Subversion Repositories SmartDukaan

Rev

Rev 6159 | Rev 6206 | 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 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    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.
525 
    Returns the final flag status.
526 
    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 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    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 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    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 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	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 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    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 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6048 rajveer 1349 
  def getServiceProviders(self, rechargeType):
1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
1353 
    """
1354 
    pass
6000 mandeep.dh 1355 
 
6049 rajveer 1356 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1357 
    """
1358 
    Parameters:
6049 rajveer 1359 
     - rechargeType
6048 rajveer 1360 
     - deviceNumber
1361 
    """
1362 
    pass
1363 
 
6094 rajveer 1364 
  def getRechargeOrdersForDevice(self, deviceNumber):
1365 
    """
1366 
    Parameters:
1367 
     - deviceNumber
1368 
    """
1369 
    pass
6048 rajveer 1370 
 
6094 rajveer 1371 
  def addAmountToWallet(self, userId, orderId, amount):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
     - orderId
1376 
     - amount
1377 
    """
1378 
    pass
1379 
 
6188 rajveer 1380 
  def getRechargeStatistics(self, ):
1381 
    pass
1382 
 
6154 rajveer 1383 
  def getRechargeOrdersForStatus(self, status):
1384 
    """
1385 
    Parameters:
1386 
     - status
1387 
    """
1388 
    pass
6094 rajveer 1389 
 
6159 rajveer 1390 
  def getPlansForOperator(self, operatorId):
1391 
    """
1392 
    Parameters:
1393 
     - operatorId
1394 
    """
1395 
    pass
6154 rajveer 1396 
 
6159 rajveer 1397 
 
3376 rajveer 1398 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1399 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1400 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1401 
 
1402 
  def createTransaction(self, transaction):
1403 
    """
1404 
    Parameters:
1405 
     - transaction
1406 
    """
1407 
    self.send_createTransaction(transaction)
132 ashish 1408 
    return self.recv_createTransaction()
94 ashish 1409 
 
1410 
  def send_createTransaction(self, transaction):
1411 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1412 
    args = createTransaction_args()
1413 
    args.transaction = transaction
1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
1418 
  def recv_createTransaction(self, ):
1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
1425 
    result = createTransaction_result()
1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
3431 rajveer 1428 
    if result.success is not None:
132 ashish 1429 
      return result.success
3431 rajveer 1430 
    if result.ex is not None:
94 ashish 1431 
      raise result.ex
132 ashish 1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1433 
 
1434 
  def getTransaction(self, id):
1435 
    """
1436 
    Parameters:
1437 
     - id
1438 
    """
1439 
    self.send_getTransaction(id)
1440 
    return self.recv_getTransaction()
1441 
 
1442 
  def send_getTransaction(self, id):
1443 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1444 
    args = getTransaction_args()
1445 
    args.id = id
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getTransaction(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = getTransaction_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
3431 rajveer 1460 
    if result.success is not None:
94 ashish 1461 
      return result.success
3431 rajveer 1462 
    if result.ex is not None:
94 ashish 1463 
      raise result.ex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1465 
 
1466 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1467 
    """
1468 
    Parameters:
1469 
     - customerId
1470 
     - from_date
1471 
     - to_date
1472 
     - status
1473 
    """
1474 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1475 
    return self.recv_getTransactionsForCustomer()
1476 
 
1477 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1478 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1479 
    args = getTransactionsForCustomer_args()
1480 
    args.customerId = customerId
1481 
    args.from_date = from_date
1482 
    args.to_date = to_date
1483 
    args.status = status
1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
1488 
  def recv_getTransactionsForCustomer(self, ):
1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
1495 
    result = getTransactionsForCustomer_result()
1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
3431 rajveer 1498 
    if result.success is not None:
94 ashish 1499 
      return result.success
3431 rajveer 1500 
    if result.ex is not None:
94 ashish 1501 
      raise result.ex
1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1503 
 
132 ashish 1504 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1505 
    """
1506 
    Parameters:
1507 
     - shoppingCartId
1508 
    """
1509 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1510 
    return self.recv_getTransactionsForShoppingCartId()
1511 
 
1512 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1513 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1514 
    args = getTransactionsForShoppingCartId_args()
1515 
    args.shoppingCartId = shoppingCartId
1516 
    args.write(self._oprot)
1517 
    self._oprot.writeMessageEnd()
1518 
    self._oprot.trans.flush()
1519 
 
1520 
  def recv_getTransactionsForShoppingCartId(self, ):
1521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1522 
    if mtype == TMessageType.EXCEPTION:
1523 
      x = TApplicationException()
1524 
      x.read(self._iprot)
1525 
      self._iprot.readMessageEnd()
1526 
      raise x
1527 
    result = getTransactionsForShoppingCartId_result()
1528 
    result.read(self._iprot)
1529 
    self._iprot.readMessageEnd()
3431 rajveer 1530 
    if result.success is not None:
132 ashish 1531 
      return result.success
3431 rajveer 1532 
    if result.ex is not None:
132 ashish 1533 
      raise result.ex
1534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1535 
 
94 ashish 1536 
  def getTransactionStatus(self, transactionId):
1537 
    """
1538 
    Parameters:
1539 
     - transactionId
1540 
    """
1541 
    self.send_getTransactionStatus(transactionId)
1542 
    return self.recv_getTransactionStatus()
1543 
 
1544 
  def send_getTransactionStatus(self, transactionId):
1545 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1546 
    args = getTransactionStatus_args()
1547 
    args.transactionId = transactionId
1548 
    args.write(self._oprot)
1549 
    self._oprot.writeMessageEnd()
1550 
    self._oprot.trans.flush()
1551 
 
1552 
  def recv_getTransactionStatus(self, ):
1553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1554 
    if mtype == TMessageType.EXCEPTION:
1555 
      x = TApplicationException()
1556 
      x.read(self._iprot)
1557 
      self._iprot.readMessageEnd()
1558 
      raise x
1559 
    result = getTransactionStatus_result()
1560 
    result.read(self._iprot)
1561 
    self._iprot.readMessageEnd()
3431 rajveer 1562 
    if result.success is not None:
94 ashish 1563 
      return result.success
3431 rajveer 1564 
    if result.ex is not None:
94 ashish 1565 
      raise result.ex
1566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1567 
 
5527 anupam.sin 1568 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1569 
    """
1570 
    Parameters:
1571 
     - transactionId
1572 
     - status
1573 
     - description
5527 anupam.sin 1574 
     - pickUp
1575 
     - orderType
94 ashish 1576 
    """
5527 anupam.sin 1577 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1578 
    return self.recv_changeTransactionStatus()
1579 
 
5527 anupam.sin 1580 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1581 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1582 
    args = changeTransactionStatus_args()
1583 
    args.transactionId = transactionId
1584 
    args.status = status
1585 
    args.description = description
5527 anupam.sin 1586 
    args.pickUp = pickUp
1587 
    args.orderType = orderType
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_changeTransactionStatus(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = changeTransactionStatus_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1607 
 
1398 varun.gupt 1608 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1609 
    """
1610 
    Parameters:
1611 
     - transactionId
1612 
    """
1398 varun.gupt 1613 
    self.send_enqueueTransactionInfoEmail(transactionId)
1614 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1615 
 
1398 varun.gupt 1616 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1617 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1618 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1619 
    args.transactionId = transactionId
1620 
    args.write(self._oprot)
1621 
    self._oprot.writeMessageEnd()
1622 
    self._oprot.trans.flush()
1623 
 
1398 varun.gupt 1624 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1626 
    if mtype == TMessageType.EXCEPTION:
1627 
      x = TApplicationException()
1628 
      x.read(self._iprot)
1629 
      self._iprot.readMessageEnd()
1630 
      raise x
1398 varun.gupt 1631 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1632 
    result.read(self._iprot)
1633 
    self._iprot.readMessageEnd()
3431 rajveer 1634 
    if result.success is not None:
1382 varun.gupt 1635 
      return result.success
3431 rajveer 1636 
    if result.ex is not None:
1382 varun.gupt 1637 
      raise result.ex
1398 varun.gupt 1638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1639 
 
4801 anupam.sin 1640 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1641 
    """
1642 
    Parameters:
4801 anupam.sin 1643 
     - statuses
483 rajveer 1644 
     - from_date
1645 
     - to_date
1646 
     - warehouse_id
94 ashish 1647 
    """
4801 anupam.sin 1648 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1649 
    return self.recv_getAllOrders()
94 ashish 1650 
 
4801 anupam.sin 1651 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1652 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1653 
    args = getAllOrders_args()
4801 anupam.sin 1654 
    args.statuses = statuses
483 rajveer 1655 
    args.from_date = from_date
1656 
    args.to_date = to_date
1657 
    args.warehouse_id = warehouse_id
94 ashish 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
483 rajveer 1662 
  def recv_getAllOrders(self, ):
94 ashish 1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
483 rajveer 1669 
    result = getAllOrders_result()
94 ashish 1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
3431 rajveer 1672 
    if result.success is not None:
94 ashish 1673 
      return result.success
3431 rajveer 1674 
    if result.ex is not None:
94 ashish 1675 
      raise result.ex
483 rajveer 1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1677 
 
4133 chandransh 1678 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1679 
    """
1680 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1681 
    Pass the status as null and the limit as 0 to ignore them.
1682 
 
1683 
    Parameters:
1684 
     - statuses
1685 
     - offset
1686 
     - limit
1687 
     - warehouse_id
1688 
    """
1689 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1690 
    return self.recv_getOrdersInBatch()
1691 
 
1692 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1693 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1694 
    args = getOrdersInBatch_args()
1695 
    args.statuses = statuses
1696 
    args.offset = offset
1697 
    args.limit = limit
1698 
    args.warehouse_id = warehouse_id
1699 
    args.write(self._oprot)
1700 
    self._oprot.writeMessageEnd()
1701 
    self._oprot.trans.flush()
1702 
 
1703 
  def recv_getOrdersInBatch(self, ):
1704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1705 
    if mtype == TMessageType.EXCEPTION:
1706 
      x = TApplicationException()
1707 
      x.read(self._iprot)
1708 
      self._iprot.readMessageEnd()
1709 
      raise x
1710 
    result = getOrdersInBatch_result()
1711 
    result.read(self._iprot)
1712 
    self._iprot.readMessageEnd()
1713 
    if result.success is not None:
1714 
      return result.success
1715 
    if result.ex is not None:
1716 
      raise result.ex
1717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1718 
 
1719 
  def getOrderCount(self, statuses, warehouseId):
1720 
    """
1721 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1722 
 
1723 
    Parameters:
1724 
     - statuses
1725 
     - warehouseId
1726 
    """
1727 
    self.send_getOrderCount(statuses, warehouseId)
1728 
    return self.recv_getOrderCount()
1729 
 
1730 
  def send_getOrderCount(self, statuses, warehouseId):
1731 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1732 
    args = getOrderCount_args()
1733 
    args.statuses = statuses
1734 
    args.warehouseId = warehouseId
1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
1739 
  def recv_getOrderCount(self, ):
1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
1746 
    result = getOrderCount_result()
1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
1749 
    if result.success is not None:
1750 
      return result.success
1751 
    if result.ex is not None:
1752 
      raise result.ex
1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1754 
 
999 varun.gupt 1755 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1756 
    """
1132 chandransh 1757 
    Returns orders within a range of their billing dates
3431 rajveer 1758 
 
999 varun.gupt 1759 
    Parameters:
1760 
     - status
1761 
     - start_billing_date
1762 
     - end_billing_date
1763 
     - warehouse_id
1764 
    """
1765 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1766 
    return self.recv_getOrdersByBillingDate()
1767 
 
1768 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1769 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1770 
    args = getOrdersByBillingDate_args()
1771 
    args.status = status
1772 
    args.start_billing_date = start_billing_date
1773 
    args.end_billing_date = end_billing_date
1774 
    args.warehouse_id = warehouse_id
1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
1779 
  def recv_getOrdersByBillingDate(self, ):
1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
1786 
    result = getOrdersByBillingDate_result()
1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
3431 rajveer 1789 
    if result.success is not None:
999 varun.gupt 1790 
      return result.success
3431 rajveer 1791 
    if result.ex is not None:
999 varun.gupt 1792 
      raise result.ex
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1794 
 
3451 chandransh 1795 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1796 
    """
1797 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1798 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1799 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1800 
 
3427 chandransh 1801 
    Parameters:
1802 
     - fromShippingDate
1803 
     - toShippingDate
1804 
     - providerId
1805 
     - warehouseId
3451 chandransh 1806 
     - cod
3427 chandransh 1807 
    """
3451 chandransh 1808 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1809 
    return self.recv_getOrdersByShippingDate()
1810 
 
3451 chandransh 1811 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1812 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1813 
    args = getOrdersByShippingDate_args()
1814 
    args.fromShippingDate = fromShippingDate
1815 
    args.toShippingDate = toShippingDate
1816 
    args.providerId = providerId
1817 
    args.warehouseId = warehouseId
3451 chandransh 1818 
    args.cod = cod
3427 chandransh 1819 
    args.write(self._oprot)
1820 
    self._oprot.writeMessageEnd()
1821 
    self._oprot.trans.flush()
1822 
 
1823 
  def recv_getOrdersByShippingDate(self, ):
1824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1825 
    if mtype == TMessageType.EXCEPTION:
1826 
      x = TApplicationException()
1827 
      x.read(self._iprot)
1828 
      self._iprot.readMessageEnd()
1829 
      raise x
1830 
    result = getOrdersByShippingDate_result()
1831 
    result.read(self._iprot)
1832 
    self._iprot.readMessageEnd()
3431 rajveer 1833 
    if result.success is not None:
3427 chandransh 1834 
      return result.success
3431 rajveer 1835 
    if result.ex is not None:
3427 chandransh 1836 
      raise result.ex
1837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1838 
 
1382 varun.gupt 1839 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1840 
    """
1841 
    Returns order ids for orders which can be returned
3431 rajveer 1842 
 
1382 varun.gupt 1843 
    Parameters:
1844 
     - customer_id
1845 
     - limit
1846 
    """
1847 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1848 
    return self.recv_getReturnableOrdersForCustomer()
1849 
 
1850 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1851 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1852 
    args = getReturnableOrdersForCustomer_args()
1853 
    args.customer_id = customer_id
1854 
    args.limit = limit
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getReturnableOrdersForCustomer(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = getReturnableOrdersForCustomer_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
3431 rajveer 1869 
    if result.success is not None:
1382 varun.gupt 1870 
      return result.success
3431 rajveer 1871 
    if result.ex is not None:
1382 varun.gupt 1872 
      raise result.ex
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1874 
 
1875 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1876 
    """
1877 
    Returns order ids for orders which can be cancelled
3431 rajveer 1878 
 
1382 varun.gupt 1879 
    Parameters:
1880 
     - customer_id
1881 
     - limit
1882 
    """
1883 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1884 
    return self.recv_getCancellableOrdersForCustomer()
1885 
 
1886 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1887 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1888 
    args = getCancellableOrdersForCustomer_args()
1889 
    args.customer_id = customer_id
1890 
    args.limit = limit
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getCancellableOrdersForCustomer(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getCancellableOrdersForCustomer_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
3431 rajveer 1905 
    if result.success is not None:
1382 varun.gupt 1906 
      return result.success
3431 rajveer 1907 
    if result.ex is not None:
1382 varun.gupt 1908 
      raise result.ex
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1910 
 
483 rajveer 1911 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1912 
    """
1913 
    Parameters:
483 rajveer 1914 
     - orderId
1915 
     - status
1916 
     - description
94 ashish 1917 
    """
483 rajveer 1918 
    self.send_changeOrderStatus(orderId, status, description)
1919 
    return self.recv_changeOrderStatus()
94 ashish 1920 
 
483 rajveer 1921 
  def send_changeOrderStatus(self, orderId, status, description):
1922 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1923 
    args = changeOrderStatus_args()
1924 
    args.orderId = orderId
1925 
    args.status = status
1926 
    args.description = description
94 ashish 1927 
    args.write(self._oprot)
1928 
    self._oprot.writeMessageEnd()
1929 
    self._oprot.trans.flush()
1930 
 
483 rajveer 1931 
  def recv_changeOrderStatus(self, ):
94 ashish 1932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1933 
    if mtype == TMessageType.EXCEPTION:
1934 
      x = TApplicationException()
1935 
      x.read(self._iprot)
1936 
      self._iprot.readMessageEnd()
1937 
      raise x
483 rajveer 1938 
    result = changeOrderStatus_result()
94 ashish 1939 
    result.read(self._iprot)
1940 
    self._iprot.readMessageEnd()
3431 rajveer 1941 
    if result.success is not None:
94 ashish 1942 
      return result.success
3431 rajveer 1943 
    if result.ex is not None:
94 ashish 1944 
      raise result.ex
483 rajveer 1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1946 
 
1528 ankur.sing 1947 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1948 
    """
1528 ankur.sing 1949 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1950 
    only user who owns the transaction can view its order details.
3431 rajveer 1951 
 
94 ashish 1952 
    Parameters:
1953 
     - transactionId
1528 ankur.sing 1954 
     - customerId
94 ashish 1955 
    """
1528 ankur.sing 1956 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1957 
    return self.recv_getOrdersForTransaction()
94 ashish 1958 
 
1528 ankur.sing 1959 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1960 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1961 
    args = getOrdersForTransaction_args()
94 ashish 1962 
    args.transactionId = transactionId
1528 ankur.sing 1963 
    args.customerId = customerId
94 ashish 1964 
    args.write(self._oprot)
1965 
    self._oprot.writeMessageEnd()
1966 
    self._oprot.trans.flush()
1967 
 
483 rajveer 1968 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1970 
    if mtype == TMessageType.EXCEPTION:
1971 
      x = TApplicationException()
1972 
      x.read(self._iprot)
1973 
      self._iprot.readMessageEnd()
1974 
      raise x
483 rajveer 1975 
    result = getOrdersForTransaction_result()
94 ashish 1976 
    result.read(self._iprot)
1977 
    self._iprot.readMessageEnd()
3431 rajveer 1978 
    if result.success is not None:
94 ashish 1979 
      return result.success
3431 rajveer 1980 
    if result.ex is not None:
94 ashish 1981 
      raise result.ex
483 rajveer 1982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1983 
 
3014 chandransh 1984 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1985 
    """
3014 chandransh 1986 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1987 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1988 
 
94 ashish 1989 
    Parameters:
483 rajveer 1990 
     - customerId
1991 
     - from_date
1992 
     - to_date
3014 chandransh 1993 
     - statuses
94 ashish 1994 
    """
3014 chandransh 1995 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1996 
    return self.recv_getOrdersForCustomer()
94 ashish 1997 
 
3014 chandransh 1998 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1999 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2000 
    args = getOrdersForCustomer_args()
2001 
    args.customerId = customerId
2002 
    args.from_date = from_date
2003 
    args.to_date = to_date
3014 chandransh 2004 
    args.statuses = statuses
94 ashish 2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
483 rajveer 2009 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
483 rajveer 2016 
    result = getOrdersForCustomer_result()
94 ashish 2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
94 ashish 2020 
      return result.success
3431 rajveer 2021 
    if result.ex is not None:
94 ashish 2022 
      raise result.ex
483 rajveer 2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2024 
 
483 rajveer 2025 
  def createOrder(self, order):
94 ashish 2026 
    """
2027 
    Parameters:
483 rajveer 2028 
     - order
94 ashish 2029 
    """
483 rajveer 2030 
    self.send_createOrder(order)
2031 
    return self.recv_createOrder()
94 ashish 2032 
 
483 rajveer 2033 
  def send_createOrder(self, order):
2034 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2035 
    args = createOrder_args()
2036 
    args.order = order
94 ashish 2037 
    args.write(self._oprot)
2038 
    self._oprot.writeMessageEnd()
2039 
    self._oprot.trans.flush()
2040 
 
483 rajveer 2041 
  def recv_createOrder(self, ):
94 ashish 2042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2043 
    if mtype == TMessageType.EXCEPTION:
2044 
      x = TApplicationException()
2045 
      x.read(self._iprot)
2046 
      self._iprot.readMessageEnd()
2047 
      raise x
483 rajveer 2048 
    result = createOrder_result()
94 ashish 2049 
    result.read(self._iprot)
2050 
    self._iprot.readMessageEnd()
3431 rajveer 2051 
    if result.success is not None:
94 ashish 2052 
      return result.success
3431 rajveer 2053 
    if result.ex is not None:
94 ashish 2054 
      raise result.ex
483 rajveer 2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2056 
 
483 rajveer 2057 
  def getOrder(self, id):
94 ashish 2058 
    """
2059 
    Parameters:
483 rajveer 2060 
     - id
94 ashish 2061 
    """
483 rajveer 2062 
    self.send_getOrder(id)
2063 
    return self.recv_getOrder()
94 ashish 2064 
 
483 rajveer 2065 
  def send_getOrder(self, id):
2066 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2067 
    args = getOrder_args()
2068 
    args.id = id
94 ashish 2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
483 rajveer 2073 
  def recv_getOrder(self, ):
94 ashish 2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
483 rajveer 2080 
    result = getOrder_result()
94 ashish 2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
3431 rajveer 2083 
    if result.success is not None:
94 ashish 2084 
      return result.success
3431 rajveer 2085 
    if result.ex is not None:
94 ashish 2086 
      raise result.ex
483 rajveer 2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2088 
 
483 rajveer 2089 
  def getLineItemsForOrder(self, orderId):
94 ashish 2090 
    """
2091 
    Parameters:
483 rajveer 2092 
     - orderId
94 ashish 2093 
    """
483 rajveer 2094 
    self.send_getLineItemsForOrder(orderId)
2095 
    return self.recv_getLineItemsForOrder()
94 ashish 2096 
 
483 rajveer 2097 
  def send_getLineItemsForOrder(self, orderId):
2098 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2099 
    args = getLineItemsForOrder_args()
2100 
    args.orderId = orderId
94 ashish 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
483 rajveer 2105 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
483 rajveer 2112 
    result = getLineItemsForOrder_result()
94 ashish 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
94 ashish 2116 
      return result.success
3431 rajveer 2117 
    if result.ex is not None:
94 ashish 2118 
      raise result.ex
483 rajveer 2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2120 
 
4999 phani.kuma 2121 
  def getOrderList(self, order_ids):
2122 
    """
2123 
    Parameters:
2124 
     - order_ids
2125 
    """
2126 
    self.send_getOrderList(order_ids)
2127 
    return self.recv_getOrderList()
2128 
 
2129 
  def send_getOrderList(self, order_ids):
2130 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2131 
    args = getOrderList_args()
2132 
    args.order_ids = order_ids
2133 
    args.write(self._oprot)
2134 
    self._oprot.writeMessageEnd()
2135 
    self._oprot.trans.flush()
2136 
 
2137 
  def recv_getOrderList(self, ):
2138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2139 
    if mtype == TMessageType.EXCEPTION:
2140 
      x = TApplicationException()
2141 
      x.read(self._iprot)
2142 
      self._iprot.readMessageEnd()
2143 
      raise x
2144 
    result = getOrderList_result()
2145 
    result.read(self._iprot)
2146 
    self._iprot.readMessageEnd()
2147 
    if result.success is not None:
2148 
      return result.success
2149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2150 
 
5386 phani.kuma 2151 
  def getOrderListForVendor(self, order_ids, vendorId):
2152 
    """
2153 
    Parameters:
2154 
     - order_ids
2155 
     - vendorId
2156 
    """
2157 
    self.send_getOrderListForVendor(order_ids, vendorId)
2158 
    return self.recv_getOrderListForVendor()
2159 
 
2160 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2161 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2162 
    args = getOrderListForVendor_args()
2163 
    args.order_ids = order_ids
2164 
    args.vendorId = vendorId
2165 
    args.write(self._oprot)
2166 
    self._oprot.writeMessageEnd()
2167 
    self._oprot.trans.flush()
2168 
 
2169 
  def recv_getOrderListForVendor(self, ):
2170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2171 
    if mtype == TMessageType.EXCEPTION:
2172 
      x = TApplicationException()
2173 
      x.read(self._iprot)
2174 
      self._iprot.readMessageEnd()
2175 
      raise x
2176 
    result = getOrderListForVendor_result()
2177 
    result.read(self._iprot)
2178 
    self._iprot.readMessageEnd()
2179 
    if result.success is not None:
2180 
      return result.success
2181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2182 
 
1528 ankur.sing 2183 
  def getOrderForCustomer(self, orderId, customerId):
2184 
    """
2185 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2186 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2187 
 
1528 ankur.sing 2188 
    Parameters:
2189 
     - orderId
2190 
     - customerId
2191 
    """
2192 
    self.send_getOrderForCustomer(orderId, customerId)
2193 
    return self.recv_getOrderForCustomer()
2194 
 
2195 
  def send_getOrderForCustomer(self, orderId, customerId):
2196 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2197 
    args = getOrderForCustomer_args()
2198 
    args.orderId = orderId
2199 
    args.customerId = customerId
2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
2204 
  def recv_getOrderForCustomer(self, ):
2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
2211 
    result = getOrderForCustomer_result()
2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
3431 rajveer 2214 
    if result.success is not None:
1528 ankur.sing 2215 
      return result.success
3431 rajveer 2216 
    if result.ex is not None:
1528 ankur.sing 2217 
      raise result.ex
2218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2219 
 
4444 rajveer 2220 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2221 
    """
2222 
    Parameters:
4394 rajveer 2223 
     - type
4444 rajveer 2224 
     - warehouseId
4394 rajveer 2225 
     - status
2226 
     - timestamp
3064 chandransh 2227 
    """
4444 rajveer 2228 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2229 
    return self.recv_getAlerts()
2230 
 
4444 rajveer 2231 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2232 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2233 
    args = getAlerts_args()
4394 rajveer 2234 
    args.type = type
4444 rajveer 2235 
    args.warehouseId = warehouseId
4394 rajveer 2236 
    args.status = status
2237 
    args.timestamp = timestamp
3064 chandransh 2238 
    args.write(self._oprot)
2239 
    self._oprot.writeMessageEnd()
2240 
    self._oprot.trans.flush()
2241 
 
2242 
  def recv_getAlerts(self, ):
2243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2244 
    if mtype == TMessageType.EXCEPTION:
2245 
      x = TApplicationException()
2246 
      x.read(self._iprot)
2247 
      self._iprot.readMessageEnd()
2248 
      raise x
2249 
    result = getAlerts_result()
2250 
    result.read(self._iprot)
2251 
    self._iprot.readMessageEnd()
3431 rajveer 2252 
    if result.success is not None:
3064 chandransh 2253 
      return result.success
2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2255 
 
4444 rajveer 2256 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2257 
    """
2258 
    Parameters:
2259 
     - type
4444 rajveer 2260 
     - warehouseId
4394 rajveer 2261 
     - description
3064 chandransh 2262 
    """
4444 rajveer 2263 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2264 
    self.recv_addAlert()
3064 chandransh 2265 
 
4444 rajveer 2266 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2267 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2268 
    args = addAlert_args()
3064 chandransh 2269 
    args.type = type
4444 rajveer 2270 
    args.warehouseId = warehouseId
4394 rajveer 2271 
    args.description = description
3064 chandransh 2272 
    args.write(self._oprot)
2273 
    self._oprot.writeMessageEnd()
2274 
    self._oprot.trans.flush()
2275 
 
4394 rajveer 2276 
  def recv_addAlert(self, ):
3064 chandransh 2277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2278 
    if mtype == TMessageType.EXCEPTION:
2279 
      x = TApplicationException()
2280 
      x.read(self._iprot)
2281 
      self._iprot.readMessageEnd()
2282 
      raise x
4394 rajveer 2283 
    result = addAlert_result()
3064 chandransh 2284 
    result.read(self._iprot)
2285 
    self._iprot.readMessageEnd()
2286 
    return
2287 
 
4444 rajveer 2288 
  def markAlertsAsSeen(self, warehouseId):
2289 
    """
2290 
    Parameters:
2291 
     - warehouseId
2292 
    """
2293 
    self.send_markAlertsAsSeen(warehouseId)
2294 
    self.recv_markAlertsAsSeen()
2295 
 
2296 
  def send_markAlertsAsSeen(self, warehouseId):
2297 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2298 
    args = markAlertsAsSeen_args()
2299 
    args.warehouseId = warehouseId
2300 
    args.write(self._oprot)
2301 
    self._oprot.writeMessageEnd()
2302 
    self._oprot.trans.flush()
2303 
 
2304 
  def recv_markAlertsAsSeen(self, ):
2305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2306 
    if mtype == TMessageType.EXCEPTION:
2307 
      x = TApplicationException()
2308 
      x.read(self._iprot)
2309 
      self._iprot.readMessageEnd()
2310 
      raise x
2311 
    result = markAlertsAsSeen_result()
2312 
    result.read(self._iprot)
2313 
    self._iprot.readMessageEnd()
2314 
    return
2315 
 
3064 chandransh 2316 
  def getValidOrderCount(self, ):
2317 
    """
2318 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2319 
    """
2320 
    self.send_getValidOrderCount()
2321 
    return self.recv_getValidOrderCount()
2322 
 
2323 
  def send_getValidOrderCount(self, ):
2324 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2325 
    args = getValidOrderCount_args()
2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_getValidOrderCount(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = getValidOrderCount_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
3064 chandransh 2341 
      return result.success
2342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2343 
 
2344 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2345 
    """
2346 
    Returns the number of distinct customers who have done successful transactions
2347 
    """
2348 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2349 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2350 
 
2351 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2352 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2353 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
2358 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
2365 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
3431 rajveer 2368 
    if result.success is not None:
3064 chandransh 2369 
      return result.success
2370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2371 
 
2372 
  def getValidOrdersAmountRange(self, ):
2373 
    """
2374 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2375 
    List contains two values, first minimum amount and second maximum amount.
2376 
    """
2377 
    self.send_getValidOrdersAmountRange()
2378 
    return self.recv_getValidOrdersAmountRange()
2379 
 
2380 
  def send_getValidOrdersAmountRange(self, ):
2381 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2382 
    args = getValidOrdersAmountRange_args()
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_getValidOrdersAmountRange(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = getValidOrdersAmountRange_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
3431 rajveer 2397 
    if result.success is not None:
3064 chandransh 2398 
      return result.success
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2400 
 
5874 rajveer 2401 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2402 
    """
2403 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2404 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2405 
 
3064 chandransh 2406 
    Parameters:
2407 
     - limit
5874 rajveer 2408 
     - onlyStore
3064 chandransh 2409 
    """
5874 rajveer 2410 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2411 
    return self.recv_getValidOrders()
2412 
 
5874 rajveer 2413 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2414 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2415 
    args = getValidOrders_args()
2416 
    args.limit = limit
5874 rajveer 2417 
    args.onlyStore = onlyStore
3064 chandransh 2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
2422 
  def recv_getValidOrders(self, ):
2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
2429 
    result = getValidOrders_result()
2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
3431 rajveer 2432 
    if result.success is not None:
3064 chandransh 2433 
      return result.success
2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2435 
 
1220 chandransh 2436 
  def batchOrders(self, warehouseId):
2437 
    """
2438 
    Create a batch of all the pending orders for the given warehouse.
2439 
    The returned list is orderd by created_timestamp.
2440 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2441 
 
1220 chandransh 2442 
    Parameters:
2443 
     - warehouseId
2444 
    """
2445 
    self.send_batchOrders(warehouseId)
2446 
    return self.recv_batchOrders()
2447 
 
2448 
  def send_batchOrders(self, warehouseId):
2449 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2450 
    args = batchOrders_args()
2451 
    args.warehouseId = warehouseId
2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_batchOrders(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = batchOrders_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
3431 rajveer 2466 
    if result.success is not None:
1220 chandransh 2467 
      return result.success
3431 rajveer 2468 
    if result.ex is not None:
1220 chandransh 2469 
      raise result.ex
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2471 
 
1208 chandransh 2472 
  def markOrderAsOutOfStock(self, orderId):
2473 
    """
2474 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2475 
 
1208 chandransh 2476 
    Parameters:
2477 
     - orderId
2478 
    """
2479 
    self.send_markOrderAsOutOfStock(orderId)
2480 
    return self.recv_markOrderAsOutOfStock()
2481 
 
2482 
  def send_markOrderAsOutOfStock(self, orderId):
2483 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2484 
    args = markOrderAsOutOfStock_args()
2485 
    args.orderId = orderId
2486 
    args.write(self._oprot)
2487 
    self._oprot.writeMessageEnd()
2488 
    self._oprot.trans.flush()
2489 
 
2490 
  def recv_markOrderAsOutOfStock(self, ):
2491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2492 
    if mtype == TMessageType.EXCEPTION:
2493 
      x = TApplicationException()
2494 
      x.read(self._iprot)
2495 
      self._iprot.readMessageEnd()
2496 
      raise x
2497 
    result = markOrderAsOutOfStock_result()
2498 
    result.read(self._iprot)
2499 
    self._iprot.readMessageEnd()
3431 rajveer 2500 
    if result.success is not None:
1208 chandransh 2501 
      return result.success
3431 rajveer 2502 
    if result.ex is not None:
1208 chandransh 2503 
      raise result.ex
2504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2505 
 
3064 chandransh 2506 
  def verifyOrder(self, orderId):
759 chandransh 2507 
    """
3064 chandransh 2508 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2509 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2510 
    used for all other orders as well.
2511 
    Throws an exception if no such order exists.
3431 rajveer 2512 
 
759 chandransh 2513 
    Parameters:
3064 chandransh 2514 
     - orderId
759 chandransh 2515 
    """
3064 chandransh 2516 
    self.send_verifyOrder(orderId)
2517 
    return self.recv_verifyOrder()
759 chandransh 2518 
 
3064 chandransh 2519 
  def send_verifyOrder(self, orderId):
2520 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2521 
    args = verifyOrder_args()
2522 
    args.orderId = orderId
759 chandransh 2523 
    args.write(self._oprot)
2524 
    self._oprot.writeMessageEnd()
2525 
    self._oprot.trans.flush()
2526 
 
3064 chandransh 2527 
  def recv_verifyOrder(self, ):
759 chandransh 2528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2529 
    if mtype == TMessageType.EXCEPTION:
2530 
      x = TApplicationException()
2531 
      x.read(self._iprot)
2532 
      self._iprot.readMessageEnd()
2533 
      raise x
3064 chandransh 2534 
    result = verifyOrder_result()
759 chandransh 2535 
    result.read(self._iprot)
2536 
    self._iprot.readMessageEnd()
3431 rajveer 2537 
    if result.success is not None:
759 chandransh 2538 
      return result.success
3431 rajveer 2539 
    if result.ex is not None:
759 chandransh 2540 
      raise result.ex
3064 chandransh 2541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2542 
 
3064 chandransh 2543 
  def acceptOrder(self, orderId):
1113 chandransh 2544 
    """
3064 chandransh 2545 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2546 
    given order is not a COD order, it also captures the payment if the same has
2547 
    not been captured.
2548 
    Throws an exception if no such order exists.
3431 rajveer 2549 
 
1113 chandransh 2550 
    Parameters:
3064 chandransh 2551 
     - orderId
1113 chandransh 2552 
    """
3064 chandransh 2553 
    self.send_acceptOrder(orderId)
2554 
    return self.recv_acceptOrder()
1113 chandransh 2555 
 
3064 chandransh 2556 
  def send_acceptOrder(self, orderId):
2557 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2558 
    args = acceptOrder_args()
2559 
    args.orderId = orderId
1113 chandransh 2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
3064 chandransh 2564 
  def recv_acceptOrder(self, ):
1113 chandransh 2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
3064 chandransh 2571 
    result = acceptOrder_result()
1113 chandransh 2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
3431 rajveer 2574 
    if result.success is not None:
1113 chandransh 2575 
      return result.success
3431 rajveer 2576 
    if result.ex is not None:
1113 chandransh 2577 
      raise result.ex
3064 chandransh 2578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2579 
 
5110 mandeep.dh 2580 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2581 
    """
3064 chandransh 2582 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2583 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2584 
    the IMEI no. if a -1 is supplied.
2585 
    Also, it generates an invoice number for the order, marks the order as
2586 
    BILLED and sets the billing timestamp.
2587 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2588 
 
1135 chandransh 2589 
    Parameters:
3064 chandransh 2590 
     - orderId
2591 
     - invoice_number
4658 mandeep.dh 2592 
     - serialNumber
4283 anupam.sin 2593 
     - itemNumber
3064 chandransh 2594 
     - billed_by
4264 rajveer 2595 
     - jacketNumber
4283 anupam.sin 2596 
     - billingType
5110 mandeep.dh 2597 
     - fulfilmentWarehouseId
4763 rajveer 2598 
     - authorize
1135 chandransh 2599 
    """
5110 mandeep.dh 2600 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2601 
    return self.recv_addBillingDetails()
1135 chandransh 2602 
 
5110 mandeep.dh 2603 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2604 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2605 
    args = addBillingDetails_args()
2606 
    args.orderId = orderId
2607 
    args.invoice_number = invoice_number
4658 mandeep.dh 2608 
    args.serialNumber = serialNumber
4283 anupam.sin 2609 
    args.itemNumber = itemNumber
3064 chandransh 2610 
    args.billed_by = billed_by
4264 rajveer 2611 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2612 
    args.billingType = billingType
5110 mandeep.dh 2613 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2614 
    args.authorize = authorize
1135 chandransh 2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
3064 chandransh 2619 
  def recv_addBillingDetails(self, ):
1135 chandransh 2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
3064 chandransh 2626 
    result = addBillingDetails_result()
1135 chandransh 2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
3431 rajveer 2629 
    if result.success is not None:
3064 chandransh 2630 
      return result.success
3431 rajveer 2631 
    if result.ex is not None:
1135 chandransh 2632 
      raise result.ex
3064 chandransh 2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2634 
 
4763 rajveer 2635 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2636 
    """
2637 
    Add the invoice number to the order.
2638 
 
2639 
    Parameters:
2640 
     - orderId
2641 
     - invoiceNumber
4763 rajveer 2642 
     - color
4579 rajveer 2643 
    """
4763 rajveer 2644 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2645 
    self.recv_addInvoiceNumber()
2646 
 
4763 rajveer 2647 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2648 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2649 
    args = addInvoiceNumber_args()
2650 
    args.orderId = orderId
2651 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2652 
    args.color = color
4579 rajveer 2653 
    args.write(self._oprot)
2654 
    self._oprot.writeMessageEnd()
2655 
    self._oprot.trans.flush()
2656 
 
2657 
  def recv_addInvoiceNumber(self, ):
2658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2659 
    if mtype == TMessageType.EXCEPTION:
2660 
      x = TApplicationException()
2661 
      x.read(self._iprot)
2662 
      self._iprot.readMessageEnd()
2663 
      raise x
2664 
    result = addInvoiceNumber_result()
2665 
    result.read(self._iprot)
2666 
    self._iprot.readMessageEnd()
2667 
    if result.ex is not None:
2668 
      raise result.ex
2669 
    return
2670 
 
4910 phani.kuma 2671 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2672 
    """
3064 chandransh 2673 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2674 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2675 
 
1408 ankur.sing 2676 
    Parameters:
3064 chandransh 2677 
     - warehouseId
1408 ankur.sing 2678 
     - providerId
3064 chandransh 2679 
     - cod
4910 phani.kuma 2680 
     - orderIds
1408 ankur.sing 2681 
    """
4910 phani.kuma 2682 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2683 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2684 
 
4910 phani.kuma 2685 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2686 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2687 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2688 
    args.warehouseId = warehouseId
1408 ankur.sing 2689 
    args.providerId = providerId
3064 chandransh 2690 
    args.cod = cod
4910 phani.kuma 2691 
    args.orderIds = orderIds
1408 ankur.sing 2692 
    args.write(self._oprot)
2693 
    self._oprot.writeMessageEnd()
2694 
    self._oprot.trans.flush()
2695 
 
4910 phani.kuma 2696 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2698 
    if mtype == TMessageType.EXCEPTION:
2699 
      x = TApplicationException()
2700 
      x.read(self._iprot)
2701 
      self._iprot.readMessageEnd()
2702 
      raise x
4910 phani.kuma 2703 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2704 
    result.read(self._iprot)
2705 
    self._iprot.readMessageEnd()
3431 rajveer 2706 
    if result.success is not None:
1408 ankur.sing 2707 
      return result.success
3431 rajveer 2708 
    if result.ex is not None:
3064 chandransh 2709 
      raise result.ex
4910 phani.kuma 2710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2711 
 
5713 rajveer 2712 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2713 
    """
2714 
    Parameters:
2715 
     - providerId
2716 
     - orderIds
5713 rajveer 2717 
     - awbs
5676 rajveer 2718 
    """
5713 rajveer 2719 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2720 
    return self.recv_markOrdersAsReturnedFromStore()
2721 
 
5713 rajveer 2722 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2723 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2724 
    args = markOrdersAsReturnedFromStore_args()
2725 
    args.providerId = providerId
2726 
    args.orderIds = orderIds
5713 rajveer 2727 
    args.awbs = awbs
5676 rajveer 2728 
    args.write(self._oprot)
2729 
    self._oprot.writeMessageEnd()
2730 
    self._oprot.trans.flush()
2731 
 
2732 
  def recv_markOrdersAsReturnedFromStore(self, ):
2733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2734 
    if mtype == TMessageType.EXCEPTION:
2735 
      x = TApplicationException()
2736 
      x.read(self._iprot)
2737 
      self._iprot.readMessageEnd()
2738 
      raise x
2739 
    result = markOrdersAsReturnedFromStore_result()
2740 
    result.read(self._iprot)
2741 
    self._iprot.readMessageEnd()
2742 
    if result.success is not None:
2743 
      return result.success
2744 
    if result.ex is not None:
2745 
      raise result.ex
2746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2747 
 
4910 phani.kuma 2748 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2749 
    """
4910 phani.kuma 2750 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2751 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2752 
 
2753 
    Parameters:
2754 
     - providerId
4910 phani.kuma 2755 
     - pickupDetails
4410 rajveer 2756 
    """
4910 phani.kuma 2757 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2758 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2759 
 
4910 phani.kuma 2760 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2761 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2762 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2763 
    args.providerId = providerId
4910 phani.kuma 2764 
    args.pickupDetails = pickupDetails
4410 rajveer 2765 
    args.write(self._oprot)
2766 
    self._oprot.writeMessageEnd()
2767 
    self._oprot.trans.flush()
2768 
 
4910 phani.kuma 2769 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2771 
    if mtype == TMessageType.EXCEPTION:
2772 
      x = TApplicationException()
2773 
      x.read(self._iprot)
2774 
      self._iprot.readMessageEnd()
2775 
      raise x
4910 phani.kuma 2776 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2777 
    result.read(self._iprot)
2778 
    self._iprot.readMessageEnd()
2779 
    if result.ex is not None:
2780 
      raise result.ex
4910 phani.kuma 2781 
    return
4410 rajveer 2782 
 
4910 phani.kuma 2783 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2784 
    """
3064 chandransh 2785 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2786 
 
94 ashish 2787 
    Parameters:
3064 chandransh 2788 
     - providerId
304 ashish 2789 
    """
4910 phani.kuma 2790 
    self.send_getOrdersNotPickedUp(providerId)
2791 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2792 
 
4910 phani.kuma 2793 
  def send_getOrdersNotPickedUp(self, providerId):
2794 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2795 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2796 
    args.providerId = providerId
304 ashish 2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
4910 phani.kuma 2801 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
4910 phani.kuma 2808 
    result = getOrdersNotPickedUp_result()
304 ashish 2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
3431 rajveer 2811 
    if result.success is not None:
304 ashish 2812 
      return result.success
4910 phani.kuma 2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2814 
 
3064 chandransh 2815 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2816 
    """
3064 chandransh 2817 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2818 
    the name of the receiver.
2819 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2820 
 
304 ashish 2821 
    Parameters:
3064 chandransh 2822 
     - providerId
2823 
     - deliveredOrders
304 ashish 2824 
    """
3064 chandransh 2825 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2826 
    self.recv_markOrdersAsDelivered()
304 ashish 2827 
 
3064 chandransh 2828 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2829 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2830 
    args = markOrdersAsDelivered_args()
2831 
    args.providerId = providerId
2832 
    args.deliveredOrders = deliveredOrders
304 ashish 2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
3064 chandransh 2837 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
3064 chandransh 2844 
    result = markOrdersAsDelivered_result()
304 ashish 2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
3431 rajveer 2847 
    if result.ex is not None:
3064 chandransh 2848 
      raise result.ex
304 ashish 2849 
    return
2850 
 
4910 phani.kuma 2851 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2852 
    """
4910 phani.kuma 2853 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2854 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2855 
 
3064 chandransh 2856 
    Parameters:
2857 
     - providerId
2858 
     - returnedOrders
1596 ankur.sing 2859 
    """
4910 phani.kuma 2860 
    self.send_markAsRTOrders(providerId, returnedOrders)
2861 
    self.recv_markAsRTOrders()
304 ashish 2862 
 
4910 phani.kuma 2863 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2864 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2865 
    args = markAsRTOrders_args()
3064 chandransh 2866 
    args.providerId = providerId
2867 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
4910 phani.kuma 2872 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
4910 phani.kuma 2879 
    result = markAsRTOrders_result()
1596 ankur.sing 2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
3431 rajveer 2882 
    if result.ex is not None:
3064 chandransh 2883 
      raise result.ex
2884 
    return
1596 ankur.sing 2885 
 
4910 phani.kuma 2886 
  def getRTOrders(self, providerId):
2887 
    """
2888 
    Returns a list of orders that were returned by courier.
2889 
 
2890 
    Parameters:
2891 
     - providerId
2892 
    """
2893 
    self.send_getRTOrders(providerId)
2894 
    return self.recv_getRTOrders()
2895 
 
2896 
  def send_getRTOrders(self, providerId):
2897 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2898 
    args = getRTOrders_args()
2899 
    args.providerId = providerId
2900 
    args.write(self._oprot)
2901 
    self._oprot.writeMessageEnd()
2902 
    self._oprot.trans.flush()
2903 
 
2904 
  def recv_getRTOrders(self, ):
2905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2906 
    if mtype == TMessageType.EXCEPTION:
2907 
      x = TApplicationException()
2908 
      x.read(self._iprot)
2909 
      self._iprot.readMessageEnd()
2910 
      raise x
2911 
    result = getRTOrders_result()
2912 
    result.read(self._iprot)
2913 
    self._iprot.readMessageEnd()
2914 
    if result.success is not None:
2915 
      return result.success
2916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2917 
 
3064 chandransh 2918 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2919 
    """
3064 chandransh 2920 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2921 
 
3064 chandransh 2922 
    Parameters:
2923 
     - providerId
2924 
     - undeliveredOrders
1627 ankur.sing 2925 
    """
3064 chandransh 2926 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2927 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2928 
 
3064 chandransh 2929 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2930 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2931 
    args = updateNonDeliveryReason_args()
2932 
    args.providerId = providerId
2933 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2934 
    args.write(self._oprot)
2935 
    self._oprot.writeMessageEnd()
2936 
    self._oprot.trans.flush()
2937 
 
3064 chandransh 2938 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2940 
    if mtype == TMessageType.EXCEPTION:
2941 
      x = TApplicationException()
2942 
      x.read(self._iprot)
2943 
      self._iprot.readMessageEnd()
2944 
      raise x
3064 chandransh 2945 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2946 
    result.read(self._iprot)
2947 
    self._iprot.readMessageEnd()
4910 phani.kuma 2948 
    if result.ex is not None:
2949 
      raise result.ex
2950 
    return
2951 
 
2952 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2953 
    """
2954 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2955 
 
2956 
    Parameters:
2957 
     - providerId
2958 
    """
2959 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2960 
    return self.recv_getNonDeliveredOrdersbyCourier()
2961 
 
2962 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2963 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2964 
    args = getNonDeliveredOrdersbyCourier_args()
2965 
    args.providerId = providerId
2966 
    args.write(self._oprot)
2967 
    self._oprot.writeMessageEnd()
2968 
    self._oprot.trans.flush()
2969 
 
2970 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2972 
    if mtype == TMessageType.EXCEPTION:
2973 
      x = TApplicationException()
2974 
      x.read(self._iprot)
2975 
      self._iprot.readMessageEnd()
2976 
      raise x
2977 
    result = getNonDeliveredOrdersbyCourier_result()
2978 
    result.read(self._iprot)
2979 
    self._iprot.readMessageEnd()
4581 phani.kuma 2980 
    if result.success is not None:
2981 
      return result.success
4910 phani.kuma 2982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2983 
 
2984 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2985 
    """
2986 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2987 
 
2988 
    Parameters:
2989 
     - providerId
2990 
     - local_connected_orders
2991 
    """
2992 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2993 
    self.recv_markOrdersAsLocalConnected()
2994 
 
2995 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2996 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2997 
    args = markOrdersAsLocalConnected_args()
2998 
    args.providerId = providerId
2999 
    args.local_connected_orders = local_connected_orders
3000 
    args.write(self._oprot)
3001 
    self._oprot.writeMessageEnd()
3002 
    self._oprot.trans.flush()
3003 
 
3004 
  def recv_markOrdersAsLocalConnected(self, ):
3005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3006 
    if mtype == TMessageType.EXCEPTION:
3007 
      x = TApplicationException()
3008 
      x.read(self._iprot)
3009 
      self._iprot.readMessageEnd()
3010 
      raise x
3011 
    result = markOrdersAsLocalConnected_result()
3012 
    result.read(self._iprot)
3013 
    self._iprot.readMessageEnd()
3431 rajveer 3014 
    if result.ex is not None:
3064 chandransh 3015 
      raise result.ex
4910 phani.kuma 3016 
    return
1627 ankur.sing 3017 
 
4910 phani.kuma 3018 
  def getOrdersNotLocalConnected(self, providerId):
3019 
    """
3020 
    Returns a list of orders that were picked up or shipped but pending local connection.
3021 
 
3022 
    Parameters:
3023 
     - providerId
3024 
    """
3025 
    self.send_getOrdersNotLocalConnected(providerId)
3026 
    return self.recv_getOrdersNotLocalConnected()
3027 
 
3028 
  def send_getOrdersNotLocalConnected(self, providerId):
3029 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3030 
    args = getOrdersNotLocalConnected_args()
3031 
    args.providerId = providerId
3032 
    args.write(self._oprot)
3033 
    self._oprot.writeMessageEnd()
3034 
    self._oprot.trans.flush()
3035 
 
3036 
  def recv_getOrdersNotLocalConnected(self, ):
3037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3038 
    if mtype == TMessageType.EXCEPTION:
3039 
      x = TApplicationException()
3040 
      x.read(self._iprot)
3041 
      self._iprot.readMessageEnd()
3042 
      raise x
3043 
    result = getOrdersNotLocalConnected_result()
3044 
    result.read(self._iprot)
3045 
    self._iprot.readMessageEnd()
3046 
    if result.success is not None:
3047 
      return result.success
3048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3049 
 
3050 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3051 
    """
3052 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3053 
 
3054 
    Parameters:
3055 
     - providerId
3056 
     - destination_city_reached_orders
3057 
    """
3058 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3059 
    self.recv_markOrdersAsDestinationCityReached()
3060 
 
3061 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3062 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3063 
    args = markOrdersAsDestinationCityReached_args()
3064 
    args.providerId = providerId
3065 
    args.destination_city_reached_orders = destination_city_reached_orders
3066 
    args.write(self._oprot)
3067 
    self._oprot.writeMessageEnd()
3068 
    self._oprot.trans.flush()
3069 
 
3070 
  def recv_markOrdersAsDestinationCityReached(self, ):
3071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3072 
    if mtype == TMessageType.EXCEPTION:
3073 
      x = TApplicationException()
3074 
      x.read(self._iprot)
3075 
      self._iprot.readMessageEnd()
3076 
      raise x
3077 
    result = markOrdersAsDestinationCityReached_result()
3078 
    result.read(self._iprot)
3079 
    self._iprot.readMessageEnd()
3080 
    if result.ex is not None:
3081 
      raise result.ex
3082 
    return
3083 
 
3084 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3085 
    """
3086 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3087 
 
3088 
    Parameters:
3089 
     - providerId
3090 
     - first_atdl_orders
3091 
    """
3092 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3093 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3094 
 
3095 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3096 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3097 
    args = markOrdersAsFirstDeliveryAttempted_args()
3098 
    args.providerId = providerId
3099 
    args.first_atdl_orders = first_atdl_orders
3100 
    args.write(self._oprot)
3101 
    self._oprot.writeMessageEnd()
3102 
    self._oprot.trans.flush()
3103 
 
3104 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3106 
    if mtype == TMessageType.EXCEPTION:
3107 
      x = TApplicationException()
3108 
      x.read(self._iprot)
3109 
      self._iprot.readMessageEnd()
3110 
      raise x
3111 
    result = markOrdersAsFirstDeliveryAttempted_result()
3112 
    result.read(self._iprot)
3113 
    self._iprot.readMessageEnd()
3114 
    if result.ex is not None:
3115 
      raise result.ex
3116 
    return
3117 
 
3064 chandransh 3118 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3119 
    """
3064 chandransh 3120 
    Returns the list of orders whose delivery time has passed but have not been
3121 
    delivered yet for the given provider and warehouse. To get a complete list of
3122 
    undelivered orders, pass them as -1.
3123 
    Returns an empty list if no such orders exist.
3431 rajveer 3124 
 
1886 ankur.sing 3125 
    Parameters:
3064 chandransh 3126 
     - providerId
3127 
     - warehouseId
1886 ankur.sing 3128 
    """
3064 chandransh 3129 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3130 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3131 
 
3064 chandransh 3132 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3133 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3134 
    args = getUndeliveredOrders_args()
3135 
    args.providerId = providerId
3136 
    args.warehouseId = warehouseId
1886 ankur.sing 3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3064 chandransh 3141 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3064 chandransh 3148 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3431 rajveer 3151 
    if result.success is not None:
1886 ankur.sing 3152 
      return result.success
3064 chandransh 3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3154 
 
4783 phani.kuma 3155 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3156 
    """
3157 
    Returns the list of orders whose expected delivery date has passed but have not been
3158 
    delivered yet.
3159 
    Returns an empty list if no such orders exist.
3160 
    """
3161 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3162 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3163 
 
3164 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3165 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3166 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
3183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3184 
 
2536 chandransh 3185 
  def toggleDOAFlag(self, orderId):
3186 
    """
3187 
    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.
3188 
    Returns the final flag status.
3189 
    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 3190 
 
2536 chandransh 3191 
    Parameters:
3192 
     - orderId
3193 
    """
3194 
    self.send_toggleDOAFlag(orderId)
3195 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3196 
 
2536 chandransh 3197 
  def send_toggleDOAFlag(self, orderId):
3198 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3199 
    args = toggleDOAFlag_args()
3200 
    args.orderId = orderId
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_toggleDOAFlag(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = toggleDOAFlag_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3431 rajveer 3215 
    if result.success is not None:
2536 chandransh 3216 
      return result.success
3431 rajveer 3217 
    if result.ex is not None:
2536 chandransh 3218 
      raise result.ex
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3220 
 
4712 rajveer 3221 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3222 
    """
3223 
    Parameters:
3224 
     - orderId
3225 
     - deliveryTimestamp
3226 
     - receiver
3227 
    """
3228 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3229 
    self.recv_markOrderAsDelivered()
3230 
 
3231 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3232 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3233 
    args = markOrderAsDelivered_args()
3234 
    args.orderId = orderId
3235 
    args.deliveryTimestamp = deliveryTimestamp
3236 
    args.receiver = receiver
3237 
    args.write(self._oprot)
3238 
    self._oprot.writeMessageEnd()
3239 
    self._oprot.trans.flush()
3240 
 
3241 
  def recv_markOrderAsDelivered(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 = markOrderAsDelivered_result()
3249 
    result.read(self._iprot)
3250 
    self._iprot.readMessageEnd()
3251 
    if result.ex is not None:
3252 
      raise result.ex
3253 
    return
3254 
 
5553 rajveer 3255 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3256 
    """
3257 
    Parameters:
3258 
     - orderId
3259 
     - deliveryTimestamp
3260 
    """
3261 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3262 
    self.recv_markOrderAsReceivedAtStore()
3263 
 
3264 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3265 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3266 
    args = markOrderAsReceivedAtStore_args()
3267 
    args.orderId = orderId
3268 
    args.deliveryTimestamp = deliveryTimestamp
3269 
    args.write(self._oprot)
3270 
    self._oprot.writeMessageEnd()
3271 
    self._oprot.trans.flush()
3272 
 
3273 
  def recv_markOrderAsReceivedAtStore(self, ):
3274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3275 
    if mtype == TMessageType.EXCEPTION:
3276 
      x = TApplicationException()
3277 
      x.read(self._iprot)
3278 
      self._iprot.readMessageEnd()
3279 
      raise x
3280 
    result = markOrderAsReceivedAtStore_result()
3281 
    result.read(self._iprot)
3282 
    self._iprot.readMessageEnd()
3283 
    if result.ex is not None:
3284 
      raise result.ex
3285 
    return
3286 
 
4454 rajveer 3287 
  def markOrderDoaRequestReceived(self, orderId):
3288 
    """
3289 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3290 
 
3291 
    Parameters:
3292 
     - orderId
3293 
    """
3294 
    self.send_markOrderDoaRequestReceived(orderId)
3295 
    return self.recv_markOrderDoaRequestReceived()
3296 
 
3297 
  def send_markOrderDoaRequestReceived(self, orderId):
3298 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3299 
    args = markOrderDoaRequestReceived_args()
3300 
    args.orderId = orderId
3301 
    args.write(self._oprot)
3302 
    self._oprot.writeMessageEnd()
3303 
    self._oprot.trans.flush()
3304 
 
3305 
  def recv_markOrderDoaRequestReceived(self, ):
3306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3307 
    if mtype == TMessageType.EXCEPTION:
3308 
      x = TApplicationException()
3309 
      x.read(self._iprot)
3310 
      self._iprot.readMessageEnd()
3311 
      raise x
3312 
    result = markOrderDoaRequestReceived_result()
3313 
    result.read(self._iprot)
3314 
    self._iprot.readMessageEnd()
3315 
    if result.success is not None:
3316 
      return result.success
3317 
    if result.ex is not None:
3318 
      raise result.ex
3319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3320 
 
3321 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3322 
    """
3323 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3324 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3325 
 
3326 
    Parameters:
3327 
     - orderId
3328 
     - isAuthorized
3329 
    """
3330 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3331 
    return self.recv_markOrderDoaRequestAuthorized()
3332 
 
3333 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3334 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3335 
    args = markOrderDoaRequestAuthorized_args()
3336 
    args.orderId = orderId
3337 
    args.isAuthorized = isAuthorized
3338 
    args.write(self._oprot)
3339 
    self._oprot.writeMessageEnd()
3340 
    self._oprot.trans.flush()
3341 
 
3342 
  def recv_markOrderDoaRequestAuthorized(self, ):
3343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3344 
    if mtype == TMessageType.EXCEPTION:
3345 
      x = TApplicationException()
3346 
      x.read(self._iprot)
3347 
      self._iprot.readMessageEnd()
3348 
      raise x
3349 
    result = markOrderDoaRequestAuthorized_result()
3350 
    result.read(self._iprot)
3351 
    self._iprot.readMessageEnd()
3352 
    if result.success is not None:
3353 
      return result.success
3354 
    if result.ex is not None:
3355 
      raise result.ex
3356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3357 
 
4488 rajveer 3358 
  def markOrderReturnRequestReceived(self, orderId):
3359 
    """
3360 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3361 
 
3362 
    Parameters:
3363 
     - orderId
3364 
    """
3365 
    self.send_markOrderReturnRequestReceived(orderId)
3366 
    return self.recv_markOrderReturnRequestReceived()
3367 
 
3368 
  def send_markOrderReturnRequestReceived(self, orderId):
3369 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3370 
    args = markOrderReturnRequestReceived_args()
3371 
    args.orderId = orderId
3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
3376 
  def recv_markOrderReturnRequestReceived(self, ):
3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
3383 
    result = markOrderReturnRequestReceived_result()
3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3386 
    if result.success is not None:
3387 
      return result.success
3388 
    if result.ex is not None:
3389 
      raise result.ex
3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3391 
 
3392 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3393 
    """
3394 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3395 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3396 
 
3397 
    Parameters:
3398 
     - orderId
3399 
     - isAuthorized
3400 
    """
3401 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3402 
    return self.recv_markOrderReturnRequestAuthorized()
3403 
 
3404 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3405 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3406 
    args = markOrderReturnRequestAuthorized_args()
3407 
    args.orderId = orderId
3408 
    args.isAuthorized = isAuthorized
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_markOrderReturnRequestAuthorized(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = markOrderReturnRequestAuthorized_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    if result.success is not None:
3424 
      return result.success
3425 
    if result.ex is not None:
3426 
      raise result.ex
3427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3428 
 
4579 rajveer 3429 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3430 
    """
3431 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3432 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3433 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3434 
    For any other status, it returns false.
3435 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3436 
 
2536 chandransh 3437 
    Parameters:
3438 
     - orderId
4579 rajveer 3439 
     - providerId
2536 chandransh 3440 
    """
4579 rajveer 3441 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3442 
    return self.recv_requestPickupNumber()
3443 
 
4579 rajveer 3444 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3445 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3446 
    args = requestPickupNumber_args()
3447 
    args.orderId = orderId
4579 rajveer 3448 
    args.providerId = providerId
2536 chandransh 3449 
    args.write(self._oprot)
3450 
    self._oprot.writeMessageEnd()
3451 
    self._oprot.trans.flush()
3452 
 
3453 
  def recv_requestPickupNumber(self, ):
3454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3455 
    if mtype == TMessageType.EXCEPTION:
3456 
      x = TApplicationException()
3457 
      x.read(self._iprot)
3458 
      self._iprot.readMessageEnd()
3459 
      raise x
3460 
    result = requestPickupNumber_result()
3461 
    result.read(self._iprot)
3462 
    self._iprot.readMessageEnd()
3431 rajveer 3463 
    if result.success is not None:
2536 chandransh 3464 
      return result.success
3431 rajveer 3465 
    if result.ex is not None:
2536 chandransh 3466 
      raise result.ex
3467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3468 
 
4602 rajveer 3469 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3470 
    """
4452 rajveer 3471 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3472 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3473 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3474 
    	3. Returns true
2591 chandransh 3475 
    If the order is in any other status, it returns false.
2536 chandransh 3476 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3477 
 
2536 chandransh 3478 
    Parameters:
3479 
     - orderId
3480 
     - pickupNumber
4602 rajveer 3481 
     - providerId
2536 chandransh 3482 
    """
4602 rajveer 3483 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3484 
    return self.recv_authorizePickup()
3485 
 
4602 rajveer 3486 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3487 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3488 
    args = authorizePickup_args()
3489 
    args.orderId = orderId
3490 
    args.pickupNumber = pickupNumber
4602 rajveer 3491 
    args.providerId = providerId
2536 chandransh 3492 
    args.write(self._oprot)
3493 
    self._oprot.writeMessageEnd()
3494 
    self._oprot.trans.flush()
3495 
 
3496 
  def recv_authorizePickup(self, ):
3497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3498 
    if mtype == TMessageType.EXCEPTION:
3499 
      x = TApplicationException()
3500 
      x.read(self._iprot)
3501 
      self._iprot.readMessageEnd()
3502 
      raise x
3503 
    result = authorizePickup_result()
3504 
    result.read(self._iprot)
3505 
    self._iprot.readMessageEnd()
3431 rajveer 3506 
    if result.success is not None:
2536 chandransh 3507 
      return result.success
3431 rajveer 3508 
    if result.ex is not None:
2536 chandransh 3509 
      raise result.ex
3510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3511 
 
2764 chandransh 3512 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3513 
    """
3514 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3515 
 
2764 chandransh 3516 
    Parameters:
3517 
     - providerId
3518 
     - pickupDetails
3519 
    """
3520 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3521 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3522 
 
3523 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3524 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3525 
    args = markDoasAsPickedUp_args()
3526 
    args.providerId = providerId
3527 
    args.pickupDetails = pickupDetails
3528 
    args.write(self._oprot)
3529 
    self._oprot.writeMessageEnd()
3530 
    self._oprot.trans.flush()
3531 
 
3532 
  def recv_markDoasAsPickedUp(self, ):
3533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3534 
    if mtype == TMessageType.EXCEPTION:
3535 
      x = TApplicationException()
3536 
      x.read(self._iprot)
3537 
      self._iprot.readMessageEnd()
3538 
      raise x
3539 
    result = markDoasAsPickedUp_result()
3540 
    result.read(self._iprot)
3541 
    self._iprot.readMessageEnd()
4910 phani.kuma 3542 
    return
3543 
 
3544 
  def getDoasNotPickedUp(self, providerId):
3545 
    """
3546 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3547 
 
3548 
    Parameters:
3549 
     - providerId
3550 
    """
3551 
    self.send_getDoasNotPickedUp(providerId)
3552 
    return self.recv_getDoasNotPickedUp()
3553 
 
3554 
  def send_getDoasNotPickedUp(self, providerId):
3555 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3556 
    args = getDoasNotPickedUp_args()
3557 
    args.providerId = providerId
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_getDoasNotPickedUp(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = getDoasNotPickedUp_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
3431 rajveer 3572 
    if result.success is not None:
2764 chandransh 3573 
      return result.success
4910 phani.kuma 3574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3575 
 
4741 phani.kuma 3576 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3577 
    """
3578 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3579 
 
3580 
    Parameters:
3581 
     - providerId
3582 
     - pickupDetails
3583 
    """
3584 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3585 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3586 
 
3587 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3588 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3589 
    args = markReturnOrdersAsPickedUp_args()
3590 
    args.providerId = providerId
3591 
    args.pickupDetails = pickupDetails
3592 
    args.write(self._oprot)
3593 
    self._oprot.writeMessageEnd()
3594 
    self._oprot.trans.flush()
3595 
 
3596 
  def recv_markReturnOrdersAsPickedUp(self, ):
3597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3598 
    if mtype == TMessageType.EXCEPTION:
3599 
      x = TApplicationException()
3600 
      x.read(self._iprot)
3601 
      self._iprot.readMessageEnd()
3602 
      raise x
3603 
    result = markReturnOrdersAsPickedUp_result()
3604 
    result.read(self._iprot)
3605 
    self._iprot.readMessageEnd()
4910 phani.kuma 3606 
    return
3607 
 
3608 
  def getReturnOrdersNotPickedUp(self, providerId):
3609 
    """
3610 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3611 
 
3612 
    Parameters:
3613 
     - providerId
3614 
    """
3615 
    self.send_getReturnOrdersNotPickedUp(providerId)
3616 
    return self.recv_getReturnOrdersNotPickedUp()
3617 
 
3618 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3619 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3620 
    args = getReturnOrdersNotPickedUp_args()
3621 
    args.providerId = providerId
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_getReturnOrdersNotPickedUp(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = getReturnOrdersNotPickedUp_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
4741 phani.kuma 3636 
    if result.success is not None:
3637 
      return result.success
4910 phani.kuma 3638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3639 
 
4479 rajveer 3640 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3641 
    """
4452 rajveer 3642 
    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 3643 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3644 
    If the order is in any other state, it returns false.
3645 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3646 
 
2591 chandransh 3647 
    Parameters:
3648 
     - orderId
4479 rajveer 3649 
     - receiveCondition
2591 chandransh 3650 
    """
4479 rajveer 3651 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3652 
    return self.recv_receiveReturn()
2536 chandransh 3653 
 
4479 rajveer 3654 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3655 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3656 
    args = receiveReturn_args()
2591 chandransh 3657 
    args.orderId = orderId
4479 rajveer 3658 
    args.receiveCondition = receiveCondition
2591 chandransh 3659 
    args.write(self._oprot)
3660 
    self._oprot.writeMessageEnd()
3661 
    self._oprot.trans.flush()
3662 
 
2616 chandransh 3663 
  def recv_receiveReturn(self, ):
2591 chandransh 3664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3665 
    if mtype == TMessageType.EXCEPTION:
3666 
      x = TApplicationException()
3667 
      x.read(self._iprot)
3668 
      self._iprot.readMessageEnd()
3669 
      raise x
2616 chandransh 3670 
    result = receiveReturn_result()
2591 chandransh 3671 
    result.read(self._iprot)
3672 
    self._iprot.readMessageEnd()
3431 rajveer 3673 
    if result.success is not None:
2591 chandransh 3674 
      return result.success
3431 rajveer 3675 
    if result.ex is not None:
2591 chandransh 3676 
      raise result.ex
2616 chandransh 3677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3678 
 
3679 
  def validateDoa(self, orderId, isValid):
3680 
    """
4452 rajveer 3681 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3682 
    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 3683 
    If the order is in any other state, it returns false.
3684 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3685 
 
2591 chandransh 3686 
    Parameters:
3687 
     - orderId
3688 
     - isValid
3689 
    """
3690 
    self.send_validateDoa(orderId, isValid)
3691 
    return self.recv_validateDoa()
3692 
 
3693 
  def send_validateDoa(self, orderId, isValid):
3694 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3695 
    args = validateDoa_args()
3696 
    args.orderId = orderId
3697 
    args.isValid = isValid
3698 
    args.write(self._oprot)
3699 
    self._oprot.writeMessageEnd()
3700 
    self._oprot.trans.flush()
3701 
 
3702 
  def recv_validateDoa(self, ):
3703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3704 
    if mtype == TMessageType.EXCEPTION:
3705 
      x = TApplicationException()
3706 
      x.read(self._iprot)
3707 
      self._iprot.readMessageEnd()
3708 
      raise x
3709 
    result = validateDoa_result()
3710 
    result.read(self._iprot)
3711 
    self._iprot.readMessageEnd()
3431 rajveer 3712 
    if result.success is not None:
2591 chandransh 3713 
      return result.success
3431 rajveer 3714 
    if result.ex is not None:
2591 chandransh 3715 
      raise result.ex
3716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3717 
 
4495 rajveer 3718 
  def validateReturnProduct(self, orderId, isUsable):
3719 
    """
3720 
    Parameters:
3721 
     - orderId
3722 
     - isUsable
3723 
    """
3724 
    self.send_validateReturnProduct(orderId, isUsable)
3725 
    return self.recv_validateReturnProduct()
3726 
 
3727 
  def send_validateReturnProduct(self, orderId, isUsable):
3728 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3729 
    args = validateReturnProduct_args()
3730 
    args.orderId = orderId
3731 
    args.isUsable = isUsable
3732 
    args.write(self._oprot)
3733 
    self._oprot.writeMessageEnd()
3734 
    self._oprot.trans.flush()
3735 
 
3736 
  def recv_validateReturnProduct(self, ):
3737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3738 
    if mtype == TMessageType.EXCEPTION:
3739 
      x = TApplicationException()
3740 
      x.read(self._iprot)
3741 
      self._iprot.readMessageEnd()
3742 
      raise x
3743 
    result = validateReturnProduct_result()
3744 
    result.read(self._iprot)
3745 
    self._iprot.readMessageEnd()
3746 
    if result.success is not None:
3747 
      return result.success
3748 
    if result.ex is not None:
3749 
      raise result.ex
3750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3751 
 
2616 chandransh 3752 
  def reshipOrder(self, orderId):
3753 
    """
4484 rajveer 3754 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3755 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3756 
    	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 3757 
 
3758 
    If the order is in DOA_CERT_VALID state, it does the following:
3759 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3760 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3761 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3762 
 
2616 chandransh 3763 
    Returns the id of the newly created order.
3431 rajveer 3764 
 
2616 chandransh 3765 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3766 
 
2616 chandransh 3767 
    Parameters:
3768 
     - orderId
3769 
    """
3770 
    self.send_reshipOrder(orderId)
3771 
    return self.recv_reshipOrder()
2591 chandransh 3772 
 
2616 chandransh 3773 
  def send_reshipOrder(self, orderId):
3774 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3775 
    args = reshipOrder_args()
3776 
    args.orderId = orderId
3777 
    args.write(self._oprot)
3778 
    self._oprot.writeMessageEnd()
3779 
    self._oprot.trans.flush()
3780 
 
3781 
  def recv_reshipOrder(self, ):
3782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3783 
    if mtype == TMessageType.EXCEPTION:
3784 
      x = TApplicationException()
3785 
      x.read(self._iprot)
3786 
      self._iprot.readMessageEnd()
3787 
      raise x
3788 
    result = reshipOrder_result()
3789 
    result.read(self._iprot)
3790 
    self._iprot.readMessageEnd()
3431 rajveer 3791 
    if result.success is not None:
2616 chandransh 3792 
      return result.success
3431 rajveer 3793 
    if result.ex is not None:
2616 chandransh 3794 
      raise result.ex
3795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3796 
 
3226 chandransh 3797 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3798 
    """
4484 rajveer 3799 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3800 
    	1. Creates a refund request for batch processing.
3801 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3802 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3803 
 
2616 chandransh 3804 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3805 
    	1. Creates a refund request for batch processing.
3226 chandransh 3806 
    	2. Cancels the reservation of the item in the warehouse.
3807 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3808 
 
3226 chandransh 3809 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3810 
    	1. Cancels the reservation of the item in the warehouse.
3811 
    	2. Marks the current order as CANCELED.
3812 
 
3813 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3814 
 
2616 chandransh 3815 
    Returns True if it is successful, False otherwise.
3431 rajveer 3816 
 
2616 chandransh 3817 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3818 
 
2616 chandransh 3819 
    Parameters:
3820 
     - orderId
3226 chandransh 3821 
     - refundedBy
3822 
     - reason
2616 chandransh 3823 
    """
3226 chandransh 3824 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3825 
    return self.recv_refundOrder()
3826 
 
3226 chandransh 3827 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3828 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3829 
    args = refundOrder_args()
3830 
    args.orderId = orderId
3226 chandransh 3831 
    args.refundedBy = refundedBy
3832 
    args.reason = reason
2616 chandransh 3833 
    args.write(self._oprot)
3834 
    self._oprot.writeMessageEnd()
3835 
    self._oprot.trans.flush()
3836 
 
3837 
  def recv_refundOrder(self, ):
3838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3839 
    if mtype == TMessageType.EXCEPTION:
3840 
      x = TApplicationException()
3841 
      x.read(self._iprot)
3842 
      self._iprot.readMessageEnd()
3843 
      raise x
3844 
    result = refundOrder_result()
3845 
    result.read(self._iprot)
3846 
    self._iprot.readMessageEnd()
3431 rajveer 3847 
    if result.success is not None:
2616 chandransh 3848 
      return result.success
3431 rajveer 3849 
    if result.ex is not None:
2616 chandransh 3850 
      raise result.ex
3851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3852 
 
2690 chandransh 3853 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3854 
    """
3855 
    Get all return orders created between the from and to dates for the given warehouse.
3856 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3857 
 
2690 chandransh 3858 
    Parameters:
3859 
     - warehouseId
3860 
     - fromDate
3861 
     - toDate
3862 
    """
3863 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3864 
    return self.recv_getReturnOrders()
2616 chandransh 3865 
 
2690 chandransh 3866 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3867 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3868 
    args = getReturnOrders_args()
3869 
    args.warehouseId = warehouseId
3870 
    args.fromDate = fromDate
3871 
    args.toDate = toDate
3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_getReturnOrders(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = getReturnOrders_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3431 rajveer 3886 
    if result.success is not None:
2690 chandransh 3887 
      return result.success
3888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3889 
 
5481 phani.kuma 3890 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3891 
    """
3892 
    Get all return orders created between the from and to dates.
3893 
 
3894 
    Parameters:
3895 
     - onlyNotProcessed
3896 
     - fromDate
3897 
     - toDate
3898 
    """
3899 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3900 
    return self.recv_getAllReturnOrders()
3901 
 
3902 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3903 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3904 
    args = getAllReturnOrders_args()
3905 
    args.onlyNotProcessed = onlyNotProcessed
3906 
    args.fromDate = fromDate
3907 
    args.toDate = toDate
3908 
    args.write(self._oprot)
3909 
    self._oprot.writeMessageEnd()
3910 
    self._oprot.trans.flush()
3911 
 
3912 
  def recv_getAllReturnOrders(self, ):
3913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3914 
    if mtype == TMessageType.EXCEPTION:
3915 
      x = TApplicationException()
3916 
      x.read(self._iprot)
3917 
      self._iprot.readMessageEnd()
3918 
      raise x
3919 
    result = getAllReturnOrders_result()
3920 
    result.read(self._iprot)
3921 
    self._iprot.readMessageEnd()
3922 
    if result.success is not None:
3923 
      return result.success
3924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3925 
 
2700 chandransh 3926 
  def getReturnOrder(self, id):
3927 
    """
3928 
    Returns the ReturnOrder corresponding to the given id.
3929 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3930 
 
2700 chandransh 3931 
    Parameters:
3932 
     - id
3933 
    """
3934 
    self.send_getReturnOrder(id)
3935 
    return self.recv_getReturnOrder()
3936 
 
3937 
  def send_getReturnOrder(self, id):
3938 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3939 
    args = getReturnOrder_args()
3940 
    args.id = id
3941 
    args.write(self._oprot)
3942 
    self._oprot.writeMessageEnd()
3943 
    self._oprot.trans.flush()
3944 
 
3945 
  def recv_getReturnOrder(self, ):
3946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3947 
    if mtype == TMessageType.EXCEPTION:
3948 
      x = TApplicationException()
3949 
      x.read(self._iprot)
3950 
      self._iprot.readMessageEnd()
3951 
      raise x
3952 
    result = getReturnOrder_result()
3953 
    result.read(self._iprot)
3954 
    self._iprot.readMessageEnd()
3431 rajveer 3955 
    if result.success is not None:
2700 chandransh 3956 
      return result.success
3431 rajveer 3957 
    if result.ex is not None:
2700 chandransh 3958 
      raise result.ex
3959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3960 
 
2690 chandransh 3961 
  def processReturn(self, returnOrderId):
3962 
    """
3963 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3964 
 
2690 chandransh 3965 
    Parameters:
3966 
     - returnOrderId
3967 
    """
3968 
    self.send_processReturn(returnOrderId)
3969 
    self.recv_processReturn()
3970 
 
3971 
  def send_processReturn(self, returnOrderId):
3972 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3973 
    args = processReturn_args()
3974 
    args.returnOrderId = returnOrderId
3975 
    args.write(self._oprot)
3976 
    self._oprot.writeMessageEnd()
3977 
    self._oprot.trans.flush()
3978 
 
3979 
  def recv_processReturn(self, ):
3980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3981 
    if mtype == TMessageType.EXCEPTION:
3982 
      x = TApplicationException()
3983 
      x.read(self._iprot)
3984 
      self._iprot.readMessageEnd()
3985 
      raise x
3986 
    result = processReturn_result()
3987 
    result.read(self._iprot)
3988 
    self._iprot.readMessageEnd()
3431 rajveer 3989 
    if result.ex is not None:
2690 chandransh 3990 
      raise result.ex
3991 
    return
3992 
 
3451 chandransh 3993 
  def updateWeight(self, orderId, weight):
3994 
    """
3995 
    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 3996 
 
3451 chandransh 3997 
    Parameters:
3998 
     - orderId
3999 
     - weight
4000 
    """
4001 
    self.send_updateWeight(orderId, weight)
4002 
    return self.recv_updateWeight()
4003 
 
4004 
  def send_updateWeight(self, orderId, weight):
4005 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4006 
    args = updateWeight_args()
4007 
    args.orderId = orderId
4008 
    args.weight = weight
4009 
    args.write(self._oprot)
4010 
    self._oprot.writeMessageEnd()
4011 
    self._oprot.trans.flush()
4012 
 
4013 
  def recv_updateWeight(self, ):
4014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4015 
    if mtype == TMessageType.EXCEPTION:
4016 
      x = TApplicationException()
4017 
      x.read(self._iprot)
4018 
      self._iprot.readMessageEnd()
4019 
      raise x
4020 
    result = updateWeight_result()
4021 
    result.read(self._iprot)
4022 
    self._iprot.readMessageEnd()
4023 
    if result.success is not None:
4024 
      return result.success
4025 
    if result.ex is not None:
4026 
      raise result.ex
4027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4028 
 
3469 chandransh 4029 
  def changeItem(self, orderId, itemId):
4030 
    """
4031 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4032 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4033 
 
3469 chandransh 4034 
    Parameters:
4035 
     - orderId
4036 
     - itemId
4037 
    """
4038 
    self.send_changeItem(orderId, itemId)
4039 
    return self.recv_changeItem()
4040 
 
4041 
  def send_changeItem(self, orderId, itemId):
4042 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4043 
    args = changeItem_args()
4044 
    args.orderId = orderId
4045 
    args.itemId = itemId
4046 
    args.write(self._oprot)
4047 
    self._oprot.writeMessageEnd()
4048 
    self._oprot.trans.flush()
4049 
 
4050 
  def recv_changeItem(self, ):
4051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4052 
    if mtype == TMessageType.EXCEPTION:
4053 
      x = TApplicationException()
4054 
      x.read(self._iprot)
4055 
      self._iprot.readMessageEnd()
4056 
      raise x
4057 
    result = changeItem_result()
4058 
    result.read(self._iprot)
4059 
    self._iprot.readMessageEnd()
4060 
    if result.success is not None:
4061 
      return result.success
4062 
    if result.ex is not None:
4063 
      raise result.ex
4064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4065 
 
4066 
  def shiftToWarehouse(self, orderId, warehouseId):
4067 
    """
4068 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4069 
 
4070 
    Parameters:
4071 
     - orderId
4072 
     - warehouseId
4073 
    """
4074 
    self.send_shiftToWarehouse(orderId, warehouseId)
4075 
    return self.recv_shiftToWarehouse()
4076 
 
4077 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4078 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4079 
    args = shiftToWarehouse_args()
4080 
    args.orderId = orderId
4081 
    args.warehouseId = warehouseId
4082 
    args.write(self._oprot)
4083 
    self._oprot.writeMessageEnd()
4084 
    self._oprot.trans.flush()
4085 
 
4086 
  def recv_shiftToWarehouse(self, ):
4087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4088 
    if mtype == TMessageType.EXCEPTION:
4089 
      x = TApplicationException()
4090 
      x.read(self._iprot)
4091 
      self._iprot.readMessageEnd()
4092 
      raise x
4093 
    result = shiftToWarehouse_result()
4094 
    result.read(self._iprot)
4095 
    self._iprot.readMessageEnd()
4096 
    if result.success is not None:
4097 
      return result.success
4098 
    if result.ex is not None:
4099 
      raise result.ex
4100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4101 
 
4647 rajveer 4102 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4103 
    """
4104 
    Adds the given delay reason to the given order.
3986 chandransh 4105 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4106 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4107 
 
3553 chandransh 4108 
    Parameters:
4109 
     - orderId
4110 
     - delayReason
3986 chandransh 4111 
     - furtherDelay
4647 rajveer 4112 
     - delayReasonText
3553 chandransh 4113 
    """
4647 rajveer 4114 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4115 
    return self.recv_addDelayReason()
4116 
 
4647 rajveer 4117 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4118 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4119 
    args = addDelayReason_args()
4120 
    args.orderId = orderId
4121 
    args.delayReason = delayReason
3986 chandransh 4122 
    args.furtherDelay = furtherDelay
4647 rajveer 4123 
    args.delayReasonText = delayReasonText
3553 chandransh 4124 
    args.write(self._oprot)
4125 
    self._oprot.writeMessageEnd()
4126 
    self._oprot.trans.flush()
4127 
 
4128 
  def recv_addDelayReason(self, ):
4129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4130 
    if mtype == TMessageType.EXCEPTION:
4131 
      x = TApplicationException()
4132 
      x.read(self._iprot)
4133 
      self._iprot.readMessageEnd()
4134 
      raise x
4135 
    result = addDelayReason_result()
4136 
    result.read(self._iprot)
4137 
    self._iprot.readMessageEnd()
4138 
    if result.success is not None:
4139 
      return result.success
4140 
    if result.ex is not None:
4141 
      raise result.ex
4142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4143 
 
3956 chandransh 4144 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4145 
    """
4146 
    Marks the COD orders with given AWB nos. as having been processed.
4147 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4148 
 
3956 chandransh 4149 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4150 
    1. There is no order corresponding to an AWB number.
4151 
    2. The captured amount for a payment exceeds the total payment.
4152 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4153 
 
4154 
    Parameters:
4155 
     - collectedAmountMap
4156 
     - xferBy
4157 
     - xferTxnId
4158 
     - xferDate
4159 
    """
4160 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4161 
    return self.recv_reconcileCodCollection()
4162 
 
4163 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4164 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4165 
    args = reconcileCodCollection_args()
4166 
    args.collectedAmountMap = collectedAmountMap
4167 
    args.xferBy = xferBy
4168 
    args.xferTxnId = xferTxnId
4169 
    args.xferDate = xferDate
4170 
    args.write(self._oprot)
4171 
    self._oprot.writeMessageEnd()
4172 
    self._oprot.trans.flush()
4173 
 
4174 
  def recv_reconcileCodCollection(self, ):
4175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4176 
    if mtype == TMessageType.EXCEPTION:
4177 
      x = TApplicationException()
4178 
      x.read(self._iprot)
4179 
      self._iprot.readMessageEnd()
4180 
      raise x
4181 
    result = reconcileCodCollection_result()
4182 
    result.read(self._iprot)
4183 
    self._iprot.readMessageEnd()
4184 
    if result.success is not None:
4185 
      return result.success
4186 
    if result.ex is not None:
4187 
      raise result.ex
4188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4189 
 
4008 mandeep.dh 4190 
  def getTransactionsRequiringExtraProcessing(self, category):
4191 
    """
4065 mandeep.dh 4192 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4193 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4194 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4195 
 
4008 mandeep.dh 4196 
    Parameters:
4197 
     - category
4198 
    """
4199 
    self.send_getTransactionsRequiringExtraProcessing(category)
4200 
    return self.recv_getTransactionsRequiringExtraProcessing()
4201 
 
4202 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4203 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4204 
    args = getTransactionsRequiringExtraProcessing_args()
4205 
    args.category = category
4206 
    args.write(self._oprot)
4207 
    self._oprot.writeMessageEnd()
4208 
    self._oprot.trans.flush()
4209 
 
4210 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4212 
    if mtype == TMessageType.EXCEPTION:
4213 
      x = TApplicationException()
4214 
      x.read(self._iprot)
4215 
      self._iprot.readMessageEnd()
4216 
      raise x
4217 
    result = getTransactionsRequiringExtraProcessing_result()
4218 
    result.read(self._iprot)
4219 
    self._iprot.readMessageEnd()
4220 
    if result.success is not None:
4221 
      return result.success
4222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4223 
 
4224 
  def markTransactionAsProcessed(self, transactionId, category):
4225 
    """
4226 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4227 
    It essentially deletes the transaction id record for a particular
4228 
    processing type category (if present) from DB.
4229 
    This is currently used by CRM application.
4008 mandeep.dh 4230 
 
4231 
    Parameters:
4232 
     - transactionId
4233 
     - category
4234 
    """
4235 
    self.send_markTransactionAsProcessed(transactionId, category)
4236 
    self.recv_markTransactionAsProcessed()
4237 
 
4238 
  def send_markTransactionAsProcessed(self, transactionId, category):
4239 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4240 
    args = markTransactionAsProcessed_args()
4241 
    args.transactionId = transactionId
4242 
    args.category = category
4243 
    args.write(self._oprot)
4244 
    self._oprot.writeMessageEnd()
4245 
    self._oprot.trans.flush()
4246 
 
4247 
  def recv_markTransactionAsProcessed(self, ):
4248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4249 
    if mtype == TMessageType.EXCEPTION:
4250 
      x = TApplicationException()
4251 
      x.read(self._iprot)
4252 
      self._iprot.readMessageEnd()
4253 
      raise x
4254 
    result = markTransactionAsProcessed_result()
4255 
    result.read(self._iprot)
4256 
    self._iprot.readMessageEnd()
4257 
    return
4258 
 
4018 chandransh 4259 
  def getItemWiseRiskyOrdersCount(self, ):
4260 
    """
4261 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4262 
    is defined as one whose shipping date is about to expire.
4263 
    """
4264 
    self.send_getItemWiseRiskyOrdersCount()
4265 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4266 
 
4018 chandransh 4267 
  def send_getItemWiseRiskyOrdersCount(self, ):
4268 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4269 
    args = getItemWiseRiskyOrdersCount_args()
4270 
    args.write(self._oprot)
4271 
    self._oprot.writeMessageEnd()
4272 
    self._oprot.trans.flush()
4273 
 
4274 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4276 
    if mtype == TMessageType.EXCEPTION:
4277 
      x = TApplicationException()
4278 
      x.read(self._iprot)
4279 
      self._iprot.readMessageEnd()
4280 
      raise x
4281 
    result = getItemWiseRiskyOrdersCount_result()
4282 
    result.read(self._iprot)
4283 
    self._iprot.readMessageEnd()
4284 
    if result.success is not None:
4285 
      return result.success
4286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4287 
 
4295 varun.gupt 4288 
  def getOrdersForItemIds(self, itemIds):
4289 
    """
4290 
    Returns a list of all orders which have items with given id
4291 
 
4292 
    Parameters:
4293 
     - itemIds
4294 
    """
4295 
    self.send_getOrdersForItemIds(itemIds)
4296 
    return self.recv_getOrdersForItemIds()
4297 
 
4298 
  def send_getOrdersForItemIds(self, itemIds):
4299 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4300 
    args = getOrdersForItemIds_args()
4301 
    args.itemIds = itemIds
4302 
    args.write(self._oprot)
4303 
    self._oprot.writeMessageEnd()
4304 
    self._oprot.trans.flush()
4305 
 
4306 
  def recv_getOrdersForItemIds(self, ):
4307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4308 
    if mtype == TMessageType.EXCEPTION:
4309 
      x = TApplicationException()
4310 
      x.read(self._iprot)
4311 
      self._iprot.readMessageEnd()
4312 
      raise x
4313 
    result = getOrdersForItemIds_result()
4314 
    result.read(self._iprot)
4315 
    self._iprot.readMessageEnd()
4316 
    if result.success is not None:
4317 
      return result.success
4318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4319 
 
4247 rajveer 4320 
  def markOrderCancellationRequestReceived(self, orderId):
4321 
    """
4322 
    Mark order as cancellation request received. If customer sends request of cancellation of
4323 
    a particular order, this method will be called. It will just change status of the order
4324 
    depending on its current status. It also records the previous status, so that we can move
4325 
    back to that status if cancellation request is denied.
4018 chandransh 4326 
 
4247 rajveer 4327 
    Parameters:
4328 
     - orderId
4329 
    """
4330 
    self.send_markOrderCancellationRequestReceived(orderId)
4331 
    self.recv_markOrderCancellationRequestReceived()
4332 
 
4333 
  def send_markOrderCancellationRequestReceived(self, orderId):
4334 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4335 
    args = markOrderCancellationRequestReceived_args()
4336 
    args.orderId = orderId
4337 
    args.write(self._oprot)
4338 
    self._oprot.writeMessageEnd()
4339 
    self._oprot.trans.flush()
4340 
 
4341 
  def recv_markOrderCancellationRequestReceived(self, ):
4342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4343 
    if mtype == TMessageType.EXCEPTION:
4344 
      x = TApplicationException()
4345 
      x.read(self._iprot)
4346 
      self._iprot.readMessageEnd()
4347 
      raise x
4348 
    result = markOrderCancellationRequestReceived_result()
4349 
    result.read(self._iprot)
4350 
    self._iprot.readMessageEnd()
4351 
    if result.ex is not None:
4352 
      raise result.ex
4353 
    return
4354 
 
4355 
  def markOrderCancellationRequestConfirmed(self, orderId):
4356 
    """
4357 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4358 
    cancellation request confirmed. After this OM will be able to cancel the order.
4359 
 
4360 
    Parameters:
4361 
     - orderId
4362 
    """
4363 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4364 
    self.recv_markOrderCancellationRequestConfirmed()
4365 
 
4366 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4367 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4368 
    args = markOrderCancellationRequestConfirmed_args()
4369 
    args.orderId = orderId
4370 
    args.write(self._oprot)
4371 
    self._oprot.writeMessageEnd()
4372 
    self._oprot.trans.flush()
4373 
 
4374 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4376 
    if mtype == TMessageType.EXCEPTION:
4377 
      x = TApplicationException()
4378 
      x.read(self._iprot)
4379 
      self._iprot.readMessageEnd()
4380 
      raise x
4381 
    result = markOrderCancellationRequestConfirmed_result()
4382 
    result.read(self._iprot)
4383 
    self._iprot.readMessageEnd()
4384 
    if result.ex is not None:
4385 
      raise result.ex
4386 
    return
4387 
 
4388 
  def markOrderCancellationRequestDenied(self, orderId):
4389 
    """
4390 
    If we decide to not to cancel order, we will move the order ro previous status.
4391 
 
4392 
    Parameters:
4393 
     - orderId
4394 
    """
4395 
    self.send_markOrderCancellationRequestDenied(orderId)
4396 
    self.recv_markOrderCancellationRequestDenied()
4397 
 
4398 
  def send_markOrderCancellationRequestDenied(self, orderId):
4399 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4400 
    args = markOrderCancellationRequestDenied_args()
4401 
    args.orderId = orderId
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_markOrderCancellationRequestDenied(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = markOrderCancellationRequestDenied_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    if result.ex is not None:
4417 
      raise result.ex
4418 
    return
4419 
 
4258 rajveer 4420 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4421 
    """
4258 rajveer 4422 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4423 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4424 
 
4425 
    Parameters:
4258 rajveer 4426 
     - transactionId
4247 rajveer 4427 
    """
4258 rajveer 4428 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4429 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4430 
 
4258 rajveer 4431 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4432 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4433 
    args = markTransactionAsPaymentFlagRemoved_args()
4434 
    args.transactionId = transactionId
4247 rajveer 4435 
    args.write(self._oprot)
4436 
    self._oprot.writeMessageEnd()
4437 
    self._oprot.trans.flush()
4438 
 
4258 rajveer 4439 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4441 
    if mtype == TMessageType.EXCEPTION:
4442 
      x = TApplicationException()
4443 
      x.read(self._iprot)
4444 
      self._iprot.readMessageEnd()
4445 
      raise x
4258 rajveer 4446 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4447 
    result.read(self._iprot)
4448 
    self._iprot.readMessageEnd()
4449 
    if result.ex is not None:
4450 
      raise result.ex
4451 
    return
4452 
 
4259 anupam.sin 4453 
  def refundTransaction(self, transactionId, refundedBy, reason):
4454 
    """
4455 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4456 
    need to be cancelled
4247 rajveer 4457 
 
4259 anupam.sin 4458 
    Parameters:
4459 
     - transactionId
4460 
     - refundedBy
4461 
     - reason
4462 
    """
4463 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4464 
    self.recv_refundTransaction()
4465 
 
4466 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4467 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4468 
    args = refundTransaction_args()
4469 
    args.transactionId = transactionId
4470 
    args.refundedBy = refundedBy
4471 
    args.reason = reason
4472 
    args.write(self._oprot)
4473 
    self._oprot.writeMessageEnd()
4474 
    self._oprot.trans.flush()
4475 
 
4476 
  def recv_refundTransaction(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 = refundTransaction_result()
4484 
    result.read(self._iprot)
4485 
    self._iprot.readMessageEnd()
4486 
    if result.ex is not None:
4487 
      raise result.ex
4488 
    return
4489 
 
4324 mandeep.dh 4490 
  def updateShipmentAddress(self, orderId, addressId):
4491 
    """
4492 
    Updates shipment address of an order. Delivery and shipping date estimates
4493 
    etc. are also updated here.
4494 
 
4495 
    Throws TransactionServiceException in case address change is not
4496 
    possible due to certain reasons such as new pincode in address is
4497 
    not serviceable etc.
4498 
 
4499 
    Parameters:
4500 
     - orderId
4501 
     - addressId
4502 
    """
4503 
    self.send_updateShipmentAddress(orderId, addressId)
4504 
    self.recv_updateShipmentAddress()
4505 
 
4506 
  def send_updateShipmentAddress(self, orderId, addressId):
4507 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4508 
    args = updateShipmentAddress_args()
4509 
    args.orderId = orderId
4510 
    args.addressId = addressId
4511 
    args.write(self._oprot)
4512 
    self._oprot.writeMessageEnd()
4513 
    self._oprot.trans.flush()
4514 
 
4515 
  def recv_updateShipmentAddress(self, ):
4516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4517 
    if mtype == TMessageType.EXCEPTION:
4518 
      x = TApplicationException()
4519 
      x.read(self._iprot)
4520 
      self._iprot.readMessageEnd()
4521 
      raise x
4522 
    result = updateShipmentAddress_result()
4523 
    result.read(self._iprot)
4524 
    self._iprot.readMessageEnd()
4525 
    if result.ex is not None:
4526 
      raise result.ex
4527 
    return
4528 
 
4285 rajveer 4529 
  def acceptOrdersForItemId(self, itemId, inventory):
4530 
    """
4531 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4532 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4533 
 
4285 rajveer 4534 
    Parameters:
4535 
     - itemId
4536 
     - inventory
4537 
    """
4538 
    self.send_acceptOrdersForItemId(itemId, inventory)
4539 
    return self.recv_acceptOrdersForItemId()
4540 
 
4541 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4542 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4543 
    args = acceptOrdersForItemId_args()
4544 
    args.itemId = itemId
4545 
    args.inventory = inventory
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_acceptOrdersForItemId(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = acceptOrdersForItemId_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    if result.success is not None:
4561 
      return result.success
4562 
    if result.ex is not None:
4563 
      raise result.ex
4564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4565 
 
4369 rajveer 4566 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4567 
    """
4568 
    Parameters:
4569 
     - vendorId
4570 
     - itemId
4571 
     - quantity
4572 
     - estimate
4369 rajveer 4573 
     - isReminder
4303 rajveer 4574 
    """
4369 rajveer 4575 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4576 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4577 
 
4369 rajveer 4578 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4579 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4580 
    args = markOrdersAsPORaised_args()
4581 
    args.vendorId = vendorId
4582 
    args.itemId = itemId
4583 
    args.quantity = quantity
4584 
    args.estimate = estimate
4369 rajveer 4585 
    args.isReminder = isReminder
4303 rajveer 4586 
    args.write(self._oprot)
4587 
    self._oprot.writeMessageEnd()
4588 
    self._oprot.trans.flush()
4589 
 
4590 
  def recv_markOrdersAsPORaised(self, ):
4591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4592 
    if mtype == TMessageType.EXCEPTION:
4593 
      x = TApplicationException()
4594 
      x.read(self._iprot)
4595 
      self._iprot.readMessageEnd()
4596 
      raise x
4597 
    result = markOrdersAsPORaised_result()
4598 
    result.read(self._iprot)
4599 
    self._iprot.readMessageEnd()
4600 
    if result.ex is not None:
4601 
      raise result.ex
4602 
    return
4603 
 
4369 rajveer 4604 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4605 
    """
4606 
    Parameters:
4607 
     - vendorId
4608 
     - itemId
4609 
     - quantity
4610 
     - estimate
4369 rajveer 4611 
     - isReminder
4303 rajveer 4612 
    """
4369 rajveer 4613 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4614 
    self.recv_markOrdersAsReversalInitiated()
4615 
 
4369 rajveer 4616 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4617 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4618 
    args = markOrdersAsReversalInitiated_args()
4619 
    args.vendorId = vendorId
4620 
    args.itemId = itemId
4621 
    args.quantity = quantity
4622 
    args.estimate = estimate
4369 rajveer 4623 
    args.isReminder = isReminder
4303 rajveer 4624 
    args.write(self._oprot)
4625 
    self._oprot.writeMessageEnd()
4626 
    self._oprot.trans.flush()
4627 
 
4628 
  def recv_markOrdersAsReversalInitiated(self, ):
4629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4630 
    if mtype == TMessageType.EXCEPTION:
4631 
      x = TApplicationException()
4632 
      x.read(self._iprot)
4633 
      self._iprot.readMessageEnd()
4634 
      raise x
4635 
    result = markOrdersAsReversalInitiated_result()
4636 
    result.read(self._iprot)
4637 
    self._iprot.readMessageEnd()
4638 
    if result.ex is not None:
4639 
      raise result.ex
4640 
    return
4641 
 
4369 rajveer 4642 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4643 
    """
4644 
    Parameters:
4645 
     - vendorId
4646 
     - itemId
4647 
     - quantity
4648 
     - estimate
4369 rajveer 4649 
     - isReminder
4303 rajveer 4650 
    """
4369 rajveer 4651 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4652 
    self.recv_markOrdersAsNotAvailabke()
4653 
 
4369 rajveer 4654 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4655 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4656 
    args = markOrdersAsNotAvailabke_args()
4657 
    args.vendorId = vendorId
4658 
    args.itemId = itemId
4659 
    args.quantity = quantity
4660 
    args.estimate = estimate
4369 rajveer 4661 
    args.isReminder = isReminder
4303 rajveer 4662 
    args.write(self._oprot)
4663 
    self._oprot.writeMessageEnd()
4664 
    self._oprot.trans.flush()
4665 
 
4666 
  def recv_markOrdersAsNotAvailabke(self, ):
4667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4668 
    if mtype == TMessageType.EXCEPTION:
4669 
      x = TApplicationException()
4670 
      x.read(self._iprot)
4671 
      self._iprot.readMessageEnd()
4672 
      raise x
4673 
    result = markOrdersAsNotAvailabke_result()
4674 
    result.read(self._iprot)
4675 
    self._iprot.readMessageEnd()
4676 
    if result.ex is not None:
4677 
      raise result.ex
4678 
    return
4679 
 
4369 rajveer 4680 
  def markOrdersAsTimeout(self, vendorId):
4681 
    """
4682 
    Parameters:
4683 
     - vendorId
4684 
    """
4685 
    self.send_markOrdersAsTimeout(vendorId)
4686 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4687 
 
4369 rajveer 4688 
  def send_markOrdersAsTimeout(self, vendorId):
4689 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4690 
    args = markOrdersAsTimeout_args()
4691 
    args.vendorId = vendorId
4692 
    args.write(self._oprot)
4693 
    self._oprot.writeMessageEnd()
4694 
    self._oprot.trans.flush()
4695 
 
4696 
  def recv_markOrdersAsTimeout(self, ):
4697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4698 
    if mtype == TMessageType.EXCEPTION:
4699 
      x = TApplicationException()
4700 
      x.read(self._iprot)
4701 
      self._iprot.readMessageEnd()
4702 
      raise x
4703 
    result = markOrdersAsTimeout_result()
4704 
    result.read(self._iprot)
4705 
    self._iprot.readMessageEnd()
4706 
    if result.success is not None:
4707 
      return result.success
4708 
    if result.ex is not None:
4709 
      raise result.ex
4710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4711 
 
4662 rajveer 4712 
  def markOrderAsLostInTransit(self, orderId):
4713 
    """
4714 
    Mark order as LOST_IN_TRANSIT
4715 
 
4716 
    Parameters:
4717 
     - orderId
4718 
    """
4719 
    self.send_markOrderAsLostInTransit(orderId)
4720 
    return self.recv_markOrderAsLostInTransit()
4721 
 
4722 
  def send_markOrderAsLostInTransit(self, orderId):
4723 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4724 
    args = markOrderAsLostInTransit_args()
4725 
    args.orderId = orderId
4726 
    args.write(self._oprot)
4727 
    self._oprot.writeMessageEnd()
4728 
    self._oprot.trans.flush()
4729 
 
4730 
  def recv_markOrderAsLostInTransit(self, ):
4731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4732 
    if mtype == TMessageType.EXCEPTION:
4733 
      x = TApplicationException()
4734 
      x.read(self._iprot)
4735 
      self._iprot.readMessageEnd()
4736 
      raise x
4737 
    result = markOrderAsLostInTransit_result()
4738 
    result.read(self._iprot)
4739 
    self._iprot.readMessageEnd()
4740 
    if result.success is not None:
4741 
      return result.success
4742 
    if result.ex is not None:
4743 
      raise result.ex
4744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4745 
 
4386 anupam.sin 4746 
  def getOrderForAwb(self, awb):
4747 
    """
4748 
    Returns the order corresponding to an AWB number
4369 rajveer 4749 
 
4386 anupam.sin 4750 
    Parameters:
4751 
     - awb
4752 
    """
4753 
    self.send_getOrderForAwb(awb)
4754 
    return self.recv_getOrderForAwb()
4755 
 
4756 
  def send_getOrderForAwb(self, awb):
4757 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4758 
    args = getOrderForAwb_args()
4759 
    args.awb = awb
4760 
    args.write(self._oprot)
4761 
    self._oprot.writeMessageEnd()
4762 
    self._oprot.trans.flush()
4763 
 
4764 
  def recv_getOrderForAwb(self, ):
4765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4766 
    if mtype == TMessageType.EXCEPTION:
4767 
      x = TApplicationException()
4768 
      x.read(self._iprot)
4769 
      self._iprot.readMessageEnd()
4770 
      raise x
4771 
    result = getOrderForAwb_result()
4772 
    result.read(self._iprot)
4773 
    self._iprot.readMessageEnd()
4774 
    if result.success is not None:
4775 
      return result.success
4776 
    if result.ex is not None:
4777 
      raise result.ex
4778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4779 
 
4910 phani.kuma 4780 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4781 
    """
4910 phani.kuma 4782 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4783 
 
4506 phani.kuma 4784 
    Parameters:
4785 
     - logistics_provider_id
4910 phani.kuma 4786 
     - order_status_list
4506 phani.kuma 4787 
    """
4910 phani.kuma 4788 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4789 
    return self.recv_getOrdersForProviderForStatus()
4790 
 
4910 phani.kuma 4791 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4792 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4793 
    args = getOrdersForProviderForStatus_args()
4794 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4795 
    args.order_status_list = order_status_list
4506 phani.kuma 4796 
    args.write(self._oprot)
4797 
    self._oprot.writeMessageEnd()
4798 
    self._oprot.trans.flush()
4799 
 
4800 
  def recv_getOrdersForProviderForStatus(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 = getOrdersForProviderForStatus_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, "getOrdersForProviderForStatus failed: unknown result");
4815 
 
4600 varun.gupt 4816 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4817 
    """
4818 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4819 
 
4600 varun.gupt 4820 
    Parameters:
4821 
     - vendorId
4822 
     - billingDateFrom
4823 
     - billingDateTo
4824 
    """
4825 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4826 
    return self.recv_getBilledOrdersForVendor()
4827 
 
4828 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4829 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4830 
    args = getBilledOrdersForVendor_args()
4831 
    args.vendorId = vendorId
4832 
    args.billingDateFrom = billingDateFrom
4833 
    args.billingDateTo = billingDateTo
4834 
    args.write(self._oprot)
4835 
    self._oprot.writeMessageEnd()
4836 
    self._oprot.trans.flush()
4837 
 
4838 
  def recv_getBilledOrdersForVendor(self, ):
4839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4840 
    if mtype == TMessageType.EXCEPTION:
4841 
      x = TApplicationException()
4842 
      x.read(self._iprot)
4843 
      self._iprot.readMessageEnd()
4844 
      raise x
4845 
    result = getBilledOrdersForVendor_result()
4846 
    result.read(self._iprot)
4847 
    self._iprot.readMessageEnd()
4848 
    if result.success is not None:
4849 
      return result.success
4850 
    if result.ex is not None:
4851 
      raise result.ex
4852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4853 
 
4607 rajveer 4854 
  def getSlippedSippingDateOrders(self, ):
4855 
    self.send_getSlippedSippingDateOrders()
4856 
    return self.recv_getSlippedSippingDateOrders()
4857 
 
4858 
  def send_getSlippedSippingDateOrders(self, ):
4859 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4860 
    args = getSlippedSippingDateOrders_args()
4861 
    args.write(self._oprot)
4862 
    self._oprot.writeMessageEnd()
4863 
    self._oprot.trans.flush()
4864 
 
4865 
  def recv_getSlippedSippingDateOrders(self, ):
4866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4867 
    if mtype == TMessageType.EXCEPTION:
4868 
      x = TApplicationException()
4869 
      x.read(self._iprot)
4870 
      self._iprot.readMessageEnd()
4871 
      raise x
4872 
    result = getSlippedSippingDateOrders_result()
4873 
    result.read(self._iprot)
4874 
    self._iprot.readMessageEnd()
4875 
    if result.success is not None:
4876 
      return result.success
4877 
    if result.ex is not None:
4878 
      raise result.ex
4879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4880 
 
4709 rajveer 4881 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4882 
    """
4883 
    Parameters:
4884 
     - cancelDateFrom
4885 
     - cancelDateTo
4886 
    """
4887 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4888 
    return self.recv_getCancelledOrders()
4889 
 
4890 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4891 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4892 
    args = getCancelledOrders_args()
4893 
    args.cancelDateFrom = cancelDateFrom
4894 
    args.cancelDateTo = cancelDateTo
4895 
    args.write(self._oprot)
4896 
    self._oprot.writeMessageEnd()
4897 
    self._oprot.trans.flush()
4898 
 
4899 
  def recv_getCancelledOrders(self, ):
4900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4901 
    if mtype == TMessageType.EXCEPTION:
4902 
      x = TApplicationException()
4903 
      x.read(self._iprot)
4904 
      self._iprot.readMessageEnd()
4905 
      raise x
4906 
    result = getCancelledOrders_result()
4907 
    result.read(self._iprot)
4908 
    self._iprot.readMessageEnd()
4909 
    if result.success is not None:
4910 
      return result.success
4911 
    if result.ex is not None:
4912 
      raise result.ex
4913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4914 
 
4600 varun.gupt 4915 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4916 
    """
4917 
    Parameters:
4918 
     - mapAWBAndAmount
4919 
    """
4920 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4921 
    self.recv_saveBluedartSettlements()
4922 
 
4923 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4924 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4925 
    args = saveBluedartSettlements_args()
4926 
    args.mapAWBAndAmount = mapAWBAndAmount
4927 
    args.write(self._oprot)
4928 
    self._oprot.writeMessageEnd()
4929 
    self._oprot.trans.flush()
4930 
 
4931 
  def recv_saveBluedartSettlements(self, ):
4932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4933 
    if mtype == TMessageType.EXCEPTION:
4934 
      x = TApplicationException()
4935 
      x.read(self._iprot)
4936 
      self._iprot.readMessageEnd()
4937 
      raise x
4938 
    result = saveBluedartSettlements_result()
4939 
    result.read(self._iprot)
4940 
    self._iprot.readMessageEnd()
4941 
    if result.ex is not None:
4942 
      raise result.ex
4943 
    return
4944 
 
4905 varun.gupt 4945 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4946 
    """
4947 
    Parameters:
4948 
     - settlementDate
4949 
     - paymentGatewayId
4905 varun.gupt 4950 
     - referenceId
4600 varun.gupt 4951 
     - serviceTax
4952 
     - otherCharges
4953 
     - netCollection
4954 
    """
4905 varun.gupt 4955 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4956 
    self.recv_savePaymentSettlements()
4957 
 
4905 varun.gupt 4958 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4959 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4960 
    args = savePaymentSettlements_args()
4961 
    args.settlementDate = settlementDate
4962 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4963 
    args.referenceId = referenceId
4600 varun.gupt 4964 
    args.serviceTax = serviceTax
4965 
    args.otherCharges = otherCharges
4966 
    args.netCollection = netCollection
4967 
    args.write(self._oprot)
4968 
    self._oprot.writeMessageEnd()
4969 
    self._oprot.trans.flush()
4970 
 
4971 
  def recv_savePaymentSettlements(self, ):
4972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4973 
    if mtype == TMessageType.EXCEPTION:
4974 
      x = TApplicationException()
4975 
      x.read(self._iprot)
4976 
      self._iprot.readMessageEnd()
4977 
      raise x
4978 
    result = savePaymentSettlements_result()
4979 
    result.read(self._iprot)
4980 
    self._iprot.readMessageEnd()
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    return
4984 
 
4985 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4986 
    """
4987 
    Parameters:
4988 
     - settlementId
4989 
     - settlementDate
4990 
     - transactionDateFrom
4991 
     - transactionDateTo
4992 
     - amount
4993 
    """
4994 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4995 
    self.recv_saveEBSSettlementSummary()
4996 
 
4997 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4998 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4999 
    args = saveEBSSettlementSummary_args()
5000 
    args.settlementId = settlementId
5001 
    args.settlementDate = settlementDate
5002 
    args.transactionDateFrom = transactionDateFrom
5003 
    args.transactionDateTo = transactionDateTo
5004 
    args.amount = amount
5005 
    args.write(self._oprot)
5006 
    self._oprot.writeMessageEnd()
5007 
    self._oprot.trans.flush()
5008 
 
5009 
  def recv_saveEBSSettlementSummary(self, ):
5010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5011 
    if mtype == TMessageType.EXCEPTION:
5012 
      x = TApplicationException()
5013 
      x.read(self._iprot)
5014 
      self._iprot.readMessageEnd()
5015 
      raise x
5016 
    result = saveEBSSettlementSummary_result()
5017 
    result.read(self._iprot)
5018 
    self._iprot.readMessageEnd()
5019 
    if result.ex is not None:
5020 
      raise result.ex
5021 
    return
5022 
 
5386 phani.kuma 5023 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5024 
    """
5025 
    Parameters:
5189 varun.gupt 5026 
     - referenceId
5027 
     - isRefund
4600 varun.gupt 5028 
    """
5386 phani.kuma 5029 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5030 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5031 
 
5386 phani.kuma 5032 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5033 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5034 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5035 
    args.referenceId = referenceId
5036 
    args.isRefund = isRefund
4600 varun.gupt 5037 
    args.write(self._oprot)
5038 
    self._oprot.writeMessageEnd()
5039 
    self._oprot.trans.flush()
5040 
 
5386 phani.kuma 5041 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 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
5386 phani.kuma 5048 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5049 
    result.read(self._iprot)
5050 
    self._iprot.readMessageEnd()
5051 
    if result.success is not None:
5052 
      return result.success
5053 
    if result.ex is not None:
5054 
      raise result.ex
5386 phani.kuma 5055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5056 
 
5386 phani.kuma 5057 
  def getSettlementForCod(self, orderId, isRefund):
5058 
    """
5059 
    Parameters:
5060 
     - orderId
5061 
     - isRefund
5062 
    """
5063 
    self.send_getSettlementForCod(orderId, isRefund)
5064 
    return self.recv_getSettlementForCod()
5065 
 
5066 
  def send_getSettlementForCod(self, orderId, isRefund):
5067 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5068 
    args = getSettlementForCod_args()
5069 
    args.orderId = orderId
5070 
    args.isRefund = isRefund
5071 
    args.write(self._oprot)
5072 
    self._oprot.writeMessageEnd()
5073 
    self._oprot.trans.flush()
5074 
 
5075 
  def recv_getSettlementForCod(self, ):
5076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5077 
    if mtype == TMessageType.EXCEPTION:
5078 
      x = TApplicationException()
5079 
      x.read(self._iprot)
5080 
      self._iprot.readMessageEnd()
5081 
      raise x
5082 
    result = getSettlementForCod_result()
5083 
    result.read(self._iprot)
5084 
    self._iprot.readMessageEnd()
5085 
    if result.success is not None:
5086 
      return result.success
5087 
    if result.ex is not None:
5088 
      raise result.ex
5089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5090 
 
4600 varun.gupt 5091 
  def getEBSSettlementSummaries(self, ):
5092 
    self.send_getEBSSettlementSummaries()
5093 
    return self.recv_getEBSSettlementSummaries()
5094 
 
5095 
  def send_getEBSSettlementSummaries(self, ):
5096 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5097 
    args = getEBSSettlementSummaries_args()
5098 
    args.write(self._oprot)
5099 
    self._oprot.writeMessageEnd()
5100 
    self._oprot.trans.flush()
5101 
 
5102 
  def recv_getEBSSettlementSummaries(self, ):
5103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5104 
    if mtype == TMessageType.EXCEPTION:
5105 
      x = TApplicationException()
5106 
      x.read(self._iprot)
5107 
      self._iprot.readMessageEnd()
5108 
      raise x
5109 
    result = getEBSSettlementSummaries_result()
5110 
    result.read(self._iprot)
5111 
    self._iprot.readMessageEnd()
5112 
    if result.success is not None:
5113 
      return result.success
5114 
    if result.ex is not None:
5115 
      raise result.ex
5116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5117 
 
5118 
  def markEBSSettlementUploaded(self, settlementId):
5119 
    """
5120 
    Parameters:
5121 
     - settlementId
5122 
    """
5123 
    self.send_markEBSSettlementUploaded(settlementId)
5124 
    self.recv_markEBSSettlementUploaded()
5125 
 
5126 
  def send_markEBSSettlementUploaded(self, settlementId):
5127 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5128 
    args = markEBSSettlementUploaded_args()
5129 
    args.settlementId = settlementId
5130 
    args.write(self._oprot)
5131 
    self._oprot.writeMessageEnd()
5132 
    self._oprot.trans.flush()
5133 
 
5134 
  def recv_markEBSSettlementUploaded(self, ):
5135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5136 
    if mtype == TMessageType.EXCEPTION:
5137 
      x = TApplicationException()
5138 
      x.read(self._iprot)
5139 
      self._iprot.readMessageEnd()
5140 
      raise x
5141 
    result = markEBSSettlementUploaded_result()
5142 
    result.read(self._iprot)
5143 
    self._iprot.readMessageEnd()
5144 
    if result.ex is not None:
5145 
      raise result.ex
5146 
    return
5147 
 
5148 
  def getEBSSettlementDate(self, settlementId):
5149 
    """
5150 
    Parameters:
5151 
     - settlementId
5152 
    """
5153 
    self.send_getEBSSettlementDate(settlementId)
5154 
    return self.recv_getEBSSettlementDate()
5155 
 
5156 
  def send_getEBSSettlementDate(self, settlementId):
5157 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5158 
    args = getEBSSettlementDate_args()
5159 
    args.settlementId = settlementId
5160 
    args.write(self._oprot)
5161 
    self._oprot.writeMessageEnd()
5162 
    self._oprot.trans.flush()
5163 
 
5164 
  def recv_getEBSSettlementDate(self, ):
5165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5166 
    if mtype == TMessageType.EXCEPTION:
5167 
      x = TApplicationException()
5168 
      x.read(self._iprot)
5169 
      self._iprot.readMessageEnd()
5170 
      raise x
5171 
    result = getEBSSettlementDate_result()
5172 
    result.read(self._iprot)
5173 
    self._iprot.readMessageEnd()
5174 
    if result.success is not None:
5175 
      return result.success
5176 
    if result.ex is not None:
5177 
      raise result.ex
5178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5179 
 
4715 varun.gupt 5180 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5181 
    """
5182 
    Parameters:
5183 
     - settlementDateFrom
5184 
     - settlementDateTo
5185 
     - isRefund
5186 
    """
5187 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5188 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5189 
 
4715 varun.gupt 5190 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5191 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5192 
    args = getSettlementsByDate_args()
5193 
    args.settlementDateFrom = settlementDateFrom
5194 
    args.settlementDateTo = settlementDateTo
5195 
    args.isRefund = isRefund
5196 
    args.write(self._oprot)
5197 
    self._oprot.writeMessageEnd()
5198 
    self._oprot.trans.flush()
5199 
 
5200 
  def recv_getSettlementsByDate(self, ):
5201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5202 
    if mtype == TMessageType.EXCEPTION:
5203 
      x = TApplicationException()
5204 
      x.read(self._iprot)
5205 
      self._iprot.readMessageEnd()
5206 
      raise x
5207 
    result = getSettlementsByDate_result()
5208 
    result.read(self._iprot)
5209 
    self._iprot.readMessageEnd()
5210 
    if result.success is not None:
5211 
      return result.success
5212 
    if result.ex is not None:
5213 
      raise result.ex
5214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5215 
 
5216 
  def getReshippedOrderIds(self, orderIds):
5217 
    """
5218 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5219 
 
5220 
    Parameters:
5221 
     - orderIds
5222 
    """
5223 
    self.send_getReshippedOrderIds(orderIds)
5224 
    return self.recv_getReshippedOrderIds()
5225 
 
5226 
  def send_getReshippedOrderIds(self, orderIds):
5227 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5228 
    args = getReshippedOrderIds_args()
5229 
    args.orderIds = orderIds
5230 
    args.write(self._oprot)
5231 
    self._oprot.writeMessageEnd()
5232 
    self._oprot.trans.flush()
5233 
 
5234 
  def recv_getReshippedOrderIds(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 = getReshippedOrderIds_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, "getReshippedOrderIds failed: unknown result");
5249 
 
5481 phani.kuma 5250 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5251 
    """
5252 
    Parameters:
5253 
     - vendorId
5481 phani.kuma 5254 
     - onlyVendorNotPaid
5255 
     - billingDateFrom
5256 
     - billingDateTo
4875 varun.gupt 5257 
    """
5481 phani.kuma 5258 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5259 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5260 
 
5481 phani.kuma 5261 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5262 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5263 
    args = getBilledOrders_args()
4875 varun.gupt 5264 
    args.vendorId = vendorId
5481 phani.kuma 5265 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5266 
    args.billingDateFrom = billingDateFrom
5267 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5268 
    args.write(self._oprot)
5269 
    self._oprot.writeMessageEnd()
5270 
    self._oprot.trans.flush()
5271 
 
5481 phani.kuma 5272 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5274 
    if mtype == TMessageType.EXCEPTION:
5275 
      x = TApplicationException()
5276 
      x.read(self._iprot)
5277 
      self._iprot.readMessageEnd()
5278 
      raise x
5481 phani.kuma 5279 
    result = getBilledOrders_result()
4875 varun.gupt 5280 
    result.read(self._iprot)
5281 
    self._iprot.readMessageEnd()
5282 
    if result.success is not None:
5283 
      return result.success
5284 
    if result.ex is not None:
5285 
      raise result.ex
5481 phani.kuma 5286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5287 
 
5031 varun.gupt 5288 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5289 
    """
5290 
    Parameters:
5291 
     - startDate
5292 
     - endDate
5293 
    """
5294 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5295 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5296 
 
5031 varun.gupt 5297 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5298 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5299 
    args = getStatusDistributionOfOrders_args()
5300 
    args.startDate = startDate
5301 
    args.endDate = endDate
5302 
    args.write(self._oprot)
5303 
    self._oprot.writeMessageEnd()
5304 
    self._oprot.trans.flush()
5305 
 
5306 
  def recv_getStatusDistributionOfOrders(self, ):
5307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5308 
    if mtype == TMessageType.EXCEPTION:
5309 
      x = TApplicationException()
5310 
      x.read(self._iprot)
5311 
      self._iprot.readMessageEnd()
5312 
      raise x
5313 
    result = getStatusDistributionOfOrders_result()
5314 
    result.read(self._iprot)
5315 
    self._iprot.readMessageEnd()
5316 
    if result.success is not None:
5317 
      return result.success
5318 
    if result.ex is not None:
5319 
      raise result.ex
5320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5321 
 
5067 varun.gupt 5322 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5323 
    """
5324 
    Parameters:
5325 
     - status
5326 
     - startDatetime
5327 
     - endDatetime
5328 
    """
5329 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5330 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5331 
 
5067 varun.gupt 5332 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5333 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5334 
    args = getOrderIdsForStatus_args()
5335 
    args.status = status
5336 
    args.startDatetime = startDatetime
5337 
    args.endDatetime = endDatetime
5338 
    args.write(self._oprot)
5339 
    self._oprot.writeMessageEnd()
5340 
    self._oprot.trans.flush()
5341 
 
5342 
  def recv_getOrderIdsForStatus(self, ):
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
5349 
    result = getOrderIdsForStatus_result()
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
5356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5357 
 
5348 anupam.sin 5358 
  def updateCODAgent(self, agent, orderId):
5359 
    """
5360 
    Updates the agent who handled the COD verification call
5361 
 
5362 
    Parameters:
5363 
     - agent
5364 
     - orderId
5365 
    """
5366 
    self.send_updateCODAgent(agent, orderId)
5367 
    self.recv_updateCODAgent()
5368 
 
5369 
  def send_updateCODAgent(self, agent, orderId):
5370 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5371 
    args = updateCODAgent_args()
5372 
    args.agent = agent
5373 
    args.orderId = orderId
5374 
    args.write(self._oprot)
5375 
    self._oprot.writeMessageEnd()
5376 
    self._oprot.trans.flush()
5377 
 
5378 
  def recv_updateCODAgent(self, ):
5379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5380 
    if mtype == TMessageType.EXCEPTION:
5381 
      x = TApplicationException()
5382 
      x.read(self._iprot)
5383 
      self._iprot.readMessageEnd()
5384 
      raise x
5385 
    result = updateCODAgent_result()
5386 
    result.read(self._iprot)
5387 
    self._iprot.readMessageEnd()
5388 
    if result.ex is not None:
5389 
      raise result.ex
5390 
    return
5391 
 
5099 varun.gupt 5392 
  def updateOrderAsPaidToVendor(self, orderId):
5393 
    """
5394 
    Parameters:
5395 
     - orderId
5396 
    """
5397 
    self.send_updateOrderAsPaidToVendor(orderId)
5398 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5399 
 
5099 varun.gupt 5400 
  def send_updateOrderAsPaidToVendor(self, orderId):
5401 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5402 
    args = updateOrderAsPaidToVendor_args()
5403 
    args.orderId = orderId
5404 
    args.write(self._oprot)
5405 
    self._oprot.writeMessageEnd()
5406 
    self._oprot.trans.flush()
5407 
 
5408 
  def recv_updateOrderAsPaidToVendor(self, ):
5409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5410 
    if mtype == TMessageType.EXCEPTION:
5411 
      x = TApplicationException()
5412 
      x.read(self._iprot)
5413 
      self._iprot.readMessageEnd()
5414 
      raise x
5415 
    result = updateOrderAsPaidToVendor_result()
5416 
    result.read(self._iprot)
5417 
    self._iprot.readMessageEnd()
5418 
    if result.ex is not None:
5419 
      raise result.ex
5420 
    return
5421 
 
5386 phani.kuma 5422 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5423 
    """
5424 
    Parameters:
5425 
     - orderId
5426 
    """
5427 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5428 
    self.recv_updateOrderOnlyAsPaidToVendor()
5429 
 
5430 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5431 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5432 
    args = updateOrderOnlyAsPaidToVendor_args()
5433 
    args.orderId = orderId
5434 
    args.write(self._oprot)
5435 
    self._oprot.writeMessageEnd()
5436 
    self._oprot.trans.flush()
5437 
 
5438 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5440 
    if mtype == TMessageType.EXCEPTION:
5441 
      x = TApplicationException()
5442 
      x.read(self._iprot)
5443 
      self._iprot.readMessageEnd()
5444 
      raise x
5445 
    result = updateOrderOnlyAsPaidToVendor_result()
5446 
    result.read(self._iprot)
5447 
    self._iprot.readMessageEnd()
5448 
    if result.ex is not None:
5449 
      raise result.ex
5450 
    return
5451 
 
5208 varun.gupt 5452 
  def getRefundedOrdersMarkedPaid(self, ):
5453 
    self.send_getRefundedOrdersMarkedPaid()
5454 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5455 
 
5208 varun.gupt 5456 
  def send_getRefundedOrdersMarkedPaid(self, ):
5457 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5458 
    args = getRefundedOrdersMarkedPaid_args()
5459 
    args.write(self._oprot)
5460 
    self._oprot.writeMessageEnd()
5461 
    self._oprot.trans.flush()
5462 
 
5463 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5465 
    if mtype == TMessageType.EXCEPTION:
5466 
      x = TApplicationException()
5467 
      x.read(self._iprot)
5468 
      self._iprot.readMessageEnd()
5469 
      raise x
5470 
    result = getRefundedOrdersMarkedPaid_result()
5471 
    result.read(self._iprot)
5472 
    self._iprot.readMessageEnd()
5473 
    if result.success is not None:
5474 
      return result.success
5475 
    if result.ex is not None:
5476 
      raise result.ex
5477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5478 
 
5447 anupam.sin 5479 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5480 
    """
5481 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5482 
 
5447 anupam.sin 5483 
 
5484 
    Parameters:
5485 
     - minOrderId
5486 
     - maxOrderId
5487 
    """
5488 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5489 
    return self.recv_getAllVerificationAgents()
5490 
 
5491 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5492 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5493 
    args = getAllVerificationAgents_args()
5494 
    args.minOrderId = minOrderId
5495 
    args.maxOrderId = maxOrderId
5496 
    args.write(self._oprot)
5497 
    self._oprot.writeMessageEnd()
5498 
    self._oprot.trans.flush()
5499 
 
5500 
  def recv_getAllVerificationAgents(self, ):
5501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5502 
    if mtype == TMessageType.EXCEPTION:
5503 
      x = TApplicationException()
5504 
      x.read(self._iprot)
5505 
      self._iprot.readMessageEnd()
5506 
      raise x
5507 
    result = getAllVerificationAgents_result()
5508 
    result.read(self._iprot)
5509 
    self._iprot.readMessageEnd()
5510 
    if result.success is not None:
5511 
      return result.success
5512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5513 
 
5527 anupam.sin 5514 
  def getAllAttributesForOrderId(self, orderId):
5515 
    """
5516 
    gets all attributes for a given orderId
5447 anupam.sin 5517 
 
5527 anupam.sin 5518 
    Parameters:
5519 
     - orderId
5520 
    """
5521 
    self.send_getAllAttributesForOrderId(orderId)
5522 
    return self.recv_getAllAttributesForOrderId()
5523 
 
5524 
  def send_getAllAttributesForOrderId(self, orderId):
5525 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5526 
    args = getAllAttributesForOrderId_args()
5527 
    args.orderId = orderId
5528 
    args.write(self._oprot)
5529 
    self._oprot.writeMessageEnd()
5530 
    self._oprot.trans.flush()
5531 
 
5532 
  def recv_getAllAttributesForOrderId(self, ):
5533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5534 
    if mtype == TMessageType.EXCEPTION:
5535 
      x = TApplicationException()
5536 
      x.read(self._iprot)
5537 
      self._iprot.readMessageEnd()
5538 
      raise x
5539 
    result = getAllAttributesForOrderId_result()
5540 
    result.read(self._iprot)
5541 
    self._iprot.readMessageEnd()
5542 
    if result.success is not None:
5543 
      return result.success
5544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5545 
 
5676 rajveer 5546 
  def setOrderAttributes(self, orderId, attributes):
5547 
    """
5548 
    sets attributes for an order
5549 
 
5550 
    Parameters:
5551 
     - orderId
5552 
     - attributes
5553 
    """
5554 
    self.send_setOrderAttributes(orderId, attributes)
5555 
    self.recv_setOrderAttributes()
5556 
 
5557 
  def send_setOrderAttributes(self, orderId, attributes):
5558 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5559 
    args = setOrderAttributes_args()
5560 
    args.orderId = orderId
5561 
    args.attributes = attributes
5562 
    args.write(self._oprot)
5563 
    self._oprot.writeMessageEnd()
5564 
    self._oprot.trans.flush()
5565 
 
5566 
  def recv_setOrderAttributes(self, ):
5567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5568 
    if mtype == TMessageType.EXCEPTION:
5569 
      x = TApplicationException()
5570 
      x.read(self._iprot)
5571 
      self._iprot.readMessageEnd()
5572 
      raise x
5573 
    result = setOrderAttributes_result()
5574 
    result.read(self._iprot)
5575 
    self._iprot.readMessageEnd()
5576 
    return
5577 
 
5527 anupam.sin 5578 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5579 
    """
5580 
    sets attributes for all orders in a transaction
5581 
 
5582 
    Parameters:
5583 
     - transactionId
5584 
     - attribute
5585 
    """
5586 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5587 
    self.recv_setOrderAttributeForTransaction()
5588 
 
5589 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5590 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5591 
    args = setOrderAttributeForTransaction_args()
5592 
    args.transactionId = transactionId
5593 
    args.attribute = attribute
5594 
    args.write(self._oprot)
5595 
    self._oprot.writeMessageEnd()
5596 
    self._oprot.trans.flush()
5597 
 
5598 
  def recv_setOrderAttributeForTransaction(self, ):
5599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5600 
    if mtype == TMessageType.EXCEPTION:
5601 
      x = TApplicationException()
5602 
      x.read(self._iprot)
5603 
      self._iprot.readMessageEnd()
5604 
      raise x
5605 
    result = setOrderAttributeForTransaction_result()
5606 
    result.read(self._iprot)
5607 
    self._iprot.readMessageEnd()
5608 
    return
5609 
 
5553 rajveer 5610 
  def getReceivePendingOrders(self, storeId):
5611 
    """
5612 
    Parameters:
5613 
     - storeId
5614 
    """
5615 
    self.send_getReceivePendingOrders(storeId)
5616 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5617 
 
5553 rajveer 5618 
  def send_getReceivePendingOrders(self, storeId):
5619 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5620 
    args = getReceivePendingOrders_args()
5621 
    args.storeId = storeId
5622 
    args.write(self._oprot)
5623 
    self._oprot.writeMessageEnd()
5624 
    self._oprot.trans.flush()
5625 
 
5626 
  def recv_getReceivePendingOrders(self, ):
5627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5628 
    if mtype == TMessageType.EXCEPTION:
5629 
      x = TApplicationException()
5630 
      x.read(self._iprot)
5631 
      self._iprot.readMessageEnd()
5632 
      raise x
5633 
    result = getReceivePendingOrders_result()
5634 
    result.read(self._iprot)
5635 
    self._iprot.readMessageEnd()
5636 
    if result.success is not None:
5637 
      return result.success
5638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5639 
 
5640 
  def getReceivedAtStoreOrders(self, storeId):
5641 
    """
5642 
    Parameters:
5643 
     - storeId
5644 
    """
5645 
    self.send_getReceivedAtStoreOrders(storeId)
5646 
    return self.recv_getReceivedAtStoreOrders()
5647 
 
5648 
  def send_getReceivedAtStoreOrders(self, storeId):
5649 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5650 
    args = getReceivedAtStoreOrders_args()
5651 
    args.storeId = storeId
5652 
    args.write(self._oprot)
5653 
    self._oprot.writeMessageEnd()
5654 
    self._oprot.trans.flush()
5655 
 
5656 
  def recv_getReceivedAtStoreOrders(self, ):
5657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5658 
    if mtype == TMessageType.EXCEPTION:
5659 
      x = TApplicationException()
5660 
      x.read(self._iprot)
5661 
      self._iprot.readMessageEnd()
5662 
      raise x
5663 
    result = getReceivedAtStoreOrders_result()
5664 
    result.read(self._iprot)
5665 
    self._iprot.readMessageEnd()
5666 
    if result.success is not None:
5667 
      return result.success
5668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5669 
 
5713 rajveer 5670 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5671 
    """
5672 
    Parameters:
5673 
     - storeId
5674 
     - fromDate
5675 
     - toDate
5676 
     - onlyCod
5677 
    """
5678 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5679 
    return self.recv_getOrdersCollectionAtStore()
5680 
 
5681 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5682 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5683 
    args = getOrdersCollectionAtStore_args()
5684 
    args.storeId = storeId
5685 
    args.fromDate = fromDate
5686 
    args.toDate = toDate
5687 
    args.onlyCod = onlyCod
5688 
    args.write(self._oprot)
5689 
    self._oprot.writeMessageEnd()
5690 
    self._oprot.trans.flush()
5691 
 
5692 
  def recv_getOrdersCollectionAtStore(self, ):
5693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5694 
    if mtype == TMessageType.EXCEPTION:
5695 
      x = TApplicationException()
5696 
      x.read(self._iprot)
5697 
      self._iprot.readMessageEnd()
5698 
      raise x
5699 
    result = getOrdersCollectionAtStore_result()
5700 
    result.read(self._iprot)
5701 
    self._iprot.readMessageEnd()
5702 
    if result.success is not None:
5703 
      return result.success
5704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5705 
 
5833 rajveer 5706 
  def getOrderAttributeValue(self, orderId, attributeName):
5707 
    """
5708 
    Parameters:
5709 
     - orderId
5710 
     - attributeName
5711 
    """
5712 
    self.send_getOrderAttributeValue(orderId, attributeName)
5713 
    return self.recv_getOrderAttributeValue()
5714 
 
5715 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5716 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5717 
    args = getOrderAttributeValue_args()
5718 
    args.orderId = orderId
5719 
    args.attributeName = attributeName
5720 
    args.write(self._oprot)
5721 
    self._oprot.writeMessageEnd()
5722 
    self._oprot.trans.flush()
5723 
 
5724 
  def recv_getOrderAttributeValue(self, ):
5725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5726 
    if mtype == TMessageType.EXCEPTION:
5727 
      x = TApplicationException()
5728 
      x.read(self._iprot)
5729 
      self._iprot.readMessageEnd()
5730 
      raise x
5731 
    result = getOrderAttributeValue_result()
5732 
    result.read(self._iprot)
5733 
    self._iprot.readMessageEnd()
5734 
    if result.success is not None:
5735 
      return result.success
5736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5737 
 
6019 rajveer 5738 
  def changeJacketNumber(self, orderId, jacketNumber):
5739 
    """
5740 
    Parameters:
5741 
     - orderId
5742 
     - jacketNumber
5743 
    """
5744 
    self.send_changeJacketNumber(orderId, jacketNumber)
5745 
    return self.recv_changeJacketNumber()
5746 
 
5747 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5748 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5749 
    args = changeJacketNumber_args()
5750 
    args.orderId = orderId
5751 
    args.jacketNumber = jacketNumber
5752 
    args.write(self._oprot)
5753 
    self._oprot.writeMessageEnd()
5754 
    self._oprot.trans.flush()
5755 
 
5756 
  def recv_changeJacketNumber(self, ):
5757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5758 
    if mtype == TMessageType.EXCEPTION:
5759 
      x = TApplicationException()
5760 
      x.read(self._iprot)
5761 
      self._iprot.readMessageEnd()
5762 
      raise x
5763 
    result = changeJacketNumber_result()
5764 
    result.read(self._iprot)
5765 
    self._iprot.readMessageEnd()
5766 
    if result.success is not None:
5767 
      return result.success
5768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5769 
 
5770 
  def markOrderAsRtoInTransit(self, orderId):
5771 
    """
5772 
    Parameters:
5773 
     - orderId
5774 
    """
5775 
    self.send_markOrderAsRtoInTransit(orderId)
5776 
    return self.recv_markOrderAsRtoInTransit()
5777 
 
5778 
  def send_markOrderAsRtoInTransit(self, orderId):
5779 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5780 
    args = markOrderAsRtoInTransit_args()
5781 
    args.orderId = orderId
5782 
    args.write(self._oprot)
5783 
    self._oprot.writeMessageEnd()
5784 
    self._oprot.trans.flush()
5785 
 
5786 
  def recv_markOrderAsRtoInTransit(self, ):
5787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5788 
    if mtype == TMessageType.EXCEPTION:
5789 
      x = TApplicationException()
5790 
      x.read(self._iprot)
5791 
      self._iprot.readMessageEnd()
5792 
      raise x
5793 
    result = markOrderAsRtoInTransit_result()
5794 
    result.read(self._iprot)
5795 
    self._iprot.readMessageEnd()
5796 
    if result.success is not None:
5797 
      return result.success
5798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5799 
 
5593 mandeep.dh 5800 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5801 
    """
5802 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5803 
    invoked while scanning IN of items.
5553 rajveer 5804 
 
5593 mandeep.dh 5805 
    Parameters:
5806 
     - itemId
5807 
     - quantity
5808 
     - fulfilmentWarehouseId
5809 
     - billingWarehouseId
5810 
    """
5811 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5812 
    self.recv_acceptOrderForItem()
5813 
 
5814 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5815 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5816 
    args = acceptOrderForItem_args()
5817 
    args.itemId = itemId
5818 
    args.quantity = quantity
5819 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5820 
    args.billingWarehouseId = billingWarehouseId
5821 
    args.write(self._oprot)
5822 
    self._oprot.writeMessageEnd()
5823 
    self._oprot.trans.flush()
5824 
 
5825 
  def recv_acceptOrderForItem(self, ):
5826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5827 
    if mtype == TMessageType.EXCEPTION:
5828 
      x = TApplicationException()
5829 
      x.read(self._iprot)
5830 
      self._iprot.readMessageEnd()
5831 
      raise x
5832 
    result = acceptOrderForItem_result()
5833 
    result.read(self._iprot)
5834 
    self._iprot.readMessageEnd()
5835 
    return
5836 
 
6000 mandeep.dh 5837 
  def createRechargeOrder(self, rechargeOrder):
5838 
    """
5839 
    Parameters:
5840 
     - rechargeOrder
5841 
    """
5842 
    self.send_createRechargeOrder(rechargeOrder)
5843 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5844 
 
6000 mandeep.dh 5845 
  def send_createRechargeOrder(self, rechargeOrder):
5846 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5847 
    args = createRechargeOrder_args()
5848 
    args.rechargeOrder = rechargeOrder
5849 
    args.write(self._oprot)
5850 
    self._oprot.writeMessageEnd()
5851 
    self._oprot.trans.flush()
5852 
 
5853 
  def recv_createRechargeOrder(self, ):
5854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5855 
    if mtype == TMessageType.EXCEPTION:
5856 
      x = TApplicationException()
5857 
      x.read(self._iprot)
5858 
      self._iprot.readMessageEnd()
5859 
      raise x
5860 
    result = createRechargeOrder_result()
5861 
    result.read(self._iprot)
5862 
    self._iprot.readMessageEnd()
5863 
    if result.success is not None:
5864 
      return result.success
5865 
    if result.ex is not None:
5866 
      raise result.ex
5867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5868 
 
6031 rajveer 5869 
  def getRechargeOrder(self, rechargeRrderId):
5870 
    """
5871 
    Parameters:
5872 
     - rechargeRrderId
5873 
    """
5874 
    self.send_getRechargeOrder(rechargeRrderId)
5875 
    return self.recv_getRechargeOrder()
5876 
 
5877 
  def send_getRechargeOrder(self, rechargeRrderId):
5878 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5879 
    args = getRechargeOrder_args()
5880 
    args.rechargeRrderId = rechargeRrderId
5881 
    args.write(self._oprot)
5882 
    self._oprot.writeMessageEnd()
5883 
    self._oprot.trans.flush()
5884 
 
5885 
  def recv_getRechargeOrder(self, ):
5886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5887 
    if mtype == TMessageType.EXCEPTION:
5888 
      x = TApplicationException()
5889 
      x.read(self._iprot)
5890 
      self._iprot.readMessageEnd()
5891 
      raise x
5892 
    result = getRechargeOrder_result()
5893 
    result.read(self._iprot)
5894 
    self._iprot.readMessageEnd()
5895 
    if result.success is not None:
5896 
      return result.success
5897 
    if result.ex is not None:
5898 
      raise result.ex
5899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5900 
 
5901 
  def getRechargeOrders(self, userId):
5902 
    """
5903 
    Parameters:
5904 
     - userId
5905 
    """
5906 
    self.send_getRechargeOrders(userId)
5907 
    return self.recv_getRechargeOrders()
5908 
 
5909 
  def send_getRechargeOrders(self, userId):
5910 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5911 
    args = getRechargeOrders_args()
5912 
    args.userId = userId
5913 
    args.write(self._oprot)
5914 
    self._oprot.writeMessageEnd()
5915 
    self._oprot.trans.flush()
5916 
 
5917 
  def recv_getRechargeOrders(self, ):
5918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5919 
    if mtype == TMessageType.EXCEPTION:
5920 
      x = TApplicationException()
5921 
      x.read(self._iprot)
5922 
      self._iprot.readMessageEnd()
5923 
      raise x
5924 
    result = getRechargeOrders_result()
5925 
    result.read(self._iprot)
5926 
    self._iprot.readMessageEnd()
5927 
    if result.success is not None:
5928 
      return result.success
5929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5930 
 
6000 mandeep.dh 5931 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5932 
    """
5933 
    Parameters:
5934 
     - rechargeOrderId
5935 
     - rechargeOrderStatus
5936 
    """
5937 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5938 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5939 
 
5940 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5941 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5942 
    args = updateRechargeOrderStatus_args()
5943 
    args.rechargeOrderId = rechargeOrderId
5944 
    args.rechargeOrderStatus = rechargeOrderStatus
5945 
    args.write(self._oprot)
5946 
    self._oprot.writeMessageEnd()
5947 
    self._oprot.trans.flush()
5948 
 
5949 
  def recv_updateRechargeOrderStatus(self, ):
5950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5951 
    if mtype == TMessageType.EXCEPTION:
5952 
      x = TApplicationException()
5953 
      x.read(self._iprot)
5954 
      self._iprot.readMessageEnd()
5955 
      raise x
5956 
    result = updateRechargeOrderStatus_result()
5957 
    result.read(self._iprot)
5958 
    self._iprot.readMessageEnd()
6031 rajveer 5959 
    if result.success is not None:
5960 
      return result.success
6000 mandeep.dh 5961 
    if result.ex is not None:
5962 
      raise result.ex
6031 rajveer 5963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5964 
 
6031 rajveer 5965 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5966 
    """
5967 
    Parameters:
6031 rajveer 5968 
     - rechargeOrderId
6000 mandeep.dh 5969 
    """
6031 rajveer 5970 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5971 
    return self.recv_activateRechargeTxn()
5972 
 
6031 rajveer 5973 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5974 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5975 
    args = activateRechargeTxn_args()
6031 rajveer 5976 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5977 
    args.write(self._oprot)
5978 
    self._oprot.writeMessageEnd()
5979 
    self._oprot.trans.flush()
5980 
 
5981 
  def recv_activateRechargeTxn(self, ):
5982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5983 
    if mtype == TMessageType.EXCEPTION:
5984 
      x = TApplicationException()
5985 
      x.read(self._iprot)
5986 
      self._iprot.readMessageEnd()
5987 
      raise x
5988 
    result = activateRechargeTxn_result()
5989 
    result.read(self._iprot)
5990 
    self._iprot.readMessageEnd()
5991 
    if result.success is not None:
5992 
      return result.success
5993 
    if result.ex is not None:
5994 
      raise result.ex
5995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5996 
 
6031 rajveer 5997 
  def getUserWallet(self, userId):
6000 mandeep.dh 5998 
    """
5999 
    Parameters:
6031 rajveer 6000 
     - userId
6000 mandeep.dh 6001 
    """
6031 rajveer 6002 
    self.send_getUserWallet(userId)
6003 
    return self.recv_getUserWallet()
6000 mandeep.dh 6004 
 
6031 rajveer 6005 
  def send_getUserWallet(self, userId):
6006 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6007 
    args = getUserWallet_args()
6008 
    args.userId = userId
6000 mandeep.dh 6009 
    args.write(self._oprot)
6010 
    self._oprot.writeMessageEnd()
6011 
    self._oprot.trans.flush()
6012 
 
6031 rajveer 6013 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6015 
    if mtype == TMessageType.EXCEPTION:
6016 
      x = TApplicationException()
6017 
      x.read(self._iprot)
6018 
      self._iprot.readMessageEnd()
6019 
      raise x
6031 rajveer 6020 
    result = getUserWallet_result()
6000 mandeep.dh 6021 
    result.read(self._iprot)
6022 
    self._iprot.readMessageEnd()
6023 
    if result.success is not None:
6024 
      return result.success
6031 rajveer 6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6026 
 
6031 rajveer 6027 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6028 
    """
6029 
    Parameters:
6031 rajveer 6030 
     - userId
6000 mandeep.dh 6031 
    """
6031 rajveer 6032 
    self.send_getUserWalletHistory(userId)
6033 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6034 
 
6031 rajveer 6035 
  def send_getUserWalletHistory(self, userId):
6036 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6037 
    args = getUserWalletHistory_args()
6038 
    args.userId = userId
6000 mandeep.dh 6039 
    args.write(self._oprot)
6040 
    self._oprot.writeMessageEnd()
6041 
    self._oprot.trans.flush()
6042 
 
6031 rajveer 6043 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6045 
    if mtype == TMessageType.EXCEPTION:
6046 
      x = TApplicationException()
6047 
      x.read(self._iprot)
6048 
      self._iprot.readMessageEnd()
6049 
      raise x
6031 rajveer 6050 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6051 
    result.read(self._iprot)
6052 
    self._iprot.readMessageEnd()
6053 
    if result.success is not None:
6054 
      return result.success
6031 rajveer 6055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6056 
 
6050 anupam.sin 6057 
  def getRechargeOrdersForTransaction(self, txnId):
6058 
    """
6059 
    Returns a recharge order for a given transactionId
6060 
 
6061 
    Parameters:
6062 
     - txnId
6063 
    """
6064 
    self.send_getRechargeOrdersForTransaction(txnId)
6065 
    return self.recv_getRechargeOrdersForTransaction()
6066 
 
6067 
  def send_getRechargeOrdersForTransaction(self, txnId):
6068 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6069 
    args = getRechargeOrdersForTransaction_args()
6070 
    args.txnId = txnId
6071 
    args.write(self._oprot)
6072 
    self._oprot.writeMessageEnd()
6073 
    self._oprot.trans.flush()
6074 
 
6075 
  def recv_getRechargeOrdersForTransaction(self, ):
6076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6077 
    if mtype == TMessageType.EXCEPTION:
6078 
      x = TApplicationException()
6079 
      x.read(self._iprot)
6080 
      self._iprot.readMessageEnd()
6081 
      raise x
6082 
    result = getRechargeOrdersForTransaction_result()
6083 
    result.read(self._iprot)
6084 
    self._iprot.readMessageEnd()
6085 
    if result.success is not None:
6086 
      return result.success
6087 
    if result.ex is not None:
6088 
      raise result.ex
6089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6090 
 
6048 rajveer 6091 
  def getServiceProviders(self, rechargeType):
6092 
    """
6093 
    Parameters:
6094 
     - rechargeType
6095 
    """
6096 
    self.send_getServiceProviders(rechargeType)
6097 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6098 
 
6048 rajveer 6099 
  def send_getServiceProviders(self, rechargeType):
6100 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6101 
    args = getServiceProviders_args()
6102 
    args.rechargeType = rechargeType
6103 
    args.write(self._oprot)
6104 
    self._oprot.writeMessageEnd()
6105 
    self._oprot.trans.flush()
6106 
 
6107 
  def recv_getServiceProviders(self, ):
6108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6109 
    if mtype == TMessageType.EXCEPTION:
6110 
      x = TApplicationException()
6111 
      x.read(self._iprot)
6112 
      self._iprot.readMessageEnd()
6113 
      raise x
6114 
    result = getServiceProviders_result()
6115 
    result.read(self._iprot)
6116 
    self._iprot.readMessageEnd()
6117 
    if result.success is not None:
6118 
      return result.success
6119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6120 
 
6049 rajveer 6121 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6122 
    """
6123 
    Parameters:
6049 rajveer 6124 
     - rechargeType
6048 rajveer 6125 
     - deviceNumber
6126 
    """
6049 rajveer 6127 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6128 
    return self.recv_getServiceProviderForDevice()
6129 
 
6049 rajveer 6130 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6131 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6132 
    args = getServiceProviderForDevice_args()
6049 rajveer 6133 
    args.rechargeType = rechargeType
6048 rajveer 6134 
    args.deviceNumber = deviceNumber
6135 
    args.write(self._oprot)
6136 
    self._oprot.writeMessageEnd()
6137 
    self._oprot.trans.flush()
6138 
 
6139 
  def recv_getServiceProviderForDevice(self, ):
6140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6141 
    if mtype == TMessageType.EXCEPTION:
6142 
      x = TApplicationException()
6143 
      x.read(self._iprot)
6144 
      self._iprot.readMessageEnd()
6145 
      raise x
6146 
    result = getServiceProviderForDevice_result()
6147 
    result.read(self._iprot)
6148 
    self._iprot.readMessageEnd()
6149 
    if result.success is not None:
6150 
      return result.success
6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6152 
 
6094 rajveer 6153 
  def getRechargeOrdersForDevice(self, deviceNumber):
6154 
    """
6155 
    Parameters:
6156 
     - deviceNumber
6157 
    """
6158 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6159 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6160 
 
6094 rajveer 6161 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6162 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6163 
    args = getRechargeOrdersForDevice_args()
6164 
    args.deviceNumber = deviceNumber
6165 
    args.write(self._oprot)
6166 
    self._oprot.writeMessageEnd()
6167 
    self._oprot.trans.flush()
6168 
 
6169 
  def recv_getRechargeOrdersForDevice(self, ):
6170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6171 
    if mtype == TMessageType.EXCEPTION:
6172 
      x = TApplicationException()
6173 
      x.read(self._iprot)
6174 
      self._iprot.readMessageEnd()
6175 
      raise x
6176 
    result = getRechargeOrdersForDevice_result()
6177 
    result.read(self._iprot)
6178 
    self._iprot.readMessageEnd()
6179 
    if result.success is not None:
6180 
      return result.success
6181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6182 
 
6183 
  def addAmountToWallet(self, userId, orderId, amount):
6184 
    """
6185 
    Parameters:
6186 
     - userId
6187 
     - orderId
6188 
     - amount
6189 
    """
6190 
    self.send_addAmountToWallet(userId, orderId, amount)
6191 
    self.recv_addAmountToWallet()
6192 
 
6193 
  def send_addAmountToWallet(self, userId, orderId, amount):
6194 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6195 
    args = addAmountToWallet_args()
6196 
    args.userId = userId
6197 
    args.orderId = orderId
6198 
    args.amount = amount
6199 
    args.write(self._oprot)
6200 
    self._oprot.writeMessageEnd()
6201 
    self._oprot.trans.flush()
6202 
 
6203 
  def recv_addAmountToWallet(self, ):
6204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6205 
    if mtype == TMessageType.EXCEPTION:
6206 
      x = TApplicationException()
6207 
      x.read(self._iprot)
6208 
      self._iprot.readMessageEnd()
6209 
      raise x
6210 
    result = addAmountToWallet_result()
6211 
    result.read(self._iprot)
6212 
    self._iprot.readMessageEnd()
6213 
    return
6214 
 
6188 rajveer 6215 
  def getRechargeStatistics(self, ):
6216 
    self.send_getRechargeStatistics()
6217 
    return self.recv_getRechargeStatistics()
6218 
 
6219 
  def send_getRechargeStatistics(self, ):
6220 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6221 
    args = getRechargeStatistics_args()
6222 
    args.write(self._oprot)
6223 
    self._oprot.writeMessageEnd()
6224 
    self._oprot.trans.flush()
6225 
 
6226 
  def recv_getRechargeStatistics(self, ):
6227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6228 
    if mtype == TMessageType.EXCEPTION:
6229 
      x = TApplicationException()
6230 
      x.read(self._iprot)
6231 
      self._iprot.readMessageEnd()
6232 
      raise x
6233 
    result = getRechargeStatistics_result()
6234 
    result.read(self._iprot)
6235 
    self._iprot.readMessageEnd()
6236 
    if result.success is not None:
6237 
      return result.success
6238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6239 
 
6154 rajveer 6240 
  def getRechargeOrdersForStatus(self, status):
6241 
    """
6242 
    Parameters:
6243 
     - status
6244 
    """
6245 
    self.send_getRechargeOrdersForStatus(status)
6246 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6247 
 
6154 rajveer 6248 
  def send_getRechargeOrdersForStatus(self, status):
6249 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6250 
    args = getRechargeOrdersForStatus_args()
6251 
    args.status = status
6252 
    args.write(self._oprot)
6253 
    self._oprot.writeMessageEnd()
6254 
    self._oprot.trans.flush()
6255 
 
6256 
  def recv_getRechargeOrdersForStatus(self, ):
6257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6258 
    if mtype == TMessageType.EXCEPTION:
6259 
      x = TApplicationException()
6260 
      x.read(self._iprot)
6261 
      self._iprot.readMessageEnd()
6262 
      raise x
6263 
    result = getRechargeOrdersForStatus_result()
6264 
    result.read(self._iprot)
6265 
    self._iprot.readMessageEnd()
6266 
    if result.success is not None:
6267 
      return result.success
6268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6269 
 
6159 rajveer 6270 
  def getPlansForOperator(self, operatorId):
6271 
    """
6272 
    Parameters:
6273 
     - operatorId
6274 
    """
6275 
    self.send_getPlansForOperator(operatorId)
6276 
    return self.recv_getPlansForOperator()
6154 rajveer 6277 
 
6159 rajveer 6278 
  def send_getPlansForOperator(self, operatorId):
6279 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6280 
    args = getPlansForOperator_args()
6281 
    args.operatorId = operatorId
6282 
    args.write(self._oprot)
6283 
    self._oprot.writeMessageEnd()
6284 
    self._oprot.trans.flush()
6285 
 
6286 
  def recv_getPlansForOperator(self, ):
6287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6288 
    if mtype == TMessageType.EXCEPTION:
6289 
      x = TApplicationException()
6290 
      x.read(self._iprot)
6291 
      self._iprot.readMessageEnd()
6292 
      raise x
6293 
    result = getPlansForOperator_result()
6294 
    result.read(self._iprot)
6295 
    self._iprot.readMessageEnd()
6296 
    if result.success is not None:
6297 
      return result.success
6298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6299 
 
6300 
 
3376 rajveer 6301 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6302 
  def __init__(self, handler):
3376 rajveer 6303 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6304 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6305 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6306 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6307 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6308 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6309 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6310 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6311 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6312 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6313 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6314 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6315 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6316 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6317 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6318 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6319 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6320 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6321 
    self._processMap["createOrder"] = Processor.process_createOrder
6322 
    self._processMap["getOrder"] = Processor.process_getOrder
6323 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6324 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6325 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6326 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6327 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6328 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6329 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6330 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6331 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6332 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6333 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6334 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6335 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6336 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6337 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6338 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6339 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6340 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6341 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6342 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6343 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6344 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6345 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6346 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6347 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6348 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6349 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6350 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6351 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6352 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6353 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6354 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6355 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6356 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6357 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6358 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6359 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6360 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6361 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6362 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6363 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6364 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6365 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6366 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6367 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6368 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6369 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6370 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6371 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6372 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6373 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6374 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6375 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6376 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6377 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6378 
    self._processMap["changeItem"] = Processor.process_changeItem
6379 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6380 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6381 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6382 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6383 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6384 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6385 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6386 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6387 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6388 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6389 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6390 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6391 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6392 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6393 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6394 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6395 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6396 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6397 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6398 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6399 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6400 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6401 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6402 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6403 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6404 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6405 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6406 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6407 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6408 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6409 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6410 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6411 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6412 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6413 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6414 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6415 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6416 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6417 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6418 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6419 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6420 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6421 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6422 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6423 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6424 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6425 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6426 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6427 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6428 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6429 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6430 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6431 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6432 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6433 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6434 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6435 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6436 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6437 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6438 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6439 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6440 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6094 rajveer 6441 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6442 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6443 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6444 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6445 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
94 ashish 6446 
 
6447 
  def process(self, iprot, oprot):
6448 
    (name, type, seqid) = iprot.readMessageBegin()
6449 
    if name not in self._processMap:
6450 
      iprot.skip(TType.STRUCT)
6451 
      iprot.readMessageEnd()
6452 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6453 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6454 
      x.write(oprot)
6455 
      oprot.writeMessageEnd()
6456 
      oprot.trans.flush()
6457 
      return
6458 
    else:
6459 
      self._processMap[name](self, seqid, iprot, oprot)
6460 
    return True
6461 
 
6462 
  def process_createTransaction(self, seqid, iprot, oprot):
6463 
    args = createTransaction_args()
6464 
    args.read(iprot)
6465 
    iprot.readMessageEnd()
6466 
    result = createTransaction_result()
6467 
    try:
132 ashish 6468 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6469 
    except TransactionServiceException, ex:
6470 
      result.ex = ex
6471 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6472 
    result.write(oprot)
6473 
    oprot.writeMessageEnd()
6474 
    oprot.trans.flush()
6475 
 
6476 
  def process_getTransaction(self, seqid, iprot, oprot):
6477 
    args = getTransaction_args()
6478 
    args.read(iprot)
6479 
    iprot.readMessageEnd()
6480 
    result = getTransaction_result()
6481 
    try:
6482 
      result.success = self._handler.getTransaction(args.id)
6483 
    except TransactionServiceException, ex:
6484 
      result.ex = ex
6485 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6486 
    result.write(oprot)
6487 
    oprot.writeMessageEnd()
6488 
    oprot.trans.flush()
6489 
 
6490 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6491 
    args = getTransactionsForCustomer_args()
6492 
    args.read(iprot)
6493 
    iprot.readMessageEnd()
6494 
    result = getTransactionsForCustomer_result()
6495 
    try:
6496 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6497 
    except TransactionServiceException, ex:
6498 
      result.ex = ex
6499 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6500 
    result.write(oprot)
6501 
    oprot.writeMessageEnd()
6502 
    oprot.trans.flush()
6503 
 
132 ashish 6504 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6505 
    args = getTransactionsForShoppingCartId_args()
6506 
    args.read(iprot)
6507 
    iprot.readMessageEnd()
6508 
    result = getTransactionsForShoppingCartId_result()
6509 
    try:
6510 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6511 
    except TransactionServiceException, ex:
6512 
      result.ex = ex
6513 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6514 
    result.write(oprot)
6515 
    oprot.writeMessageEnd()
6516 
    oprot.trans.flush()
6517 
 
94 ashish 6518 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6519 
    args = getTransactionStatus_args()
6520 
    args.read(iprot)
6521 
    iprot.readMessageEnd()
6522 
    result = getTransactionStatus_result()
6523 
    try:
6524 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6525 
    except TransactionServiceException, ex:
6526 
      result.ex = ex
6527 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6528 
    result.write(oprot)
6529 
    oprot.writeMessageEnd()
6530 
    oprot.trans.flush()
6531 
 
6532 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6533 
    args = changeTransactionStatus_args()
6534 
    args.read(iprot)
6535 
    iprot.readMessageEnd()
6536 
    result = changeTransactionStatus_result()
6537 
    try:
5527 anupam.sin 6538 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6539 
    except TransactionServiceException, ex:
6540 
      result.ex = ex
6541 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6542 
    result.write(oprot)
6543 
    oprot.writeMessageEnd()
6544 
    oprot.trans.flush()
6545 
 
1398 varun.gupt 6546 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6547 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6548 
    args.read(iprot)
6549 
    iprot.readMessageEnd()
1398 varun.gupt 6550 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6551 
    try:
1398 varun.gupt 6552 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6553 
    except TransactionServiceException, ex:
6554 
      result.ex = ex
1398 varun.gupt 6555 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6556 
    result.write(oprot)
6557 
    oprot.writeMessageEnd()
6558 
    oprot.trans.flush()
6559 
 
483 rajveer 6560 
  def process_getAllOrders(self, seqid, iprot, oprot):
6561 
    args = getAllOrders_args()
94 ashish 6562 
    args.read(iprot)
6563 
    iprot.readMessageEnd()
483 rajveer 6564 
    result = getAllOrders_result()
94 ashish 6565 
    try:
4801 anupam.sin 6566 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6567 
    except TransactionServiceException, ex:
6568 
      result.ex = ex
483 rajveer 6569 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6570 
    result.write(oprot)
6571 
    oprot.writeMessageEnd()
6572 
    oprot.trans.flush()
6573 
 
4133 chandransh 6574 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6575 
    args = getOrdersInBatch_args()
6576 
    args.read(iprot)
6577 
    iprot.readMessageEnd()
6578 
    result = getOrdersInBatch_result()
6579 
    try:
6580 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6581 
    except TransactionServiceException, ex:
6582 
      result.ex = ex
6583 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6584 
    result.write(oprot)
6585 
    oprot.writeMessageEnd()
6586 
    oprot.trans.flush()
6587 
 
6588 
  def process_getOrderCount(self, seqid, iprot, oprot):
6589 
    args = getOrderCount_args()
6590 
    args.read(iprot)
6591 
    iprot.readMessageEnd()
6592 
    result = getOrderCount_result()
6593 
    try:
6594 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6595 
    except TransactionServiceException, ex:
6596 
      result.ex = ex
6597 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6598 
    result.write(oprot)
6599 
    oprot.writeMessageEnd()
6600 
    oprot.trans.flush()
6601 
 
999 varun.gupt 6602 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6603 
    args = getOrdersByBillingDate_args()
6604 
    args.read(iprot)
6605 
    iprot.readMessageEnd()
6606 
    result = getOrdersByBillingDate_result()
6607 
    try:
6608 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6609 
    except TransactionServiceException, ex:
6610 
      result.ex = ex
6611 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6612 
    result.write(oprot)
6613 
    oprot.writeMessageEnd()
6614 
    oprot.trans.flush()
6615 
 
3427 chandransh 6616 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6617 
    args = getOrdersByShippingDate_args()
6618 
    args.read(iprot)
6619 
    iprot.readMessageEnd()
6620 
    result = getOrdersByShippingDate_result()
6621 
    try:
3451 chandransh 6622 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6623 
    except TransactionServiceException, ex:
6624 
      result.ex = ex
6625 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6626 
    result.write(oprot)
6627 
    oprot.writeMessageEnd()
6628 
    oprot.trans.flush()
6629 
 
1382 varun.gupt 6630 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6631 
    args = getReturnableOrdersForCustomer_args()
6632 
    args.read(iprot)
6633 
    iprot.readMessageEnd()
6634 
    result = getReturnableOrdersForCustomer_result()
6635 
    try:
6636 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6637 
    except TransactionServiceException, ex:
6638 
      result.ex = ex
6639 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6640 
    result.write(oprot)
6641 
    oprot.writeMessageEnd()
6642 
    oprot.trans.flush()
6643 
 
6644 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6645 
    args = getCancellableOrdersForCustomer_args()
6646 
    args.read(iprot)
6647 
    iprot.readMessageEnd()
6648 
    result = getCancellableOrdersForCustomer_result()
6649 
    try:
6650 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6651 
    except TransactionServiceException, ex:
6652 
      result.ex = ex
6653 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6654 
    result.write(oprot)
6655 
    oprot.writeMessageEnd()
6656 
    oprot.trans.flush()
6657 
 
483 rajveer 6658 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6659 
    args = changeOrderStatus_args()
94 ashish 6660 
    args.read(iprot)
6661 
    iprot.readMessageEnd()
483 rajveer 6662 
    result = changeOrderStatus_result()
94 ashish 6663 
    try:
483 rajveer 6664 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6665 
    except TransactionServiceException, ex:
6666 
      result.ex = ex
483 rajveer 6667 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6668 
    result.write(oprot)
6669 
    oprot.writeMessageEnd()
6670 
    oprot.trans.flush()
6671 
 
483 rajveer 6672 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6673 
    args = getOrdersForTransaction_args()
94 ashish 6674 
    args.read(iprot)
6675 
    iprot.readMessageEnd()
483 rajveer 6676 
    result = getOrdersForTransaction_result()
94 ashish 6677 
    try:
1528 ankur.sing 6678 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6679 
    except TransactionServiceException, ex:
6680 
      result.ex = ex
483 rajveer 6681 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6685 
 
483 rajveer 6686 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6687 
    args = getOrdersForCustomer_args()
94 ashish 6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
483 rajveer 6690 
    result = getOrdersForCustomer_result()
94 ashish 6691 
    try:
3014 chandransh 6692 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6693 
    except TransactionServiceException, ex:
6694 
      result.ex = ex
483 rajveer 6695 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6696 
    result.write(oprot)
6697 
    oprot.writeMessageEnd()
6698 
    oprot.trans.flush()
6699 
 
483 rajveer 6700 
  def process_createOrder(self, seqid, iprot, oprot):
6701 
    args = createOrder_args()
94 ashish 6702 
    args.read(iprot)
6703 
    iprot.readMessageEnd()
483 rajveer 6704 
    result = createOrder_result()
94 ashish 6705 
    try:
483 rajveer 6706 
      result.success = self._handler.createOrder(args.order)
94 ashish 6707 
    except TransactionServiceException, ex:
6708 
      result.ex = ex
483 rajveer 6709 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6710 
    result.write(oprot)
6711 
    oprot.writeMessageEnd()
6712 
    oprot.trans.flush()
6713 
 
483 rajveer 6714 
  def process_getOrder(self, seqid, iprot, oprot):
6715 
    args = getOrder_args()
94 ashish 6716 
    args.read(iprot)
6717 
    iprot.readMessageEnd()
483 rajveer 6718 
    result = getOrder_result()
94 ashish 6719 
    try:
483 rajveer 6720 
      result.success = self._handler.getOrder(args.id)
94 ashish 6721 
    except TransactionServiceException, ex:
6722 
      result.ex = ex
483 rajveer 6723 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6724 
    result.write(oprot)
6725 
    oprot.writeMessageEnd()
6726 
    oprot.trans.flush()
6727 
 
483 rajveer 6728 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6729 
    args = getLineItemsForOrder_args()
94 ashish 6730 
    args.read(iprot)
6731 
    iprot.readMessageEnd()
483 rajveer 6732 
    result = getLineItemsForOrder_result()
94 ashish 6733 
    try:
483 rajveer 6734 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6735 
    except TransactionServiceException, ex:
6736 
      result.ex = ex
483 rajveer 6737 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6738 
    result.write(oprot)
6739 
    oprot.writeMessageEnd()
6740 
    oprot.trans.flush()
6741 
 
4999 phani.kuma 6742 
  def process_getOrderList(self, seqid, iprot, oprot):
6743 
    args = getOrderList_args()
6744 
    args.read(iprot)
6745 
    iprot.readMessageEnd()
6746 
    result = getOrderList_result()
6747 
    result.success = self._handler.getOrderList(args.order_ids)
6748 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6749 
    result.write(oprot)
6750 
    oprot.writeMessageEnd()
6751 
    oprot.trans.flush()
6752 
 
5386 phani.kuma 6753 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6754 
    args = getOrderListForVendor_args()
6755 
    args.read(iprot)
6756 
    iprot.readMessageEnd()
6757 
    result = getOrderListForVendor_result()
6758 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6759 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6760 
    result.write(oprot)
6761 
    oprot.writeMessageEnd()
6762 
    oprot.trans.flush()
6763 
 
1528 ankur.sing 6764 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6765 
    args = getOrderForCustomer_args()
6766 
    args.read(iprot)
6767 
    iprot.readMessageEnd()
6768 
    result = getOrderForCustomer_result()
6769 
    try:
6770 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6771 
    except TransactionServiceException, ex:
6772 
      result.ex = ex
6773 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6774 
    result.write(oprot)
6775 
    oprot.writeMessageEnd()
6776 
    oprot.trans.flush()
6777 
 
3064 chandransh 6778 
  def process_getAlerts(self, seqid, iprot, oprot):
6779 
    args = getAlerts_args()
6780 
    args.read(iprot)
6781 
    iprot.readMessageEnd()
6782 
    result = getAlerts_result()
4444 rajveer 6783 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6784 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6785 
    result.write(oprot)
6786 
    oprot.writeMessageEnd()
6787 
    oprot.trans.flush()
6788 
 
4394 rajveer 6789 
  def process_addAlert(self, seqid, iprot, oprot):
6790 
    args = addAlert_args()
3064 chandransh 6791 
    args.read(iprot)
6792 
    iprot.readMessageEnd()
4394 rajveer 6793 
    result = addAlert_result()
4444 rajveer 6794 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6795 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6796 
    result.write(oprot)
6797 
    oprot.writeMessageEnd()
6798 
    oprot.trans.flush()
6799 
 
4444 rajveer 6800 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6801 
    args = markAlertsAsSeen_args()
6802 
    args.read(iprot)
6803 
    iprot.readMessageEnd()
6804 
    result = markAlertsAsSeen_result()
6805 
    self._handler.markAlertsAsSeen(args.warehouseId)
6806 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6807 
    result.write(oprot)
6808 
    oprot.writeMessageEnd()
6809 
    oprot.trans.flush()
6810 
 
3064 chandransh 6811 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6812 
    args = getValidOrderCount_args()
6813 
    args.read(iprot)
6814 
    iprot.readMessageEnd()
6815 
    result = getValidOrderCount_result()
6816 
    result.success = self._handler.getValidOrderCount()
6817 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6818 
    result.write(oprot)
6819 
    oprot.writeMessageEnd()
6820 
    oprot.trans.flush()
6821 
 
6822 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6823 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6824 
    args.read(iprot)
6825 
    iprot.readMessageEnd()
6826 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6827 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6828 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6829 
    result.write(oprot)
6830 
    oprot.writeMessageEnd()
6831 
    oprot.trans.flush()
6832 
 
6833 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6834 
    args = getValidOrdersAmountRange_args()
6835 
    args.read(iprot)
6836 
    iprot.readMessageEnd()
6837 
    result = getValidOrdersAmountRange_result()
6838 
    result.success = self._handler.getValidOrdersAmountRange()
6839 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6840 
    result.write(oprot)
6841 
    oprot.writeMessageEnd()
6842 
    oprot.trans.flush()
6843 
 
6844 
  def process_getValidOrders(self, seqid, iprot, oprot):
6845 
    args = getValidOrders_args()
6846 
    args.read(iprot)
6847 
    iprot.readMessageEnd()
6848 
    result = getValidOrders_result()
5874 rajveer 6849 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6850 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6851 
    result.write(oprot)
6852 
    oprot.writeMessageEnd()
6853 
    oprot.trans.flush()
6854 
 
1220 chandransh 6855 
  def process_batchOrders(self, seqid, iprot, oprot):
6856 
    args = batchOrders_args()
6857 
    args.read(iprot)
6858 
    iprot.readMessageEnd()
6859 
    result = batchOrders_result()
6860 
    try:
6861 
      result.success = self._handler.batchOrders(args.warehouseId)
6862 
    except TransactionServiceException, ex:
6863 
      result.ex = ex
6864 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6865 
    result.write(oprot)
6866 
    oprot.writeMessageEnd()
6867 
    oprot.trans.flush()
6868 
 
1208 chandransh 6869 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6870 
    args = markOrderAsOutOfStock_args()
6871 
    args.read(iprot)
6872 
    iprot.readMessageEnd()
6873 
    result = markOrderAsOutOfStock_result()
6874 
    try:
6875 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6876 
    except TransactionServiceException, ex:
6877 
      result.ex = ex
6878 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
6882 
 
3064 chandransh 6883 
  def process_verifyOrder(self, seqid, iprot, oprot):
6884 
    args = verifyOrder_args()
759 chandransh 6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
3064 chandransh 6887 
    result = verifyOrder_result()
759 chandransh 6888 
    try:
3064 chandransh 6889 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6890 
    except TransactionServiceException, ex:
6891 
      result.ex = ex
3064 chandransh 6892 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
6896 
 
3064 chandransh 6897 
  def process_acceptOrder(self, seqid, iprot, oprot):
6898 
    args = acceptOrder_args()
1113 chandransh 6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
3064 chandransh 6901 
    result = acceptOrder_result()
1113 chandransh 6902 
    try:
3064 chandransh 6903 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6904 
    except TransactionServiceException, ex:
6905 
      result.ex = ex
3064 chandransh 6906 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6907 
    result.write(oprot)
6908 
    oprot.writeMessageEnd()
6909 
    oprot.trans.flush()
6910 
 
3064 chandransh 6911 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6912 
    args = addBillingDetails_args()
1135 chandransh 6913 
    args.read(iprot)
6914 
    iprot.readMessageEnd()
3064 chandransh 6915 
    result = addBillingDetails_result()
1135 chandransh 6916 
    try:
5110 mandeep.dh 6917 
      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 6918 
    except TransactionServiceException, ex:
6919 
      result.ex = ex
3064 chandransh 6920 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6921 
    result.write(oprot)
6922 
    oprot.writeMessageEnd()
6923 
    oprot.trans.flush()
6924 
 
4579 rajveer 6925 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6926 
    args = addInvoiceNumber_args()
6927 
    args.read(iprot)
6928 
    iprot.readMessageEnd()
6929 
    result = addInvoiceNumber_result()
6930 
    try:
4763 rajveer 6931 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6932 
    except TransactionServiceException, ex:
6933 
      result.ex = ex
6934 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
6938 
 
4410 rajveer 6939 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6940 
    args = markOrdersAsShippedFromWarehouse_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = markOrdersAsShippedFromWarehouse_result()
6944 
    try:
4789 rajveer 6945 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6946 
    except TransactionServiceException, ex:
6947 
      result.ex = ex
6948 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6949 
    result.write(oprot)
6950 
    oprot.writeMessageEnd()
6951 
    oprot.trans.flush()
6952 
 
5676 rajveer 6953 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6954 
    args = markOrdersAsReturnedFromStore_args()
6955 
    args.read(iprot)
6956 
    iprot.readMessageEnd()
6957 
    result = markOrdersAsReturnedFromStore_result()
6958 
    try:
5713 rajveer 6959 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6960 
    except TransactionServiceException, ex:
6961 
      result.ex = ex
6962 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6963 
    result.write(oprot)
6964 
    oprot.writeMessageEnd()
6965 
    oprot.trans.flush()
6966 
 
3064 chandransh 6967 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6968 
    args = markOrdersAsPickedUp_args()
304 ashish 6969 
    args.read(iprot)
6970 
    iprot.readMessageEnd()
3064 chandransh 6971 
    result = markOrdersAsPickedUp_result()
6972 
    try:
4910 phani.kuma 6973 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6974 
    except TransactionServiceException, ex:
6975 
      result.ex = ex
6976 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6977 
    result.write(oprot)
6978 
    oprot.writeMessageEnd()
6979 
    oprot.trans.flush()
94 ashish 6980 
 
4910 phani.kuma 6981 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6982 
    args = getOrdersNotPickedUp_args()
6983 
    args.read(iprot)
6984 
    iprot.readMessageEnd()
6985 
    result = getOrdersNotPickedUp_result()
6986 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6987 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6988 
    result.write(oprot)
6989 
    oprot.writeMessageEnd()
6990 
    oprot.trans.flush()
6991 
 
3064 chandransh 6992 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6993 
    args = markOrdersAsDelivered_args()
304 ashish 6994 
    args.read(iprot)
6995 
    iprot.readMessageEnd()
3064 chandransh 6996 
    result = markOrdersAsDelivered_result()
6997 
    try:
6998 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6999 
    except TransactionServiceException, ex:
7000 
      result.ex = ex
7001 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7002 
    result.write(oprot)
7003 
    oprot.writeMessageEnd()
7004 
    oprot.trans.flush()
7005 
 
4910 phani.kuma 7006 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7007 
    args = markAsRTOrders_args()
1596 ankur.sing 7008 
    args.read(iprot)
7009 
    iprot.readMessageEnd()
4910 phani.kuma 7010 
    result = markAsRTOrders_result()
3064 chandransh 7011 
    try:
4910 phani.kuma 7012 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7013 
    except TransactionServiceException, ex:
7014 
      result.ex = ex
4910 phani.kuma 7015 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7016 
    result.write(oprot)
7017 
    oprot.writeMessageEnd()
7018 
    oprot.trans.flush()
304 ashish 7019 
 
4910 phani.kuma 7020 
  def process_getRTOrders(self, seqid, iprot, oprot):
7021 
    args = getRTOrders_args()
7022 
    args.read(iprot)
7023 
    iprot.readMessageEnd()
7024 
    result = getRTOrders_result()
7025 
    result.success = self._handler.getRTOrders(args.providerId)
7026 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7027 
    result.write(oprot)
7028 
    oprot.writeMessageEnd()
7029 
    oprot.trans.flush()
7030 
 
3064 chandransh 7031 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7032 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7033 
    args.read(iprot)
7034 
    iprot.readMessageEnd()
3064 chandransh 7035 
    result = updateNonDeliveryReason_result()
7036 
    try:
4910 phani.kuma 7037 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7038 
    except TransactionServiceException, ex:
7039 
      result.ex = ex
7040 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7041 
    result.write(oprot)
7042 
    oprot.writeMessageEnd()
7043 
    oprot.trans.flush()
1596 ankur.sing 7044 
 
4910 phani.kuma 7045 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7046 
    args = getNonDeliveredOrdersbyCourier_args()
7047 
    args.read(iprot)
7048 
    iprot.readMessageEnd()
7049 
    result = getNonDeliveredOrdersbyCourier_result()
7050 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7051 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7052 
    result.write(oprot)
7053 
    oprot.writeMessageEnd()
7054 
    oprot.trans.flush()
7055 
 
7056 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7057 
    args = markOrdersAsLocalConnected_args()
7058 
    args.read(iprot)
7059 
    iprot.readMessageEnd()
7060 
    result = markOrdersAsLocalConnected_result()
7061 
    try:
7062 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7063 
    except TransactionServiceException, ex:
7064 
      result.ex = ex
7065 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7066 
    result.write(oprot)
7067 
    oprot.writeMessageEnd()
7068 
    oprot.trans.flush()
7069 
 
7070 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7071 
    args = getOrdersNotLocalConnected_args()
7072 
    args.read(iprot)
7073 
    iprot.readMessageEnd()
7074 
    result = getOrdersNotLocalConnected_result()
7075 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7076 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7077 
    result.write(oprot)
7078 
    oprot.writeMessageEnd()
7079 
    oprot.trans.flush()
7080 
 
7081 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7082 
    args = markOrdersAsDestinationCityReached_args()
7083 
    args.read(iprot)
7084 
    iprot.readMessageEnd()
7085 
    result = markOrdersAsDestinationCityReached_result()
7086 
    try:
7087 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7088 
    except TransactionServiceException, ex:
7089 
      result.ex = ex
7090 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7091 
    result.write(oprot)
7092 
    oprot.writeMessageEnd()
7093 
    oprot.trans.flush()
7094 
 
7095 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7096 
    args = markOrdersAsFirstDeliveryAttempted_args()
7097 
    args.read(iprot)
7098 
    iprot.readMessageEnd()
7099 
    result = markOrdersAsFirstDeliveryAttempted_result()
7100 
    try:
7101 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7102 
    except TransactionServiceException, ex:
7103 
      result.ex = ex
7104 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7105 
    result.write(oprot)
7106 
    oprot.writeMessageEnd()
7107 
    oprot.trans.flush()
7108 
 
3064 chandransh 7109 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7110 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7111 
    args.read(iprot)
7112 
    iprot.readMessageEnd()
3064 chandransh 7113 
    result = getUndeliveredOrders_result()
7114 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7115 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
4783 phani.kuma 7120 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7121 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7125 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7126 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
2536 chandransh 7131 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7132 
    args = toggleDOAFlag_args()
7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
7135 
    result = toggleDOAFlag_result()
7136 
    try:
7137 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7138 
    except TransactionServiceException, ex:
7139 
      result.ex = ex
7140 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7141 
    result.write(oprot)
7142 
    oprot.writeMessageEnd()
7143 
    oprot.trans.flush()
1886 ankur.sing 7144 
 
4712 rajveer 7145 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7146 
    args = markOrderAsDelivered_args()
7147 
    args.read(iprot)
7148 
    iprot.readMessageEnd()
7149 
    result = markOrderAsDelivered_result()
7150 
    try:
7151 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7152 
    except TransactionServiceException, ex:
7153 
      result.ex = ex
7154 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7155 
    result.write(oprot)
7156 
    oprot.writeMessageEnd()
7157 
    oprot.trans.flush()
7158 
 
5553 rajveer 7159 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7160 
    args = markOrderAsReceivedAtStore_args()
7161 
    args.read(iprot)
7162 
    iprot.readMessageEnd()
7163 
    result = markOrderAsReceivedAtStore_result()
7164 
    try:
7165 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7166 
    except TransactionServiceException, ex:
7167 
      result.ex = ex
7168 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7169 
    result.write(oprot)
7170 
    oprot.writeMessageEnd()
7171 
    oprot.trans.flush()
7172 
 
4454 rajveer 7173 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7174 
    args = markOrderDoaRequestReceived_args()
7175 
    args.read(iprot)
7176 
    iprot.readMessageEnd()
7177 
    result = markOrderDoaRequestReceived_result()
7178 
    try:
7179 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7180 
    except TransactionServiceException, ex:
7181 
      result.ex = ex
7182 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7183 
    result.write(oprot)
7184 
    oprot.writeMessageEnd()
7185 
    oprot.trans.flush()
7186 
 
7187 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7188 
    args = markOrderDoaRequestAuthorized_args()
7189 
    args.read(iprot)
7190 
    iprot.readMessageEnd()
7191 
    result = markOrderDoaRequestAuthorized_result()
7192 
    try:
7193 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7194 
    except TransactionServiceException, ex:
7195 
      result.ex = ex
7196 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7197 
    result.write(oprot)
7198 
    oprot.writeMessageEnd()
7199 
    oprot.trans.flush()
7200 
 
4488 rajveer 7201 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7202 
    args = markOrderReturnRequestReceived_args()
7203 
    args.read(iprot)
7204 
    iprot.readMessageEnd()
7205 
    result = markOrderReturnRequestReceived_result()
7206 
    try:
7207 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7208 
    except TransactionServiceException, ex:
7209 
      result.ex = ex
7210 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7211 
    result.write(oprot)
7212 
    oprot.writeMessageEnd()
7213 
    oprot.trans.flush()
7214 
 
7215 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7216 
    args = markOrderReturnRequestAuthorized_args()
7217 
    args.read(iprot)
7218 
    iprot.readMessageEnd()
7219 
    result = markOrderReturnRequestAuthorized_result()
7220 
    try:
7221 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7222 
    except TransactionServiceException, ex:
7223 
      result.ex = ex
7224 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7225 
    result.write(oprot)
7226 
    oprot.writeMessageEnd()
7227 
    oprot.trans.flush()
7228 
 
2536 chandransh 7229 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7230 
    args = requestPickupNumber_args()
7231 
    args.read(iprot)
7232 
    iprot.readMessageEnd()
7233 
    result = requestPickupNumber_result()
7234 
    try:
4579 rajveer 7235 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7236 
    except TransactionServiceException, ex:
7237 
      result.ex = ex
7238 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7239 
    result.write(oprot)
7240 
    oprot.writeMessageEnd()
7241 
    oprot.trans.flush()
7242 
 
7243 
  def process_authorizePickup(self, seqid, iprot, oprot):
7244 
    args = authorizePickup_args()
7245 
    args.read(iprot)
7246 
    iprot.readMessageEnd()
7247 
    result = authorizePickup_result()
7248 
    try:
4602 rajveer 7249 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7250 
    except TransactionServiceException, ex:
7251 
      result.ex = ex
7252 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7253 
    result.write(oprot)
7254 
    oprot.writeMessageEnd()
7255 
    oprot.trans.flush()
7256 
 
2764 chandransh 7257 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7258 
    args = markDoasAsPickedUp_args()
7259 
    args.read(iprot)
7260 
    iprot.readMessageEnd()
7261 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7262 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7263 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7264 
    result.write(oprot)
7265 
    oprot.writeMessageEnd()
7266 
    oprot.trans.flush()
7267 
 
4910 phani.kuma 7268 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7269 
    args = getDoasNotPickedUp_args()
7270 
    args.read(iprot)
7271 
    iprot.readMessageEnd()
7272 
    result = getDoasNotPickedUp_result()
7273 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7274 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7275 
    result.write(oprot)
7276 
    oprot.writeMessageEnd()
7277 
    oprot.trans.flush()
7278 
 
4741 phani.kuma 7279 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7280 
    args = markReturnOrdersAsPickedUp_args()
7281 
    args.read(iprot)
7282 
    iprot.readMessageEnd()
7283 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7284 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7285 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7286 
    result.write(oprot)
7287 
    oprot.writeMessageEnd()
7288 
    oprot.trans.flush()
7289 
 
4910 phani.kuma 7290 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7291 
    args = getReturnOrdersNotPickedUp_args()
7292 
    args.read(iprot)
7293 
    iprot.readMessageEnd()
7294 
    result = getReturnOrdersNotPickedUp_result()
7295 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7296 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7297 
    result.write(oprot)
7298 
    oprot.writeMessageEnd()
7299 
    oprot.trans.flush()
7300 
 
2616 chandransh 7301 
  def process_receiveReturn(self, seqid, iprot, oprot):
7302 
    args = receiveReturn_args()
2591 chandransh 7303 
    args.read(iprot)
7304 
    iprot.readMessageEnd()
2616 chandransh 7305 
    result = receiveReturn_result()
2591 chandransh 7306 
    try:
4479 rajveer 7307 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7308 
    except TransactionServiceException, ex:
7309 
      result.ex = ex
2616 chandransh 7310 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
2536 chandransh 7314 
 
2591 chandransh 7315 
  def process_validateDoa(self, seqid, iprot, oprot):
7316 
    args = validateDoa_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = validateDoa_result()
7320 
    try:
7321 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7322 
    except TransactionServiceException, ex:
7323 
      result.ex = ex
7324 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
4495 rajveer 7329 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7330 
    args = validateReturnProduct_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = validateReturnProduct_result()
7334 
    try:
7335 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7336 
    except TransactionServiceException, ex:
7337 
      result.ex = ex
7338 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7339 
    result.write(oprot)
7340 
    oprot.writeMessageEnd()
7341 
    oprot.trans.flush()
7342 
 
2616 chandransh 7343 
  def process_reshipOrder(self, seqid, iprot, oprot):
7344 
    args = reshipOrder_args()
7345 
    args.read(iprot)
7346 
    iprot.readMessageEnd()
7347 
    result = reshipOrder_result()
7348 
    try:
7349 
      result.success = self._handler.reshipOrder(args.orderId)
7350 
    except TransactionServiceException, ex:
7351 
      result.ex = ex
7352 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
2591 chandransh 7356 
 
2616 chandransh 7357 
  def process_refundOrder(self, seqid, iprot, oprot):
7358 
    args = refundOrder_args()
7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
7361 
    result = refundOrder_result()
7362 
    try:
3226 chandransh 7363 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7364 
    except TransactionServiceException, ex:
7365 
      result.ex = ex
7366 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7367 
    result.write(oprot)
7368 
    oprot.writeMessageEnd()
7369 
    oprot.trans.flush()
7370 
 
2690 chandransh 7371 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7372 
    args = getReturnOrders_args()
7373 
    args.read(iprot)
7374 
    iprot.readMessageEnd()
7375 
    result = getReturnOrders_result()
7376 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7377 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7378 
    result.write(oprot)
7379 
    oprot.writeMessageEnd()
7380 
    oprot.trans.flush()
2616 chandransh 7381 
 
5481 phani.kuma 7382 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7383 
    args = getAllReturnOrders_args()
7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
7386 
    result = getAllReturnOrders_result()
7387 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7388 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7389 
    result.write(oprot)
7390 
    oprot.writeMessageEnd()
7391 
    oprot.trans.flush()
7392 
 
2700 chandransh 7393 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7394 
    args = getReturnOrder_args()
7395 
    args.read(iprot)
7396 
    iprot.readMessageEnd()
7397 
    result = getReturnOrder_result()
7398 
    try:
7399 
      result.success = self._handler.getReturnOrder(args.id)
7400 
    except TransactionServiceException, ex:
7401 
      result.ex = ex
7402 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
2690 chandransh 7407 
  def process_processReturn(self, seqid, iprot, oprot):
7408 
    args = processReturn_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = processReturn_result()
7412 
    try:
7413 
      self._handler.processReturn(args.returnOrderId)
7414 
    except TransactionServiceException, ex:
7415 
      result.ex = ex
7416 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
3451 chandransh 7421 
  def process_updateWeight(self, seqid, iprot, oprot):
7422 
    args = updateWeight_args()
7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
7425 
    result = updateWeight_result()
7426 
    try:
7427 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7428 
    except TransactionServiceException, ex:
7429 
      result.ex = ex
7430 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
2819 chandransh 7434 
 
3469 chandransh 7435 
  def process_changeItem(self, seqid, iprot, oprot):
7436 
    args = changeItem_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = changeItem_result()
7440 
    try:
7441 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7442 
    except TransactionServiceException, ex:
7443 
      result.ex = ex
7444 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7445 
    result.write(oprot)
7446 
    oprot.writeMessageEnd()
7447 
    oprot.trans.flush()
3451 chandransh 7448 
 
3469 chandransh 7449 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7450 
    args = shiftToWarehouse_args()
7451 
    args.read(iprot)
7452 
    iprot.readMessageEnd()
7453 
    result = shiftToWarehouse_result()
7454 
    try:
7455 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7456 
    except TransactionServiceException, ex:
7457 
      result.ex = ex
7458 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
7462 
 
3553 chandransh 7463 
  def process_addDelayReason(self, seqid, iprot, oprot):
7464 
    args = addDelayReason_args()
7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
7467 
    result = addDelayReason_result()
7468 
    try:
4647 rajveer 7469 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7470 
    except TransactionServiceException, ex:
7471 
      result.ex = ex
7472 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7473 
    result.write(oprot)
7474 
    oprot.writeMessageEnd()
7475 
    oprot.trans.flush()
3469 chandransh 7476 
 
3956 chandransh 7477 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7478 
    args = reconcileCodCollection_args()
7479 
    args.read(iprot)
7480 
    iprot.readMessageEnd()
7481 
    result = reconcileCodCollection_result()
7482 
    try:
7483 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7484 
    except TransactionServiceException, ex:
7485 
      result.ex = ex
7486 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7487 
    result.write(oprot)
7488 
    oprot.writeMessageEnd()
7489 
    oprot.trans.flush()
3553 chandransh 7490 
 
4008 mandeep.dh 7491 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7492 
    args = getTransactionsRequiringExtraProcessing_args()
7493 
    args.read(iprot)
7494 
    iprot.readMessageEnd()
7495 
    result = getTransactionsRequiringExtraProcessing_result()
7496 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7497 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7498 
    result.write(oprot)
7499 
    oprot.writeMessageEnd()
7500 
    oprot.trans.flush()
3956 chandransh 7501 
 
4008 mandeep.dh 7502 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7503 
    args = markTransactionAsProcessed_args()
7504 
    args.read(iprot)
7505 
    iprot.readMessageEnd()
7506 
    result = markTransactionAsProcessed_result()
7507 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7508 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7509 
    result.write(oprot)
7510 
    oprot.writeMessageEnd()
7511 
    oprot.trans.flush()
7512 
 
4018 chandransh 7513 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7514 
    args = getItemWiseRiskyOrdersCount_args()
7515 
    args.read(iprot)
7516 
    iprot.readMessageEnd()
7517 
    result = getItemWiseRiskyOrdersCount_result()
7518 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7519 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7520 
    result.write(oprot)
7521 
    oprot.writeMessageEnd()
7522 
    oprot.trans.flush()
4008 mandeep.dh 7523 
 
4295 varun.gupt 7524 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7525 
    args = getOrdersForItemIds_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = getOrdersForItemIds_result()
7529 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7530 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
4247 rajveer 7535 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7536 
    args = markOrderCancellationRequestReceived_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = markOrderCancellationRequestReceived_result()
7540 
    try:
7541 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
4018 chandransh 7548 
 
4247 rajveer 7549 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7550 
    args = markOrderCancellationRequestConfirmed_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = markOrderCancellationRequestConfirmed_result()
7554 
    try:
7555 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
7563 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7564 
    args = markOrderCancellationRequestDenied_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = markOrderCancellationRequestDenied_result()
7568 
    try:
7569 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
4258 rajveer 7577 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7578 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
4258 rajveer 7581 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7582 
    try:
4258 rajveer 7583 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7584 
    except TransactionServiceException, ex:
7585 
      result.ex = ex
4258 rajveer 7586 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
4259 anupam.sin 7591 
  def process_refundTransaction(self, seqid, iprot, oprot):
7592 
    args = refundTransaction_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = refundTransaction_result()
7596 
    try:
7597 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7598 
    except TransactionServiceException, ex:
7599 
      result.ex = ex
7600 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7601 
    result.write(oprot)
7602 
    oprot.writeMessageEnd()
7603 
    oprot.trans.flush()
4247 rajveer 7604 
 
4324 mandeep.dh 7605 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7606 
    args = updateShipmentAddress_args()
7607 
    args.read(iprot)
7608 
    iprot.readMessageEnd()
7609 
    result = updateShipmentAddress_result()
7610 
    try:
7611 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7612 
    except TransactionServiceException, ex:
7613 
      result.ex = ex
7614 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7615 
    result.write(oprot)
7616 
    oprot.writeMessageEnd()
7617 
    oprot.trans.flush()
7618 
 
4285 rajveer 7619 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7620 
    args = acceptOrdersForItemId_args()
7621 
    args.read(iprot)
7622 
    iprot.readMessageEnd()
7623 
    result = acceptOrdersForItemId_result()
7624 
    try:
7625 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7626 
    except TransactionServiceException, ex:
7627 
      result.ex = ex
7628 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7629 
    result.write(oprot)
7630 
    oprot.writeMessageEnd()
7631 
    oprot.trans.flush()
4259 anupam.sin 7632 
 
4303 rajveer 7633 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7634 
    args = markOrdersAsPORaised_args()
7635 
    args.read(iprot)
7636 
    iprot.readMessageEnd()
7637 
    result = markOrdersAsPORaised_result()
7638 
    try:
4369 rajveer 7639 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7640 
    except TransactionServiceException, ex:
7641 
      result.ex = ex
7642 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7643 
    result.write(oprot)
7644 
    oprot.writeMessageEnd()
7645 
    oprot.trans.flush()
4285 rajveer 7646 
 
4303 rajveer 7647 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7648 
    args = markOrdersAsReversalInitiated_args()
7649 
    args.read(iprot)
7650 
    iprot.readMessageEnd()
7651 
    result = markOrdersAsReversalInitiated_result()
7652 
    try:
4369 rajveer 7653 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7654 
    except TransactionServiceException, ex:
7655 
      result.ex = ex
7656 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7657 
    result.write(oprot)
7658 
    oprot.writeMessageEnd()
7659 
    oprot.trans.flush()
7660 
 
7661 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7662 
    args = markOrdersAsNotAvailabke_args()
7663 
    args.read(iprot)
7664 
    iprot.readMessageEnd()
7665 
    result = markOrdersAsNotAvailabke_result()
7666 
    try:
4369 rajveer 7667 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7668 
    except TransactionServiceException, ex:
7669 
      result.ex = ex
7670 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7671 
    result.write(oprot)
7672 
    oprot.writeMessageEnd()
7673 
    oprot.trans.flush()
7674 
 
4369 rajveer 7675 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7676 
    args = markOrdersAsTimeout_args()
7677 
    args.read(iprot)
7678 
    iprot.readMessageEnd()
7679 
    result = markOrdersAsTimeout_result()
7680 
    try:
7681 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7682 
    except TransactionServiceException, ex:
7683 
      result.ex = ex
7684 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7685 
    result.write(oprot)
7686 
    oprot.writeMessageEnd()
7687 
    oprot.trans.flush()
4303 rajveer 7688 
 
4662 rajveer 7689 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7690 
    args = markOrderAsLostInTransit_args()
7691 
    args.read(iprot)
7692 
    iprot.readMessageEnd()
7693 
    result = markOrderAsLostInTransit_result()
7694 
    try:
7695 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7696 
    except TransactionServiceException, ex:
7697 
      result.ex = ex
7698 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7699 
    result.write(oprot)
7700 
    oprot.writeMessageEnd()
7701 
    oprot.trans.flush()
7702 
 
4386 anupam.sin 7703 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7704 
    args = getOrderForAwb_args()
7705 
    args.read(iprot)
7706 
    iprot.readMessageEnd()
7707 
    result = getOrderForAwb_result()
7708 
    try:
7709 
      result.success = self._handler.getOrderForAwb(args.awb)
7710 
    except TransactionServiceException, ex:
7711 
      result.ex = ex
7712 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7713 
    result.write(oprot)
7714 
    oprot.writeMessageEnd()
7715 
    oprot.trans.flush()
4369 rajveer 7716 
 
4506 phani.kuma 7717 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7718 
    args = getOrdersForProviderForStatus_args()
7719 
    args.read(iprot)
7720 
    iprot.readMessageEnd()
7721 
    result = getOrdersForProviderForStatus_result()
7722 
    try:
4910 phani.kuma 7723 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7724 
    except TransactionServiceException, ex:
7725 
      result.ex = ex
7726 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7727 
    result.write(oprot)
7728 
    oprot.writeMessageEnd()
7729 
    oprot.trans.flush()
4386 anupam.sin 7730 
 
4600 varun.gupt 7731 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7732 
    args = getBilledOrdersForVendor_args()
7733 
    args.read(iprot)
7734 
    iprot.readMessageEnd()
7735 
    result = getBilledOrdersForVendor_result()
7736 
    try:
7737 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7738 
    except TransactionServiceException, ex:
7739 
      result.ex = ex
7740 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7741 
    result.write(oprot)
7742 
    oprot.writeMessageEnd()
7743 
    oprot.trans.flush()
4506 phani.kuma 7744 
 
4607 rajveer 7745 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7746 
    args = getSlippedSippingDateOrders_args()
7747 
    args.read(iprot)
7748 
    iprot.readMessageEnd()
7749 
    result = getSlippedSippingDateOrders_result()
7750 
    try:
7751 
      result.success = self._handler.getSlippedSippingDateOrders()
7752 
    except TransactionServiceException, ex:
7753 
      result.ex = ex
7754 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7755 
    result.write(oprot)
7756 
    oprot.writeMessageEnd()
7757 
    oprot.trans.flush()
7758 
 
4709 rajveer 7759 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7760 
    args = getCancelledOrders_args()
7761 
    args.read(iprot)
7762 
    iprot.readMessageEnd()
7763 
    result = getCancelledOrders_result()
7764 
    try:
7765 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7766 
    except TransactionServiceException, ex:
7767 
      result.ex = ex
7768 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7769 
    result.write(oprot)
7770 
    oprot.writeMessageEnd()
7771 
    oprot.trans.flush()
7772 
 
4600 varun.gupt 7773 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7774 
    args = saveBluedartSettlements_args()
7775 
    args.read(iprot)
7776 
    iprot.readMessageEnd()
7777 
    result = saveBluedartSettlements_result()
7778 
    try:
7779 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7780 
    except TransactionServiceException, ex:
7781 
      result.ex = ex
7782 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7783 
    result.write(oprot)
7784 
    oprot.writeMessageEnd()
7785 
    oprot.trans.flush()
7786 
 
7787 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7788 
    args = savePaymentSettlements_args()
7789 
    args.read(iprot)
7790 
    iprot.readMessageEnd()
7791 
    result = savePaymentSettlements_result()
7792 
    try:
4905 varun.gupt 7793 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7794 
    except TransactionServiceException, ex:
7795 
      result.ex = ex
7796 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7797 
    result.write(oprot)
7798 
    oprot.writeMessageEnd()
7799 
    oprot.trans.flush()
7800 
 
7801 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7802 
    args = saveEBSSettlementSummary_args()
7803 
    args.read(iprot)
7804 
    iprot.readMessageEnd()
7805 
    result = saveEBSSettlementSummary_result()
7806 
    try:
7807 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7808 
    except TransactionServiceException, ex:
7809 
      result.ex = ex
7810 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7811 
    result.write(oprot)
7812 
    oprot.writeMessageEnd()
7813 
    oprot.trans.flush()
7814 
 
5386 phani.kuma 7815 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7816 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7817 
    args.read(iprot)
7818 
    iprot.readMessageEnd()
5386 phani.kuma 7819 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7820 
    try:
5386 phani.kuma 7821 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7822 
    except TransactionServiceException, ex:
7823 
      result.ex = ex
5386 phani.kuma 7824 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7825 
    result.write(oprot)
7826 
    oprot.writeMessageEnd()
7827 
    oprot.trans.flush()
7828 
 
5386 phani.kuma 7829 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7830 
    args = getSettlementForCod_args()
7831 
    args.read(iprot)
7832 
    iprot.readMessageEnd()
7833 
    result = getSettlementForCod_result()
7834 
    try:
7835 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7836 
    except TransactionServiceException, ex:
7837 
      result.ex = ex
7838 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7839 
    result.write(oprot)
7840 
    oprot.writeMessageEnd()
7841 
    oprot.trans.flush()
7842 
 
4600 varun.gupt 7843 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7844 
    args = getEBSSettlementSummaries_args()
7845 
    args.read(iprot)
7846 
    iprot.readMessageEnd()
7847 
    result = getEBSSettlementSummaries_result()
7848 
    try:
7849 
      result.success = self._handler.getEBSSettlementSummaries()
7850 
    except TransactionServiceException, ex:
7851 
      result.ex = ex
7852 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7853 
    result.write(oprot)
7854 
    oprot.writeMessageEnd()
7855 
    oprot.trans.flush()
7856 
 
7857 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7858 
    args = markEBSSettlementUploaded_args()
7859 
    args.read(iprot)
7860 
    iprot.readMessageEnd()
7861 
    result = markEBSSettlementUploaded_result()
7862 
    try:
7863 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7864 
    except TransactionServiceException, ex:
7865 
      result.ex = ex
7866 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7867 
    result.write(oprot)
7868 
    oprot.writeMessageEnd()
7869 
    oprot.trans.flush()
7870 
 
7871 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7872 
    args = getEBSSettlementDate_args()
7873 
    args.read(iprot)
7874 
    iprot.readMessageEnd()
7875 
    result = getEBSSettlementDate_result()
7876 
    try:
7877 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7878 
    except TransactionServiceException, ex:
7879 
      result.ex = ex
7880 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7881 
    result.write(oprot)
7882 
    oprot.writeMessageEnd()
7883 
    oprot.trans.flush()
7884 
 
4715 varun.gupt 7885 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7886 
    args = getSettlementsByDate_args()
7887 
    args.read(iprot)
7888 
    iprot.readMessageEnd()
7889 
    result = getSettlementsByDate_result()
7890 
    try:
7891 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7892 
    except TransactionServiceException, ex:
7893 
      result.ex = ex
7894 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7895 
    result.write(oprot)
7896 
    oprot.writeMessageEnd()
7897 
    oprot.trans.flush()
4600 varun.gupt 7898 
 
4715 varun.gupt 7899 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7900 
    args = getReshippedOrderIds_args()
7901 
    args.read(iprot)
7902 
    iprot.readMessageEnd()
7903 
    result = getReshippedOrderIds_result()
7904 
    try:
7905 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7906 
    except TransactionServiceException, ex:
7907 
      result.ex = ex
7908 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7909 
    result.write(oprot)
7910 
    oprot.writeMessageEnd()
7911 
    oprot.trans.flush()
7912 
 
5481 phani.kuma 7913 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7914 
    args = getBilledOrders_args()
4875 varun.gupt 7915 
    args.read(iprot)
7916 
    iprot.readMessageEnd()
5481 phani.kuma 7917 
    result = getBilledOrders_result()
4875 varun.gupt 7918 
    try:
5481 phani.kuma 7919 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7920 
    except TransactionServiceException, ex:
7921 
      result.ex = ex
5481 phani.kuma 7922 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7923 
    result.write(oprot)
7924 
    oprot.writeMessageEnd()
7925 
    oprot.trans.flush()
4757 mandeep.dh 7926 
 
5031 varun.gupt 7927 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7928 
    args = getStatusDistributionOfOrders_args()
7929 
    args.read(iprot)
7930 
    iprot.readMessageEnd()
7931 
    result = getStatusDistributionOfOrders_result()
7932 
    try:
7933 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7934 
    except TransactionServiceException, ex:
7935 
      result.ex = ex
7936 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7937 
    result.write(oprot)
7938 
    oprot.writeMessageEnd()
7939 
    oprot.trans.flush()
4875 varun.gupt 7940 
 
5067 varun.gupt 7941 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7942 
    args = getOrderIdsForStatus_args()
7943 
    args.read(iprot)
7944 
    iprot.readMessageEnd()
7945 
    result = getOrderIdsForStatus_result()
7946 
    try:
7947 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7948 
    except TransactionServiceException, ex:
7949 
      result.ex = ex
7950 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7951 
    result.write(oprot)
7952 
    oprot.writeMessageEnd()
7953 
    oprot.trans.flush()
5031 varun.gupt 7954 
 
5348 anupam.sin 7955 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7956 
    args = updateCODAgent_args()
7957 
    args.read(iprot)
7958 
    iprot.readMessageEnd()
7959 
    result = updateCODAgent_result()
7960 
    try:
7961 
      self._handler.updateCODAgent(args.agent, args.orderId)
7962 
    except TransactionServiceException, ex:
7963 
      result.ex = ex
7964 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7965 
    result.write(oprot)
7966 
    oprot.writeMessageEnd()
7967 
    oprot.trans.flush()
7968 
 
5099 varun.gupt 7969 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7970 
    args = updateOrderAsPaidToVendor_args()
7971 
    args.read(iprot)
7972 
    iprot.readMessageEnd()
7973 
    result = updateOrderAsPaidToVendor_result()
7974 
    try:
7975 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7976 
    except TransactionServiceException, ex:
7977 
      result.ex = ex
7978 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7979 
    result.write(oprot)
7980 
    oprot.writeMessageEnd()
7981 
    oprot.trans.flush()
5067 varun.gupt 7982 
 
5386 phani.kuma 7983 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7984 
    args = updateOrderOnlyAsPaidToVendor_args()
7985 
    args.read(iprot)
7986 
    iprot.readMessageEnd()
7987 
    result = updateOrderOnlyAsPaidToVendor_result()
7988 
    try:
7989 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7990 
    except TransactionServiceException, ex:
7991 
      result.ex = ex
7992 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7993 
    result.write(oprot)
7994 
    oprot.writeMessageEnd()
7995 
    oprot.trans.flush()
7996 
 
5208 varun.gupt 7997 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7998 
    args = getRefundedOrdersMarkedPaid_args()
7999 
    args.read(iprot)
8000 
    iprot.readMessageEnd()
8001 
    result = getRefundedOrdersMarkedPaid_result()
8002 
    try:
8003 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8004 
    except TransactionServiceException, ex:
8005 
      result.ex = ex
8006 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8007 
    result.write(oprot)
8008 
    oprot.writeMessageEnd()
8009 
    oprot.trans.flush()
5099 varun.gupt 8010 
 
5447 anupam.sin 8011 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8012 
    args = getAllVerificationAgents_args()
8013 
    args.read(iprot)
8014 
    iprot.readMessageEnd()
8015 
    result = getAllVerificationAgents_result()
8016 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8017 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8018 
    result.write(oprot)
8019 
    oprot.writeMessageEnd()
8020 
    oprot.trans.flush()
5208 varun.gupt 8021 
 
5527 anupam.sin 8022 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8023 
    args = getAllAttributesForOrderId_args()
8024 
    args.read(iprot)
8025 
    iprot.readMessageEnd()
8026 
    result = getAllAttributesForOrderId_result()
8027 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8028 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8029 
    result.write(oprot)
8030 
    oprot.writeMessageEnd()
8031 
    oprot.trans.flush()
5447 anupam.sin 8032 
 
5676 rajveer 8033 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8034 
    args = setOrderAttributes_args()
8035 
    args.read(iprot)
8036 
    iprot.readMessageEnd()
8037 
    result = setOrderAttributes_result()
8038 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8039 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8040 
    result.write(oprot)
8041 
    oprot.writeMessageEnd()
8042 
    oprot.trans.flush()
8043 
 
5527 anupam.sin 8044 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8045 
    args = setOrderAttributeForTransaction_args()
8046 
    args.read(iprot)
8047 
    iprot.readMessageEnd()
8048 
    result = setOrderAttributeForTransaction_result()
8049 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8050 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8051 
    result.write(oprot)
8052 
    oprot.writeMessageEnd()
8053 
    oprot.trans.flush()
8054 
 
5553 rajveer 8055 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8056 
    args = getReceivePendingOrders_args()
8057 
    args.read(iprot)
8058 
    iprot.readMessageEnd()
8059 
    result = getReceivePendingOrders_result()
8060 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8061 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8062 
    result.write(oprot)
8063 
    oprot.writeMessageEnd()
8064 
    oprot.trans.flush()
5527 anupam.sin 8065 
 
5553 rajveer 8066 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8067 
    args = getReceivedAtStoreOrders_args()
8068 
    args.read(iprot)
8069 
    iprot.readMessageEnd()
8070 
    result = getReceivedAtStoreOrders_result()
8071 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8072 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8073 
    result.write(oprot)
8074 
    oprot.writeMessageEnd()
8075 
    oprot.trans.flush()
8076 
 
5713 rajveer 8077 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8078 
    args = getOrdersCollectionAtStore_args()
8079 
    args.read(iprot)
8080 
    iprot.readMessageEnd()
8081 
    result = getOrdersCollectionAtStore_result()
8082 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8083 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8084 
    result.write(oprot)
8085 
    oprot.writeMessageEnd()
8086 
    oprot.trans.flush()
8087 
 
5833 rajveer 8088 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8089 
    args = getOrderAttributeValue_args()
8090 
    args.read(iprot)
8091 
    iprot.readMessageEnd()
8092 
    result = getOrderAttributeValue_result()
8093 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8094 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
8098 
 
6019 rajveer 8099 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8100 
    args = changeJacketNumber_args()
8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
8103 
    result = changeJacketNumber_result()
8104 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8105 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8106 
    result.write(oprot)
8107 
    oprot.writeMessageEnd()
8108 
    oprot.trans.flush()
8109 
 
8110 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8111 
    args = markOrderAsRtoInTransit_args()
8112 
    args.read(iprot)
8113 
    iprot.readMessageEnd()
8114 
    result = markOrderAsRtoInTransit_result()
8115 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8116 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
8120 
 
5593 mandeep.dh 8121 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8122 
    args = acceptOrderForItem_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = acceptOrderForItem_result()
8126 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8127 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8128 
    result.write(oprot)
8129 
    oprot.writeMessageEnd()
8130 
    oprot.trans.flush()
5553 rajveer 8131 
 
6000 mandeep.dh 8132 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8133 
    args = createRechargeOrder_args()
8134 
    args.read(iprot)
8135 
    iprot.readMessageEnd()
8136 
    result = createRechargeOrder_result()
8137 
    try:
8138 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8139 
    except TransactionServiceException, ex:
8140 
      result.ex = ex
8141 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8142 
    result.write(oprot)
8143 
    oprot.writeMessageEnd()
8144 
    oprot.trans.flush()
5593 mandeep.dh 8145 
 
6031 rajveer 8146 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8147 
    args = getRechargeOrder_args()
8148 
    args.read(iprot)
8149 
    iprot.readMessageEnd()
8150 
    result = getRechargeOrder_result()
8151 
    try:
8152 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8153 
    except TransactionServiceException, ex:
8154 
      result.ex = ex
8155 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8156 
    result.write(oprot)
8157 
    oprot.writeMessageEnd()
8158 
    oprot.trans.flush()
8159 
 
8160 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8161 
    args = getRechargeOrders_args()
8162 
    args.read(iprot)
8163 
    iprot.readMessageEnd()
8164 
    result = getRechargeOrders_result()
8165 
    result.success = self._handler.getRechargeOrders(args.userId)
8166 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8167 
    result.write(oprot)
8168 
    oprot.writeMessageEnd()
8169 
    oprot.trans.flush()
8170 
 
6000 mandeep.dh 8171 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8172 
    args = updateRechargeOrderStatus_args()
8173 
    args.read(iprot)
8174 
    iprot.readMessageEnd()
8175 
    result = updateRechargeOrderStatus_result()
8176 
    try:
6031 rajveer 8177 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8178 
    except TransactionServiceException, ex:
8179 
      result.ex = ex
8180 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8181 
    result.write(oprot)
8182 
    oprot.writeMessageEnd()
8183 
    oprot.trans.flush()
8184 
 
8185 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8186 
    args = activateRechargeTxn_args()
8187 
    args.read(iprot)
8188 
    iprot.readMessageEnd()
8189 
    result = activateRechargeTxn_result()
8190 
    try:
6031 rajveer 8191 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8192 
    except TransactionServiceException, ex:
8193 
      result.ex = ex
8194 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8195 
    result.write(oprot)
8196 
    oprot.writeMessageEnd()
8197 
    oprot.trans.flush()
8198 
 
6031 rajveer 8199 
  def process_getUserWallet(self, seqid, iprot, oprot):
8200 
    args = getUserWallet_args()
6000 mandeep.dh 8201 
    args.read(iprot)
8202 
    iprot.readMessageEnd()
6031 rajveer 8203 
    result = getUserWallet_result()
8204 
    result.success = self._handler.getUserWallet(args.userId)
8205 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8206 
    result.write(oprot)
8207 
    oprot.writeMessageEnd()
8208 
    oprot.trans.flush()
8209 
 
6031 rajveer 8210 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8211 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8212 
    args.read(iprot)
8213 
    iprot.readMessageEnd()
6031 rajveer 8214 
    result = getUserWalletHistory_result()
8215 
    result.success = self._handler.getUserWalletHistory(args.userId)
8216 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8217 
    result.write(oprot)
8218 
    oprot.writeMessageEnd()
8219 
    oprot.trans.flush()
8220 
 
6050 anupam.sin 8221 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8222 
    args = getRechargeOrdersForTransaction_args()
8223 
    args.read(iprot)
8224 
    iprot.readMessageEnd()
8225 
    result = getRechargeOrdersForTransaction_result()
8226 
    try:
8227 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8228 
    except TransactionServiceException, ex:
8229 
      result.ex = ex
8230 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8231 
    result.write(oprot)
8232 
    oprot.writeMessageEnd()
8233 
    oprot.trans.flush()
8234 
 
6048 rajveer 8235 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8236 
    args = getServiceProviders_args()
8237 
    args.read(iprot)
8238 
    iprot.readMessageEnd()
8239 
    result = getServiceProviders_result()
8240 
    result.success = self._handler.getServiceProviders(args.rechargeType)
8241 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8242 
    result.write(oprot)
8243 
    oprot.writeMessageEnd()
8244 
    oprot.trans.flush()
6000 mandeep.dh 8245 
 
6048 rajveer 8246 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8247 
    args = getServiceProviderForDevice_args()
8248 
    args.read(iprot)
8249 
    iprot.readMessageEnd()
8250 
    result = getServiceProviderForDevice_result()
6049 rajveer 8251 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8252 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
8256 
 
6094 rajveer 8257 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8258 
    args = getRechargeOrdersForDevice_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = getRechargeOrdersForDevice_result()
8262 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8263 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8264 
    result.write(oprot)
8265 
    oprot.writeMessageEnd()
8266 
    oprot.trans.flush()
6048 rajveer 8267 
 
6094 rajveer 8268 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8269 
    args = addAmountToWallet_args()
8270 
    args.read(iprot)
8271 
    iprot.readMessageEnd()
8272 
    result = addAmountToWallet_result()
8273 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8274 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
8278 
 
6188 rajveer 8279 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8280 
    args = getRechargeStatistics_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = getRechargeStatistics_result()
8284 
    result.success = self._handler.getRechargeStatistics()
8285 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8286 
    result.write(oprot)
8287 
    oprot.writeMessageEnd()
8288 
    oprot.trans.flush()
8289 
 
6154 rajveer 8290 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8291 
    args = getRechargeOrdersForStatus_args()
8292 
    args.read(iprot)
8293 
    iprot.readMessageEnd()
8294 
    result = getRechargeOrdersForStatus_result()
8295 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8296 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8297 
    result.write(oprot)
8298 
    oprot.writeMessageEnd()
8299 
    oprot.trans.flush()
6094 rajveer 8300 
 
6159 rajveer 8301 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8302 
    args = getPlansForOperator_args()
8303 
    args.read(iprot)
8304 
    iprot.readMessageEnd()
8305 
    result = getPlansForOperator_result()
8306 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8307 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8308 
    result.write(oprot)
8309 
    oprot.writeMessageEnd()
8310 
    oprot.trans.flush()
6154 rajveer 8311 
 
6159 rajveer 8312 
 
94 ashish 8313 
# HELPER FUNCTIONS AND STRUCTURES
8314 
 
8315 
class createTransaction_args:
8316 
  """
8317 
  Attributes:
8318 
   - transaction
8319 
  """
8320 
 
8321 
  thrift_spec = (
8322 
    None, # 0
8323 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8324 
  )
8325 
 
8326 
  def __init__(self, transaction=None,):
8327 
    self.transaction = transaction
8328 
 
8329 
  def read(self, iprot):
8330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8332 
      return
8333 
    iprot.readStructBegin()
8334 
    while True:
8335 
      (fname, ftype, fid) = iprot.readFieldBegin()
8336 
      if ftype == TType.STOP:
8337 
        break
8338 
      if fid == 1:
8339 
        if ftype == TType.STRUCT:
8340 
          self.transaction = Transaction()
8341 
          self.transaction.read(iprot)
8342 
        else:
8343 
          iprot.skip(ftype)
8344 
      else:
8345 
        iprot.skip(ftype)
8346 
      iprot.readFieldEnd()
8347 
    iprot.readStructEnd()
8348 
 
8349 
  def write(self, oprot):
8350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8352 
      return
8353 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8354 
    if self.transaction is not None:
94 ashish 8355 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8356 
      self.transaction.write(oprot)
8357 
      oprot.writeFieldEnd()
8358 
    oprot.writeFieldStop()
8359 
    oprot.writeStructEnd()
8360 
 
3431 rajveer 8361 
  def validate(self):
8362 
    return
8363 
 
8364 
 
94 ashish 8365 
  def __repr__(self):
8366 
    L = ['%s=%r' % (key, value)
8367 
      for key, value in self.__dict__.iteritems()]
8368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8369 
 
8370 
  def __eq__(self, other):
8371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8372 
 
8373 
  def __ne__(self, other):
8374 
    return not (self == other)
8375 
 
8376 
class createTransaction_result:
8377 
  """
8378 
  Attributes:
132 ashish 8379 
   - success
94 ashish 8380 
   - ex
8381 
  """
8382 
 
8383 
  thrift_spec = (
132 ashish 8384 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8386 
  )
8387 
 
132 ashish 8388 
  def __init__(self, success=None, ex=None,):
8389 
    self.success = success
94 ashish 8390 
    self.ex = ex
8391 
 
8392 
  def read(self, iprot):
8393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8395 
      return
8396 
    iprot.readStructBegin()
8397 
    while True:
8398 
      (fname, ftype, fid) = iprot.readFieldBegin()
8399 
      if ftype == TType.STOP:
8400 
        break
132 ashish 8401 
      if fid == 0:
8402 
        if ftype == TType.I64:
8403 
          self.success = iprot.readI64();
8404 
        else:
8405 
          iprot.skip(ftype)
8406 
      elif fid == 1:
94 ashish 8407 
        if ftype == TType.STRUCT:
8408 
          self.ex = TransactionServiceException()
8409 
          self.ex.read(iprot)
8410 
        else:
8411 
          iprot.skip(ftype)
8412 
      else:
8413 
        iprot.skip(ftype)
8414 
      iprot.readFieldEnd()
8415 
    iprot.readStructEnd()
8416 
 
8417 
  def write(self, oprot):
8418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8420 
      return
8421 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8422 
    if self.success is not None:
132 ashish 8423 
      oprot.writeFieldBegin('success', TType.I64, 0)
8424 
      oprot.writeI64(self.success)
8425 
      oprot.writeFieldEnd()
3431 rajveer 8426 
    if self.ex is not None:
94 ashish 8427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8428 
      self.ex.write(oprot)
8429 
      oprot.writeFieldEnd()
8430 
    oprot.writeFieldStop()
8431 
    oprot.writeStructEnd()
8432 
 
3431 rajveer 8433 
  def validate(self):
8434 
    return
8435 
 
8436 
 
94 ashish 8437 
  def __repr__(self):
8438 
    L = ['%s=%r' % (key, value)
8439 
      for key, value in self.__dict__.iteritems()]
8440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8441 
 
8442 
  def __eq__(self, other):
8443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8444 
 
8445 
  def __ne__(self, other):
8446 
    return not (self == other)
8447 
 
8448 
class getTransaction_args:
8449 
  """
8450 
  Attributes:
8451 
   - id
8452 
  """
8453 
 
8454 
  thrift_spec = (
8455 
    None, # 0
8456 
    (1, TType.I64, 'id', None, None, ), # 1
8457 
  )
8458 
 
8459 
  def __init__(self, id=None,):
8460 
    self.id = id
8461 
 
8462 
  def read(self, iprot):
8463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8465 
      return
8466 
    iprot.readStructBegin()
8467 
    while True:
8468 
      (fname, ftype, fid) = iprot.readFieldBegin()
8469 
      if ftype == TType.STOP:
8470 
        break
8471 
      if fid == 1:
8472 
        if ftype == TType.I64:
8473 
          self.id = iprot.readI64();
8474 
        else:
8475 
          iprot.skip(ftype)
8476 
      else:
8477 
        iprot.skip(ftype)
8478 
      iprot.readFieldEnd()
8479 
    iprot.readStructEnd()
8480 
 
8481 
  def write(self, oprot):
8482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8484 
      return
8485 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8486 
    if self.id is not None:
94 ashish 8487 
      oprot.writeFieldBegin('id', TType.I64, 1)
8488 
      oprot.writeI64(self.id)
8489 
      oprot.writeFieldEnd()
8490 
    oprot.writeFieldStop()
8491 
    oprot.writeStructEnd()
8492 
 
3431 rajveer 8493 
  def validate(self):
8494 
    return
8495 
 
8496 
 
94 ashish 8497 
  def __repr__(self):
8498 
    L = ['%s=%r' % (key, value)
8499 
      for key, value in self.__dict__.iteritems()]
8500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8501 
 
8502 
  def __eq__(self, other):
8503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8504 
 
8505 
  def __ne__(self, other):
8506 
    return not (self == other)
8507 
 
8508 
class getTransaction_result:
8509 
  """
8510 
  Attributes:
8511 
   - success
8512 
   - ex
8513 
  """
8514 
 
8515 
  thrift_spec = (
8516 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8518 
  )
8519 
 
8520 
  def __init__(self, success=None, ex=None,):
8521 
    self.success = success
8522 
    self.ex = ex
8523 
 
8524 
  def read(self, iprot):
8525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8527 
      return
8528 
    iprot.readStructBegin()
8529 
    while True:
8530 
      (fname, ftype, fid) = iprot.readFieldBegin()
8531 
      if ftype == TType.STOP:
8532 
        break
8533 
      if fid == 0:
8534 
        if ftype == TType.STRUCT:
8535 
          self.success = Transaction()
8536 
          self.success.read(iprot)
8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      elif fid == 1:
8540 
        if ftype == TType.STRUCT:
8541 
          self.ex = TransactionServiceException()
8542 
          self.ex.read(iprot)
8543 
        else:
8544 
          iprot.skip(ftype)
8545 
      else:
8546 
        iprot.skip(ftype)
8547 
      iprot.readFieldEnd()
8548 
    iprot.readStructEnd()
8549 
 
8550 
  def write(self, oprot):
8551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8553 
      return
8554 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8555 
    if self.success is not None:
94 ashish 8556 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8557 
      self.success.write(oprot)
8558 
      oprot.writeFieldEnd()
3431 rajveer 8559 
    if self.ex is not None:
94 ashish 8560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8561 
      self.ex.write(oprot)
8562 
      oprot.writeFieldEnd()
8563 
    oprot.writeFieldStop()
8564 
    oprot.writeStructEnd()
8565 
 
3431 rajveer 8566 
  def validate(self):
8567 
    return
8568 
 
8569 
 
94 ashish 8570 
  def __repr__(self):
8571 
    L = ['%s=%r' % (key, value)
8572 
      for key, value in self.__dict__.iteritems()]
8573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8574 
 
8575 
  def __eq__(self, other):
8576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8577 
 
8578 
  def __ne__(self, other):
8579 
    return not (self == other)
8580 
 
8581 
class getTransactionsForCustomer_args:
8582 
  """
8583 
  Attributes:
8584 
   - customerId
8585 
   - from_date
8586 
   - to_date
8587 
   - status
8588 
  """
8589 
 
8590 
  thrift_spec = (
8591 
    None, # 0
8592 
    (1, TType.I64, 'customerId', None, None, ), # 1
8593 
    (2, TType.I64, 'from_date', None, None, ), # 2
8594 
    (3, TType.I64, 'to_date', None, None, ), # 3
8595 
    (4, TType.I32, 'status', None, None, ), # 4
8596 
  )
8597 
 
8598 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8599 
    self.customerId = customerId
8600 
    self.from_date = from_date
8601 
    self.to_date = to_date
8602 
    self.status = status
8603 
 
8604 
  def read(self, iprot):
8605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8607 
      return
8608 
    iprot.readStructBegin()
8609 
    while True:
8610 
      (fname, ftype, fid) = iprot.readFieldBegin()
8611 
      if ftype == TType.STOP:
8612 
        break
8613 
      if fid == 1:
8614 
        if ftype == TType.I64:
8615 
          self.customerId = iprot.readI64();
8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      elif fid == 2:
8619 
        if ftype == TType.I64:
8620 
          self.from_date = iprot.readI64();
8621 
        else:
8622 
          iprot.skip(ftype)
8623 
      elif fid == 3:
8624 
        if ftype == TType.I64:
8625 
          self.to_date = iprot.readI64();
8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      elif fid == 4:
8629 
        if ftype == TType.I32:
8630 
          self.status = iprot.readI32();
8631 
        else:
8632 
          iprot.skip(ftype)
8633 
      else:
8634 
        iprot.skip(ftype)
8635 
      iprot.readFieldEnd()
8636 
    iprot.readStructEnd()
8637 
 
8638 
  def write(self, oprot):
8639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8641 
      return
8642 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8643 
    if self.customerId is not None:
94 ashish 8644 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8645 
      oprot.writeI64(self.customerId)
8646 
      oprot.writeFieldEnd()
3431 rajveer 8647 
    if self.from_date is not None:
94 ashish 8648 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8649 
      oprot.writeI64(self.from_date)
8650 
      oprot.writeFieldEnd()
3431 rajveer 8651 
    if self.to_date is not None:
94 ashish 8652 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8653 
      oprot.writeI64(self.to_date)
8654 
      oprot.writeFieldEnd()
3431 rajveer 8655 
    if self.status is not None:
94 ashish 8656 
      oprot.writeFieldBegin('status', TType.I32, 4)
8657 
      oprot.writeI32(self.status)
8658 
      oprot.writeFieldEnd()
8659 
    oprot.writeFieldStop()
8660 
    oprot.writeStructEnd()
8661 
 
3431 rajveer 8662 
  def validate(self):
8663 
    return
8664 
 
8665 
 
94 ashish 8666 
  def __repr__(self):
8667 
    L = ['%s=%r' % (key, value)
8668 
      for key, value in self.__dict__.iteritems()]
8669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8670 
 
8671 
  def __eq__(self, other):
8672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8673 
 
8674 
  def __ne__(self, other):
8675 
    return not (self == other)
8676 
 
8677 
class getTransactionsForCustomer_result:
8678 
  """
8679 
  Attributes:
8680 
   - success
8681 
   - ex
8682 
  """
8683 
 
8684 
  thrift_spec = (
8685 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8687 
  )
8688 
 
8689 
  def __init__(self, success=None, ex=None,):
8690 
    self.success = success
8691 
    self.ex = ex
8692 
 
8693 
  def read(self, iprot):
8694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8696 
      return
8697 
    iprot.readStructBegin()
8698 
    while True:
8699 
      (fname, ftype, fid) = iprot.readFieldBegin()
8700 
      if ftype == TType.STOP:
8701 
        break
8702 
      if fid == 0:
8703 
        if ftype == TType.LIST:
8704 
          self.success = []
6188 rajveer 8705 
          (_etype109, _size106) = iprot.readListBegin()
8706 
          for _i110 in xrange(_size106):
8707 
            _elem111 = Transaction()
8708 
            _elem111.read(iprot)
8709 
            self.success.append(_elem111)
94 ashish 8710 
          iprot.readListEnd()
8711 
        else:
8712 
          iprot.skip(ftype)
8713 
      elif fid == 1:
8714 
        if ftype == TType.STRUCT:
8715 
          self.ex = TransactionServiceException()
8716 
          self.ex.read(iprot)
8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      else:
8720 
        iprot.skip(ftype)
8721 
      iprot.readFieldEnd()
8722 
    iprot.readStructEnd()
8723 
 
8724 
  def write(self, oprot):
8725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8727 
      return
8728 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8729 
    if self.success is not None:
94 ashish 8730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8732 
      for iter112 in self.success:
8733 
        iter112.write(oprot)
94 ashish 8734 
      oprot.writeListEnd()
8735 
      oprot.writeFieldEnd()
3431 rajveer 8736 
    if self.ex is not None:
94 ashish 8737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8738 
      self.ex.write(oprot)
8739 
      oprot.writeFieldEnd()
8740 
    oprot.writeFieldStop()
8741 
    oprot.writeStructEnd()
8742 
 
3431 rajveer 8743 
  def validate(self):
8744 
    return
8745 
 
8746 
 
94 ashish 8747 
  def __repr__(self):
8748 
    L = ['%s=%r' % (key, value)
8749 
      for key, value in self.__dict__.iteritems()]
8750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8751 
 
8752 
  def __eq__(self, other):
8753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8754 
 
8755 
  def __ne__(self, other):
8756 
    return not (self == other)
8757 
 
132 ashish 8758 
class getTransactionsForShoppingCartId_args:
8759 
  """
8760 
  Attributes:
8761 
   - shoppingCartId
8762 
  """
8763 
 
8764 
  thrift_spec = (
8765 
    None, # 0
8766 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8767 
  )
8768 
 
8769 
  def __init__(self, shoppingCartId=None,):
8770 
    self.shoppingCartId = shoppingCartId
8771 
 
8772 
  def read(self, iprot):
8773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8775 
      return
8776 
    iprot.readStructBegin()
8777 
    while True:
8778 
      (fname, ftype, fid) = iprot.readFieldBegin()
8779 
      if ftype == TType.STOP:
8780 
        break
8781 
      if fid == 1:
8782 
        if ftype == TType.I64:
8783 
          self.shoppingCartId = iprot.readI64();
8784 
        else:
8785 
          iprot.skip(ftype)
8786 
      else:
8787 
        iprot.skip(ftype)
8788 
      iprot.readFieldEnd()
8789 
    iprot.readStructEnd()
8790 
 
8791 
  def write(self, oprot):
8792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8794 
      return
8795 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8796 
    if self.shoppingCartId is not None:
132 ashish 8797 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8798 
      oprot.writeI64(self.shoppingCartId)
8799 
      oprot.writeFieldEnd()
8800 
    oprot.writeFieldStop()
8801 
    oprot.writeStructEnd()
8802 
 
3431 rajveer 8803 
  def validate(self):
8804 
    return
8805 
 
8806 
 
132 ashish 8807 
  def __repr__(self):
8808 
    L = ['%s=%r' % (key, value)
8809 
      for key, value in self.__dict__.iteritems()]
8810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8811 
 
8812 
  def __eq__(self, other):
8813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8814 
 
8815 
  def __ne__(self, other):
8816 
    return not (self == other)
8817 
 
8818 
class getTransactionsForShoppingCartId_result:
8819 
  """
8820 
  Attributes:
8821 
   - success
8822 
   - ex
8823 
  """
8824 
 
8825 
  thrift_spec = (
8826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8828 
  )
8829 
 
8830 
  def __init__(self, success=None, ex=None,):
8831 
    self.success = success
8832 
    self.ex = ex
8833 
 
8834 
  def read(self, iprot):
8835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8837 
      return
8838 
    iprot.readStructBegin()
8839 
    while True:
8840 
      (fname, ftype, fid) = iprot.readFieldBegin()
8841 
      if ftype == TType.STOP:
8842 
        break
8843 
      if fid == 0:
8844 
        if ftype == TType.LIST:
8845 
          self.success = []
6188 rajveer 8846 
          (_etype116, _size113) = iprot.readListBegin()
8847 
          for _i117 in xrange(_size113):
8848 
            _elem118 = Transaction()
8849 
            _elem118.read(iprot)
8850 
            self.success.append(_elem118)
132 ashish 8851 
          iprot.readListEnd()
8852 
        else:
8853 
          iprot.skip(ftype)
8854 
      elif fid == 1:
8855 
        if ftype == TType.STRUCT:
8856 
          self.ex = TransactionServiceException()
8857 
          self.ex.read(iprot)
8858 
        else:
8859 
          iprot.skip(ftype)
8860 
      else:
8861 
        iprot.skip(ftype)
8862 
      iprot.readFieldEnd()
8863 
    iprot.readStructEnd()
8864 
 
8865 
  def write(self, oprot):
8866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8868 
      return
8869 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8870 
    if self.success is not None:
132 ashish 8871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8873 
      for iter119 in self.success:
8874 
        iter119.write(oprot)
132 ashish 8875 
      oprot.writeListEnd()
8876 
      oprot.writeFieldEnd()
3431 rajveer 8877 
    if self.ex is not None:
132 ashish 8878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8879 
      self.ex.write(oprot)
8880 
      oprot.writeFieldEnd()
8881 
    oprot.writeFieldStop()
8882 
    oprot.writeStructEnd()
8883 
 
3431 rajveer 8884 
  def validate(self):
8885 
    return
8886 
 
8887 
 
132 ashish 8888 
  def __repr__(self):
8889 
    L = ['%s=%r' % (key, value)
8890 
      for key, value in self.__dict__.iteritems()]
8891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8892 
 
8893 
  def __eq__(self, other):
8894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8895 
 
8896 
  def __ne__(self, other):
8897 
    return not (self == other)
8898 
 
94 ashish 8899 
class getTransactionStatus_args:
8900 
  """
8901 
  Attributes:
8902 
   - transactionId
8903 
  """
8904 
 
8905 
  thrift_spec = (
8906 
    None, # 0
8907 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8908 
  )
8909 
 
8910 
  def __init__(self, transactionId=None,):
8911 
    self.transactionId = transactionId
8912 
 
8913 
  def read(self, iprot):
8914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8916 
      return
8917 
    iprot.readStructBegin()
8918 
    while True:
8919 
      (fname, ftype, fid) = iprot.readFieldBegin()
8920 
      if ftype == TType.STOP:
8921 
        break
8922 
      if fid == 1:
8923 
        if ftype == TType.I64:
8924 
          self.transactionId = iprot.readI64();
8925 
        else:
8926 
          iprot.skip(ftype)
8927 
      else:
8928 
        iprot.skip(ftype)
8929 
      iprot.readFieldEnd()
8930 
    iprot.readStructEnd()
8931 
 
8932 
  def write(self, oprot):
8933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8935 
      return
8936 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8937 
    if self.transactionId is not None:
94 ashish 8938 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8939 
      oprot.writeI64(self.transactionId)
8940 
      oprot.writeFieldEnd()
8941 
    oprot.writeFieldStop()
8942 
    oprot.writeStructEnd()
8943 
 
3431 rajveer 8944 
  def validate(self):
8945 
    return
8946 
 
8947 
 
94 ashish 8948 
  def __repr__(self):
8949 
    L = ['%s=%r' % (key, value)
8950 
      for key, value in self.__dict__.iteritems()]
8951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8952 
 
8953 
  def __eq__(self, other):
8954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8955 
 
8956 
  def __ne__(self, other):
8957 
    return not (self == other)
8958 
 
8959 
class getTransactionStatus_result:
8960 
  """
8961 
  Attributes:
8962 
   - success
8963 
   - ex
8964 
  """
8965 
 
8966 
  thrift_spec = (
8967 
    (0, TType.I32, 'success', None, None, ), # 0
8968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8969 
  )
8970 
 
8971 
  def __init__(self, success=None, ex=None,):
8972 
    self.success = success
8973 
    self.ex = ex
8974 
 
8975 
  def read(self, iprot):
8976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8978 
      return
8979 
    iprot.readStructBegin()
8980 
    while True:
8981 
      (fname, ftype, fid) = iprot.readFieldBegin()
8982 
      if ftype == TType.STOP:
8983 
        break
8984 
      if fid == 0:
8985 
        if ftype == TType.I32:
8986 
          self.success = iprot.readI32();
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      elif fid == 1:
8990 
        if ftype == TType.STRUCT:
8991 
          self.ex = TransactionServiceException()
8992 
          self.ex.read(iprot)
8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      else:
8996 
        iprot.skip(ftype)
8997 
      iprot.readFieldEnd()
8998 
    iprot.readStructEnd()
8999 
 
9000 
  def write(self, oprot):
9001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9003 
      return
9004 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9005 
    if self.success is not None:
94 ashish 9006 
      oprot.writeFieldBegin('success', TType.I32, 0)
9007 
      oprot.writeI32(self.success)
9008 
      oprot.writeFieldEnd()
3431 rajveer 9009 
    if self.ex is not None:
94 ashish 9010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9011 
      self.ex.write(oprot)
9012 
      oprot.writeFieldEnd()
9013 
    oprot.writeFieldStop()
9014 
    oprot.writeStructEnd()
9015 
 
3431 rajveer 9016 
  def validate(self):
9017 
    return
9018 
 
9019 
 
94 ashish 9020 
  def __repr__(self):
9021 
    L = ['%s=%r' % (key, value)
9022 
      for key, value in self.__dict__.iteritems()]
9023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9024 
 
9025 
  def __eq__(self, other):
9026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9027 
 
9028 
  def __ne__(self, other):
9029 
    return not (self == other)
9030 
 
9031 
class changeTransactionStatus_args:
9032 
  """
9033 
  Attributes:
9034 
   - transactionId
9035 
   - status
9036 
   - description
5527 anupam.sin 9037 
   - pickUp
9038 
   - orderType
94 ashish 9039 
  """
9040 
 
9041 
  thrift_spec = (
9042 
    None, # 0
9043 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9044 
    (2, TType.I32, 'status', None, None, ), # 2
9045 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9046 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9047 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9048 
  )
9049 
 
5527 anupam.sin 9050 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9051 
    self.transactionId = transactionId
9052 
    self.status = status
9053 
    self.description = description
5527 anupam.sin 9054 
    self.pickUp = pickUp
9055 
    self.orderType = orderType
94 ashish 9056 
 
9057 
  def read(self, iprot):
9058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9060 
      return
9061 
    iprot.readStructBegin()
9062 
    while True:
9063 
      (fname, ftype, fid) = iprot.readFieldBegin()
9064 
      if ftype == TType.STOP:
9065 
        break
9066 
      if fid == 1:
9067 
        if ftype == TType.I64:
9068 
          self.transactionId = iprot.readI64();
9069 
        else:
9070 
          iprot.skip(ftype)
9071 
      elif fid == 2:
9072 
        if ftype == TType.I32:
9073 
          self.status = iprot.readI32();
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      elif fid == 3:
9077 
        if ftype == TType.STRING:
9078 
          self.description = iprot.readString();
9079 
        else:
9080 
          iprot.skip(ftype)
5387 rajveer 9081 
      elif fid == 4:
5527 anupam.sin 9082 
        if ftype == TType.I64:
9083 
          self.pickUp = iprot.readI64();
5387 rajveer 9084 
        else:
9085 
          iprot.skip(ftype)
5527 anupam.sin 9086 
      elif fid == 5:
9087 
        if ftype == TType.I32:
9088 
          self.orderType = iprot.readI32();
9089 
        else:
9090 
          iprot.skip(ftype)
94 ashish 9091 
      else:
9092 
        iprot.skip(ftype)
9093 
      iprot.readFieldEnd()
9094 
    iprot.readStructEnd()
9095 
 
9096 
  def write(self, oprot):
9097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9099 
      return
9100 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9101 
    if self.transactionId is not None:
94 ashish 9102 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9103 
      oprot.writeI64(self.transactionId)
9104 
      oprot.writeFieldEnd()
3431 rajveer 9105 
    if self.status is not None:
94 ashish 9106 
      oprot.writeFieldBegin('status', TType.I32, 2)
9107 
      oprot.writeI32(self.status)
9108 
      oprot.writeFieldEnd()
3431 rajveer 9109 
    if self.description is not None:
94 ashish 9110 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9111 
      oprot.writeString(self.description)
9112 
      oprot.writeFieldEnd()
5527 anupam.sin 9113 
    if self.pickUp is not None:
9114 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9115 
      oprot.writeI64(self.pickUp)
5387 rajveer 9116 
      oprot.writeFieldEnd()
5527 anupam.sin 9117 
    if self.orderType is not None:
9118 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9119 
      oprot.writeI32(self.orderType)
9120 
      oprot.writeFieldEnd()
94 ashish 9121 
    oprot.writeFieldStop()
9122 
    oprot.writeStructEnd()
9123 
 
3431 rajveer 9124 
  def validate(self):
9125 
    return
9126 
 
9127 
 
94 ashish 9128 
  def __repr__(self):
9129 
    L = ['%s=%r' % (key, value)
9130 
      for key, value in self.__dict__.iteritems()]
9131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9132 
 
9133 
  def __eq__(self, other):
9134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9135 
 
9136 
  def __ne__(self, other):
9137 
    return not (self == other)
9138 
 
9139 
class changeTransactionStatus_result:
9140 
  """
9141 
  Attributes:
9142 
   - success
9143 
   - ex
9144 
  """
9145 
 
9146 
  thrift_spec = (
9147 
    (0, TType.BOOL, 'success', None, None, ), # 0
9148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9149 
  )
9150 
 
9151 
  def __init__(self, success=None, ex=None,):
9152 
    self.success = success
9153 
    self.ex = ex
9154 
 
9155 
  def read(self, iprot):
9156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9158 
      return
9159 
    iprot.readStructBegin()
9160 
    while True:
9161 
      (fname, ftype, fid) = iprot.readFieldBegin()
9162 
      if ftype == TType.STOP:
9163 
        break
9164 
      if fid == 0:
9165 
        if ftype == TType.BOOL:
9166 
          self.success = iprot.readBool();
9167 
        else:
9168 
          iprot.skip(ftype)
9169 
      elif fid == 1:
9170 
        if ftype == TType.STRUCT:
9171 
          self.ex = TransactionServiceException()
9172 
          self.ex.read(iprot)
9173 
        else:
9174 
          iprot.skip(ftype)
9175 
      else:
9176 
        iprot.skip(ftype)
9177 
      iprot.readFieldEnd()
9178 
    iprot.readStructEnd()
9179 
 
9180 
  def write(self, oprot):
9181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9183 
      return
9184 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9185 
    if self.success is not None:
94 ashish 9186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9187 
      oprot.writeBool(self.success)
9188 
      oprot.writeFieldEnd()
3431 rajveer 9189 
    if self.ex is not None:
94 ashish 9190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9191 
      self.ex.write(oprot)
9192 
      oprot.writeFieldEnd()
9193 
    oprot.writeFieldStop()
9194 
    oprot.writeStructEnd()
9195 
 
3431 rajveer 9196 
  def validate(self):
9197 
    return
9198 
 
9199 
 
94 ashish 9200 
  def __repr__(self):
9201 
    L = ['%s=%r' % (key, value)
9202 
      for key, value in self.__dict__.iteritems()]
9203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9204 
 
9205 
  def __eq__(self, other):
9206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9207 
 
9208 
  def __ne__(self, other):
9209 
    return not (self == other)
9210 
 
1398 varun.gupt 9211 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9212 
  """
9213 
  Attributes:
9214 
   - transactionId
9215 
  """
9216 
 
9217 
  thrift_spec = (
9218 
    None, # 0
9219 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9220 
  )
9221 
 
9222 
  def __init__(self, transactionId=None,):
9223 
    self.transactionId = transactionId
9224 
 
9225 
  def read(self, iprot):
9226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9228 
      return
9229 
    iprot.readStructBegin()
9230 
    while True:
9231 
      (fname, ftype, fid) = iprot.readFieldBegin()
9232 
      if ftype == TType.STOP:
9233 
        break
9234 
      if fid == 1:
9235 
        if ftype == TType.I64:
9236 
          self.transactionId = iprot.readI64();
9237 
        else:
9238 
          iprot.skip(ftype)
9239 
      else:
9240 
        iprot.skip(ftype)
9241 
      iprot.readFieldEnd()
9242 
    iprot.readStructEnd()
9243 
 
9244 
  def write(self, oprot):
9245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9247 
      return
1398 varun.gupt 9248 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9249 
    if self.transactionId is not None:
1382 varun.gupt 9250 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9251 
      oprot.writeI64(self.transactionId)
9252 
      oprot.writeFieldEnd()
9253 
    oprot.writeFieldStop()
9254 
    oprot.writeStructEnd()
9255 
 
3431 rajveer 9256 
  def validate(self):
9257 
    return
9258 
 
9259 
 
1382 varun.gupt 9260 
  def __repr__(self):
9261 
    L = ['%s=%r' % (key, value)
9262 
      for key, value in self.__dict__.iteritems()]
9263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9264 
 
9265 
  def __eq__(self, other):
9266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9267 
 
9268 
  def __ne__(self, other):
9269 
    return not (self == other)
9270 
 
1398 varun.gupt 9271 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9272 
  """
9273 
  Attributes:
9274 
   - success
9275 
   - ex
9276 
  """
9277 
 
9278 
  thrift_spec = (
9279 
    (0, TType.BOOL, 'success', None, None, ), # 0
9280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9281 
  )
9282 
 
9283 
  def __init__(self, success=None, ex=None,):
9284 
    self.success = success
9285 
    self.ex = ex
9286 
 
9287 
  def read(self, iprot):
9288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9290 
      return
9291 
    iprot.readStructBegin()
9292 
    while True:
9293 
      (fname, ftype, fid) = iprot.readFieldBegin()
9294 
      if ftype == TType.STOP:
9295 
        break
9296 
      if fid == 0:
9297 
        if ftype == TType.BOOL:
9298 
          self.success = iprot.readBool();
9299 
        else:
9300 
          iprot.skip(ftype)
9301 
      elif fid == 1:
9302 
        if ftype == TType.STRUCT:
9303 
          self.ex = TransactionServiceException()
9304 
          self.ex.read(iprot)
9305 
        else:
9306 
          iprot.skip(ftype)
9307 
      else:
9308 
        iprot.skip(ftype)
9309 
      iprot.readFieldEnd()
9310 
    iprot.readStructEnd()
9311 
 
9312 
  def write(self, oprot):
9313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9315 
      return
1398 varun.gupt 9316 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9317 
    if self.success is not None:
1382 varun.gupt 9318 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9319 
      oprot.writeBool(self.success)
9320 
      oprot.writeFieldEnd()
3431 rajveer 9321 
    if self.ex is not None:
1382 varun.gupt 9322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9323 
      self.ex.write(oprot)
9324 
      oprot.writeFieldEnd()
9325 
    oprot.writeFieldStop()
9326 
    oprot.writeStructEnd()
9327 
 
3431 rajveer 9328 
  def validate(self):
9329 
    return
9330 
 
9331 
 
1382 varun.gupt 9332 
  def __repr__(self):
9333 
    L = ['%s=%r' % (key, value)
9334 
      for key, value in self.__dict__.iteritems()]
9335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9336 
 
9337 
  def __eq__(self, other):
9338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9339 
 
9340 
  def __ne__(self, other):
9341 
    return not (self == other)
9342 
 
483 rajveer 9343 
class getAllOrders_args:
94 ashish 9344 
  """
9345 
  Attributes:
4801 anupam.sin 9346 
   - statuses
483 rajveer 9347 
   - from_date
9348 
   - to_date
9349 
   - warehouse_id
94 ashish 9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    None, # 0
4801 anupam.sin 9354 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9355 
    (2, TType.I64, 'from_date', None, None, ), # 2
9356 
    (3, TType.I64, 'to_date', None, None, ), # 3
9357 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9358 
  )
9359 
 
4801 anupam.sin 9360 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9361 
    self.statuses = statuses
483 rajveer 9362 
    self.from_date = from_date
9363 
    self.to_date = to_date
9364 
    self.warehouse_id = warehouse_id
94 ashish 9365 
 
9366 
  def read(self, iprot):
9367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9369 
      return
9370 
    iprot.readStructBegin()
9371 
    while True:
9372 
      (fname, ftype, fid) = iprot.readFieldBegin()
9373 
      if ftype == TType.STOP:
9374 
        break
9375 
      if fid == 1:
4801 anupam.sin 9376 
        if ftype == TType.LIST:
9377 
          self.statuses = []
6188 rajveer 9378 
          (_etype123, _size120) = iprot.readListBegin()
9379 
          for _i124 in xrange(_size120):
9380 
            _elem125 = iprot.readI32();
9381 
            self.statuses.append(_elem125)
4801 anupam.sin 9382 
          iprot.readListEnd()
94 ashish 9383 
        else:
9384 
          iprot.skip(ftype)
483 rajveer 9385 
      elif fid == 2:
9386 
        if ftype == TType.I64:
9387 
          self.from_date = iprot.readI64();
94 ashish 9388 
        else:
9389 
          iprot.skip(ftype)
483 rajveer 9390 
      elif fid == 3:
9391 
        if ftype == TType.I64:
9392 
          self.to_date = iprot.readI64();
94 ashish 9393 
        else:
9394 
          iprot.skip(ftype)
483 rajveer 9395 
      elif fid == 4:
94 ashish 9396 
        if ftype == TType.I64:
483 rajveer 9397 
          self.warehouse_id = iprot.readI64();
94 ashish 9398 
        else:
9399 
          iprot.skip(ftype)
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
483 rajveer 9409 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9410 
    if self.statuses is not None:
9411 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9412 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9413 
      for iter126 in self.statuses:
9414 
        oprot.writeI32(iter126)
4801 anupam.sin 9415 
      oprot.writeListEnd()
94 ashish 9416 
      oprot.writeFieldEnd()
3431 rajveer 9417 
    if self.from_date is not None:
483 rajveer 9418 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9419 
      oprot.writeI64(self.from_date)
94 ashish 9420 
      oprot.writeFieldEnd()
3431 rajveer 9421 
    if self.to_date is not None:
483 rajveer 9422 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9423 
      oprot.writeI64(self.to_date)
94 ashish 9424 
      oprot.writeFieldEnd()
3431 rajveer 9425 
    if self.warehouse_id is not None:
483 rajveer 9426 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9427 
      oprot.writeI64(self.warehouse_id)
94 ashish 9428 
      oprot.writeFieldEnd()
9429 
    oprot.writeFieldStop()
9430 
    oprot.writeStructEnd()
9431 
 
3431 rajveer 9432 
  def validate(self):
9433 
    return
9434 
 
9435 
 
94 ashish 9436 
  def __repr__(self):
9437 
    L = ['%s=%r' % (key, value)
9438 
      for key, value in self.__dict__.iteritems()]
9439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9440 
 
9441 
  def __eq__(self, other):
9442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9443 
 
9444 
  def __ne__(self, other):
9445 
    return not (self == other)
9446 
 
483 rajveer 9447 
class getAllOrders_result:
94 ashish 9448 
  """
9449 
  Attributes:
9450 
   - success
9451 
   - ex
9452 
  """
9453 
 
9454 
  thrift_spec = (
483 rajveer 9455 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9457 
  )
9458 
 
9459 
  def __init__(self, success=None, ex=None,):
9460 
    self.success = success
9461 
    self.ex = ex
9462 
 
9463 
  def read(self, iprot):
9464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9466 
      return
9467 
    iprot.readStructBegin()
9468 
    while True:
9469 
      (fname, ftype, fid) = iprot.readFieldBegin()
9470 
      if ftype == TType.STOP:
9471 
        break
9472 
      if fid == 0:
483 rajveer 9473 
        if ftype == TType.LIST:
9474 
          self.success = []
6188 rajveer 9475 
          (_etype130, _size127) = iprot.readListBegin()
9476 
          for _i131 in xrange(_size127):
9477 
            _elem132 = Order()
9478 
            _elem132.read(iprot)
9479 
            self.success.append(_elem132)
483 rajveer 9480 
          iprot.readListEnd()
94 ashish 9481 
        else:
9482 
          iprot.skip(ftype)
9483 
      elif fid == 1:
9484 
        if ftype == TType.STRUCT:
9485 
          self.ex = TransactionServiceException()
9486 
          self.ex.read(iprot)
9487 
        else:
9488 
          iprot.skip(ftype)
9489 
      else:
9490 
        iprot.skip(ftype)
9491 
      iprot.readFieldEnd()
9492 
    iprot.readStructEnd()
9493 
 
9494 
  def write(self, oprot):
9495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9497 
      return
483 rajveer 9498 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9499 
    if self.success is not None:
483 rajveer 9500 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9501 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9502 
      for iter133 in self.success:
9503 
        iter133.write(oprot)
483 rajveer 9504 
      oprot.writeListEnd()
94 ashish 9505 
      oprot.writeFieldEnd()
3431 rajveer 9506 
    if self.ex is not None:
94 ashish 9507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9508 
      self.ex.write(oprot)
9509 
      oprot.writeFieldEnd()
9510 
    oprot.writeFieldStop()
9511 
    oprot.writeStructEnd()
9512 
 
3431 rajveer 9513 
  def validate(self):
9514 
    return
9515 
 
9516 
 
94 ashish 9517 
  def __repr__(self):
9518 
    L = ['%s=%r' % (key, value)
9519 
      for key, value in self.__dict__.iteritems()]
9520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9521 
 
9522 
  def __eq__(self, other):
9523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9524 
 
9525 
  def __ne__(self, other):
9526 
    return not (self == other)
9527 
 
4133 chandransh 9528 
class getOrdersInBatch_args:
9529 
  """
9530 
  Attributes:
9531 
   - statuses
9532 
   - offset
9533 
   - limit
9534 
   - warehouse_id
9535 
  """
9536 
 
9537 
  thrift_spec = (
9538 
    None, # 0
9539 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9540 
    (2, TType.I64, 'offset', None, None, ), # 2
9541 
    (3, TType.I64, 'limit', None, None, ), # 3
9542 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9543 
  )
9544 
 
9545 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9546 
    self.statuses = statuses
9547 
    self.offset = offset
9548 
    self.limit = limit
9549 
    self.warehouse_id = warehouse_id
9550 
 
9551 
  def read(self, iprot):
9552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9554 
      return
9555 
    iprot.readStructBegin()
9556 
    while True:
9557 
      (fname, ftype, fid) = iprot.readFieldBegin()
9558 
      if ftype == TType.STOP:
9559 
        break
9560 
      if fid == 1:
9561 
        if ftype == TType.LIST:
9562 
          self.statuses = []
6188 rajveer 9563 
          (_etype137, _size134) = iprot.readListBegin()
9564 
          for _i138 in xrange(_size134):
9565 
            _elem139 = iprot.readI32();
9566 
            self.statuses.append(_elem139)
4133 chandransh 9567 
          iprot.readListEnd()
9568 
        else:
9569 
          iprot.skip(ftype)
9570 
      elif fid == 2:
9571 
        if ftype == TType.I64:
9572 
          self.offset = iprot.readI64();
9573 
        else:
9574 
          iprot.skip(ftype)
9575 
      elif fid == 3:
9576 
        if ftype == TType.I64:
9577 
          self.limit = iprot.readI64();
9578 
        else:
9579 
          iprot.skip(ftype)
9580 
      elif fid == 4:
9581 
        if ftype == TType.I64:
9582 
          self.warehouse_id = iprot.readI64();
9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      else:
9586 
        iprot.skip(ftype)
9587 
      iprot.readFieldEnd()
9588 
    iprot.readStructEnd()
9589 
 
9590 
  def write(self, oprot):
9591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9593 
      return
9594 
    oprot.writeStructBegin('getOrdersInBatch_args')
9595 
    if self.statuses is not None:
9596 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9597 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9598 
      for iter140 in self.statuses:
9599 
        oprot.writeI32(iter140)
4133 chandransh 9600 
      oprot.writeListEnd()
9601 
      oprot.writeFieldEnd()
9602 
    if self.offset is not None:
9603 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9604 
      oprot.writeI64(self.offset)
9605 
      oprot.writeFieldEnd()
9606 
    if self.limit is not None:
9607 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9608 
      oprot.writeI64(self.limit)
9609 
      oprot.writeFieldEnd()
9610 
    if self.warehouse_id is not None:
9611 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9612 
      oprot.writeI64(self.warehouse_id)
9613 
      oprot.writeFieldEnd()
9614 
    oprot.writeFieldStop()
9615 
    oprot.writeStructEnd()
9616 
 
9617 
  def validate(self):
9618 
    return
9619 
 
9620 
 
9621 
  def __repr__(self):
9622 
    L = ['%s=%r' % (key, value)
9623 
      for key, value in self.__dict__.iteritems()]
9624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9625 
 
9626 
  def __eq__(self, other):
9627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9628 
 
9629 
  def __ne__(self, other):
9630 
    return not (self == other)
9631 
 
9632 
class getOrdersInBatch_result:
9633 
  """
9634 
  Attributes:
9635 
   - success
9636 
   - ex
9637 
  """
9638 
 
9639 
  thrift_spec = (
9640 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9642 
  )
9643 
 
9644 
  def __init__(self, success=None, ex=None,):
9645 
    self.success = success
9646 
    self.ex = ex
9647 
 
9648 
  def read(self, iprot):
9649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9651 
      return
9652 
    iprot.readStructBegin()
9653 
    while True:
9654 
      (fname, ftype, fid) = iprot.readFieldBegin()
9655 
      if ftype == TType.STOP:
9656 
        break
9657 
      if fid == 0:
9658 
        if ftype == TType.LIST:
9659 
          self.success = []
6188 rajveer 9660 
          (_etype144, _size141) = iprot.readListBegin()
9661 
          for _i145 in xrange(_size141):
9662 
            _elem146 = Order()
9663 
            _elem146.read(iprot)
9664 
            self.success.append(_elem146)
4133 chandransh 9665 
          iprot.readListEnd()
9666 
        else:
9667 
          iprot.skip(ftype)
9668 
      elif fid == 1:
9669 
        if ftype == TType.STRUCT:
9670 
          self.ex = TransactionServiceException()
9671 
          self.ex.read(iprot)
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      else:
9675 
        iprot.skip(ftype)
9676 
      iprot.readFieldEnd()
9677 
    iprot.readStructEnd()
9678 
 
9679 
  def write(self, oprot):
9680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9682 
      return
9683 
    oprot.writeStructBegin('getOrdersInBatch_result')
9684 
    if self.success is not None:
9685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9687 
      for iter147 in self.success:
9688 
        iter147.write(oprot)
4133 chandransh 9689 
      oprot.writeListEnd()
9690 
      oprot.writeFieldEnd()
9691 
    if self.ex is not None:
9692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9693 
      self.ex.write(oprot)
9694 
      oprot.writeFieldEnd()
9695 
    oprot.writeFieldStop()
9696 
    oprot.writeStructEnd()
9697 
 
9698 
  def validate(self):
9699 
    return
9700 
 
9701 
 
9702 
  def __repr__(self):
9703 
    L = ['%s=%r' % (key, value)
9704 
      for key, value in self.__dict__.iteritems()]
9705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9706 
 
9707 
  def __eq__(self, other):
9708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9709 
 
9710 
  def __ne__(self, other):
9711 
    return not (self == other)
9712 
 
9713 
class getOrderCount_args:
9714 
  """
9715 
  Attributes:
9716 
   - statuses
9717 
   - warehouseId
9718 
  """
9719 
 
9720 
  thrift_spec = (
9721 
    None, # 0
9722 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9723 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9724 
  )
9725 
 
9726 
  def __init__(self, statuses=None, warehouseId=None,):
9727 
    self.statuses = statuses
9728 
    self.warehouseId = warehouseId
9729 
 
9730 
  def read(self, iprot):
9731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9733 
      return
9734 
    iprot.readStructBegin()
9735 
    while True:
9736 
      (fname, ftype, fid) = iprot.readFieldBegin()
9737 
      if ftype == TType.STOP:
9738 
        break
9739 
      if fid == 1:
9740 
        if ftype == TType.LIST:
9741 
          self.statuses = []
6188 rajveer 9742 
          (_etype151, _size148) = iprot.readListBegin()
9743 
          for _i152 in xrange(_size148):
9744 
            _elem153 = iprot.readI32();
9745 
            self.statuses.append(_elem153)
4133 chandransh 9746 
          iprot.readListEnd()
9747 
        else:
9748 
          iprot.skip(ftype)
9749 
      elif fid == 2:
9750 
        if ftype == TType.I64:
9751 
          self.warehouseId = iprot.readI64();
9752 
        else:
9753 
          iprot.skip(ftype)
9754 
      else:
9755 
        iprot.skip(ftype)
9756 
      iprot.readFieldEnd()
9757 
    iprot.readStructEnd()
9758 
 
9759 
  def write(self, oprot):
9760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9762 
      return
9763 
    oprot.writeStructBegin('getOrderCount_args')
9764 
    if self.statuses is not None:
9765 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9766 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9767 
      for iter154 in self.statuses:
9768 
        oprot.writeI32(iter154)
4133 chandransh 9769 
      oprot.writeListEnd()
9770 
      oprot.writeFieldEnd()
9771 
    if self.warehouseId is not None:
9772 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9773 
      oprot.writeI64(self.warehouseId)
9774 
      oprot.writeFieldEnd()
9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
9778 
  def validate(self):
9779 
    return
9780 
 
9781 
 
9782 
  def __repr__(self):
9783 
    L = ['%s=%r' % (key, value)
9784 
      for key, value in self.__dict__.iteritems()]
9785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9786 
 
9787 
  def __eq__(self, other):
9788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9789 
 
9790 
  def __ne__(self, other):
9791 
    return not (self == other)
9792 
 
9793 
class getOrderCount_result:
9794 
  """
9795 
  Attributes:
9796 
   - success
9797 
   - ex
9798 
  """
9799 
 
9800 
  thrift_spec = (
9801 
    (0, TType.I32, 'success', None, None, ), # 0
9802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9803 
  )
9804 
 
9805 
  def __init__(self, success=None, ex=None,):
9806 
    self.success = success
9807 
    self.ex = ex
9808 
 
9809 
  def read(self, iprot):
9810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9812 
      return
9813 
    iprot.readStructBegin()
9814 
    while True:
9815 
      (fname, ftype, fid) = iprot.readFieldBegin()
9816 
      if ftype == TType.STOP:
9817 
        break
9818 
      if fid == 0:
9819 
        if ftype == TType.I32:
9820 
          self.success = iprot.readI32();
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 1:
9824 
        if ftype == TType.STRUCT:
9825 
          self.ex = TransactionServiceException()
9826 
          self.ex.read(iprot)
9827 
        else:
9828 
          iprot.skip(ftype)
9829 
      else:
9830 
        iprot.skip(ftype)
9831 
      iprot.readFieldEnd()
9832 
    iprot.readStructEnd()
9833 
 
9834 
  def write(self, oprot):
9835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9837 
      return
9838 
    oprot.writeStructBegin('getOrderCount_result')
9839 
    if self.success is not None:
9840 
      oprot.writeFieldBegin('success', TType.I32, 0)
9841 
      oprot.writeI32(self.success)
9842 
      oprot.writeFieldEnd()
9843 
    if self.ex is not None:
9844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9845 
      self.ex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
999 varun.gupt 9865 
class getOrdersByBillingDate_args:
9866 
  """
9867 
  Attributes:
9868 
   - status
9869 
   - start_billing_date
9870 
   - end_billing_date
9871 
   - warehouse_id
9872 
  """
9873 
 
9874 
  thrift_spec = (
9875 
    None, # 0
9876 
    (1, TType.I32, 'status', None, None, ), # 1
9877 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9878 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9879 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9880 
  )
9881 
 
9882 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9883 
    self.status = status
9884 
    self.start_billing_date = start_billing_date
9885 
    self.end_billing_date = end_billing_date
9886 
    self.warehouse_id = warehouse_id
9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 1:
9898 
        if ftype == TType.I32:
9899 
          self.status = iprot.readI32();
9900 
        else:
9901 
          iprot.skip(ftype)
9902 
      elif fid == 2:
9903 
        if ftype == TType.I64:
9904 
          self.start_billing_date = iprot.readI64();
9905 
        else:
9906 
          iprot.skip(ftype)
9907 
      elif fid == 3:
9908 
        if ftype == TType.I64:
9909 
          self.end_billing_date = iprot.readI64();
9910 
        else:
9911 
          iprot.skip(ftype)
9912 
      elif fid == 4:
9913 
        if ftype == TType.I64:
9914 
          self.warehouse_id = iprot.readI64();
9915 
        else:
9916 
          iprot.skip(ftype)
9917 
      else:
9918 
        iprot.skip(ftype)
9919 
      iprot.readFieldEnd()
9920 
    iprot.readStructEnd()
9921 
 
9922 
  def write(self, oprot):
9923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9925 
      return
9926 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9927 
    if self.status is not None:
999 varun.gupt 9928 
      oprot.writeFieldBegin('status', TType.I32, 1)
9929 
      oprot.writeI32(self.status)
9930 
      oprot.writeFieldEnd()
3431 rajveer 9931 
    if self.start_billing_date is not None:
999 varun.gupt 9932 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9933 
      oprot.writeI64(self.start_billing_date)
9934 
      oprot.writeFieldEnd()
3431 rajveer 9935 
    if self.end_billing_date is not None:
999 varun.gupt 9936 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9937 
      oprot.writeI64(self.end_billing_date)
9938 
      oprot.writeFieldEnd()
3431 rajveer 9939 
    if self.warehouse_id is not None:
999 varun.gupt 9940 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9941 
      oprot.writeI64(self.warehouse_id)
9942 
      oprot.writeFieldEnd()
9943 
    oprot.writeFieldStop()
9944 
    oprot.writeStructEnd()
9945 
 
3431 rajveer 9946 
  def validate(self):
9947 
    return
9948 
 
9949 
 
999 varun.gupt 9950 
  def __repr__(self):
9951 
    L = ['%s=%r' % (key, value)
9952 
      for key, value in self.__dict__.iteritems()]
9953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9954 
 
9955 
  def __eq__(self, other):
9956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9957 
 
9958 
  def __ne__(self, other):
9959 
    return not (self == other)
9960 
 
9961 
class getOrdersByBillingDate_result:
9962 
  """
9963 
  Attributes:
9964 
   - success
9965 
   - ex
9966 
  """
9967 
 
9968 
  thrift_spec = (
9969 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9971 
  )
9972 
 
9973 
  def __init__(self, success=None, ex=None,):
9974 
    self.success = success
9975 
    self.ex = ex
9976 
 
9977 
  def read(self, iprot):
9978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9980 
      return
9981 
    iprot.readStructBegin()
9982 
    while True:
9983 
      (fname, ftype, fid) = iprot.readFieldBegin()
9984 
      if ftype == TType.STOP:
9985 
        break
9986 
      if fid == 0:
9987 
        if ftype == TType.LIST:
9988 
          self.success = []
6188 rajveer 9989 
          (_etype158, _size155) = iprot.readListBegin()
9990 
          for _i159 in xrange(_size155):
9991 
            _elem160 = Order()
9992 
            _elem160.read(iprot)
9993 
            self.success.append(_elem160)
999 varun.gupt 9994 
          iprot.readListEnd()
9995 
        else:
9996 
          iprot.skip(ftype)
9997 
      elif fid == 1:
9998 
        if ftype == TType.STRUCT:
9999 
          self.ex = TransactionServiceException()
10000 
          self.ex.read(iprot)
10001 
        else:
10002 
          iprot.skip(ftype)
10003 
      else:
10004 
        iprot.skip(ftype)
10005 
      iprot.readFieldEnd()
10006 
    iprot.readStructEnd()
10007 
 
10008 
  def write(self, oprot):
10009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10011 
      return
10012 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10013 
    if self.success is not None:
999 varun.gupt 10014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10015 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10016 
      for iter161 in self.success:
10017 
        iter161.write(oprot)
999 varun.gupt 10018 
      oprot.writeListEnd()
10019 
      oprot.writeFieldEnd()
3431 rajveer 10020 
    if self.ex is not None:
999 varun.gupt 10021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10022 
      self.ex.write(oprot)
10023 
      oprot.writeFieldEnd()
10024 
    oprot.writeFieldStop()
10025 
    oprot.writeStructEnd()
10026 
 
3431 rajveer 10027 
  def validate(self):
10028 
    return
10029 
 
10030 
 
999 varun.gupt 10031 
  def __repr__(self):
10032 
    L = ['%s=%r' % (key, value)
10033 
      for key, value in self.__dict__.iteritems()]
10034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10035 
 
10036 
  def __eq__(self, other):
10037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10038 
 
10039 
  def __ne__(self, other):
10040 
    return not (self == other)
10041 
 
3427 chandransh 10042 
class getOrdersByShippingDate_args:
10043 
  """
10044 
  Attributes:
10045 
   - fromShippingDate
10046 
   - toShippingDate
10047 
   - providerId
10048 
   - warehouseId
3451 chandransh 10049 
   - cod
3427 chandransh 10050 
  """
10051 
 
10052 
  thrift_spec = (
10053 
    None, # 0
10054 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10055 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10056 
    (3, TType.I64, 'providerId', None, None, ), # 3
10057 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10058 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10059 
  )
10060 
 
3451 chandransh 10061 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10062 
    self.fromShippingDate = fromShippingDate
10063 
    self.toShippingDate = toShippingDate
10064 
    self.providerId = providerId
10065 
    self.warehouseId = warehouseId
3451 chandransh 10066 
    self.cod = cod
3427 chandransh 10067 
 
10068 
  def read(self, iprot):
10069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10071 
      return
10072 
    iprot.readStructBegin()
10073 
    while True:
10074 
      (fname, ftype, fid) = iprot.readFieldBegin()
10075 
      if ftype == TType.STOP:
10076 
        break
10077 
      if fid == 1:
10078 
        if ftype == TType.I64:
10079 
          self.fromShippingDate = iprot.readI64();
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      elif fid == 2:
10083 
        if ftype == TType.I64:
10084 
          self.toShippingDate = iprot.readI64();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 3:
10088 
        if ftype == TType.I64:
10089 
          self.providerId = iprot.readI64();
10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      elif fid == 4:
10093 
        if ftype == TType.I64:
10094 
          self.warehouseId = iprot.readI64();
10095 
        else:
10096 
          iprot.skip(ftype)
3451 chandransh 10097 
      elif fid == 5:
10098 
        if ftype == TType.BOOL:
10099 
          self.cod = iprot.readBool();
10100 
        else:
10101 
          iprot.skip(ftype)
3427 chandransh 10102 
      else:
10103 
        iprot.skip(ftype)
10104 
      iprot.readFieldEnd()
10105 
    iprot.readStructEnd()
10106 
 
10107 
  def write(self, oprot):
10108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10110 
      return
10111 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10112 
    if self.fromShippingDate is not None:
3427 chandransh 10113 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10114 
      oprot.writeI64(self.fromShippingDate)
10115 
      oprot.writeFieldEnd()
3431 rajveer 10116 
    if self.toShippingDate is not None:
3427 chandransh 10117 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10118 
      oprot.writeI64(self.toShippingDate)
10119 
      oprot.writeFieldEnd()
3431 rajveer 10120 
    if self.providerId is not None:
3427 chandransh 10121 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10122 
      oprot.writeI64(self.providerId)
10123 
      oprot.writeFieldEnd()
3431 rajveer 10124 
    if self.warehouseId is not None:
3427 chandransh 10125 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10126 
      oprot.writeI64(self.warehouseId)
10127 
      oprot.writeFieldEnd()
3451 chandransh 10128 
    if self.cod is not None:
10129 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10130 
      oprot.writeBool(self.cod)
10131 
      oprot.writeFieldEnd()
3427 chandransh 10132 
    oprot.writeFieldStop()
10133 
    oprot.writeStructEnd()
10134 
 
3431 rajveer 10135 
  def validate(self):
10136 
    return
10137 
 
10138 
 
3427 chandransh 10139 
  def __repr__(self):
10140 
    L = ['%s=%r' % (key, value)
10141 
      for key, value in self.__dict__.iteritems()]
10142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10143 
 
10144 
  def __eq__(self, other):
10145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10146 
 
10147 
  def __ne__(self, other):
10148 
    return not (self == other)
10149 
 
10150 
class getOrdersByShippingDate_result:
10151 
  """
10152 
  Attributes:
10153 
   - success
10154 
   - ex
10155 
  """
10156 
 
10157 
  thrift_spec = (
10158 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10160 
  )
10161 
 
10162 
  def __init__(self, success=None, ex=None,):
10163 
    self.success = success
10164 
    self.ex = ex
10165 
 
10166 
  def read(self, iprot):
10167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10169 
      return
10170 
    iprot.readStructBegin()
10171 
    while True:
10172 
      (fname, ftype, fid) = iprot.readFieldBegin()
10173 
      if ftype == TType.STOP:
10174 
        break
10175 
      if fid == 0:
10176 
        if ftype == TType.LIST:
10177 
          self.success = []
6188 rajveer 10178 
          (_etype165, _size162) = iprot.readListBegin()
10179 
          for _i166 in xrange(_size162):
10180 
            _elem167 = Order()
10181 
            _elem167.read(iprot)
10182 
            self.success.append(_elem167)
3427 chandransh 10183 
          iprot.readListEnd()
10184 
        else:
10185 
          iprot.skip(ftype)
10186 
      elif fid == 1:
10187 
        if ftype == TType.STRUCT:
10188 
          self.ex = TransactionServiceException()
10189 
          self.ex.read(iprot)
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10202 
    if self.success is not None:
3427 chandransh 10203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10204 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10205 
      for iter168 in self.success:
10206 
        iter168.write(oprot)
3427 chandransh 10207 
      oprot.writeListEnd()
10208 
      oprot.writeFieldEnd()
3431 rajveer 10209 
    if self.ex is not None:
3427 chandransh 10210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10211 
      self.ex.write(oprot)
10212 
      oprot.writeFieldEnd()
10213 
    oprot.writeFieldStop()
10214 
    oprot.writeStructEnd()
10215 
 
3431 rajveer 10216 
  def validate(self):
10217 
    return
10218 
 
10219 
 
3427 chandransh 10220 
  def __repr__(self):
10221 
    L = ['%s=%r' % (key, value)
10222 
      for key, value in self.__dict__.iteritems()]
10223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10224 
 
10225 
  def __eq__(self, other):
10226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10227 
 
10228 
  def __ne__(self, other):
10229 
    return not (self == other)
10230 
 
1382 varun.gupt 10231 
class getReturnableOrdersForCustomer_args:
10232 
  """
10233 
  Attributes:
10234 
   - customer_id
10235 
   - limit
10236 
  """
10237 
 
10238 
  thrift_spec = (
10239 
    None, # 0
10240 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10241 
    (2, TType.I64, 'limit', None, None, ), # 2
10242 
  )
10243 
 
10244 
  def __init__(self, customer_id=None, limit=None,):
10245 
    self.customer_id = customer_id
10246 
    self.limit = limit
10247 
 
10248 
  def read(self, iprot):
10249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10251 
      return
10252 
    iprot.readStructBegin()
10253 
    while True:
10254 
      (fname, ftype, fid) = iprot.readFieldBegin()
10255 
      if ftype == TType.STOP:
10256 
        break
10257 
      if fid == 1:
10258 
        if ftype == TType.I64:
10259 
          self.customer_id = iprot.readI64();
10260 
        else:
10261 
          iprot.skip(ftype)
10262 
      elif fid == 2:
10263 
        if ftype == TType.I64:
10264 
          self.limit = iprot.readI64();
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      else:
10268 
        iprot.skip(ftype)
10269 
      iprot.readFieldEnd()
10270 
    iprot.readStructEnd()
10271 
 
10272 
  def write(self, oprot):
10273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10275 
      return
10276 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10277 
    if self.customer_id is not None:
1382 varun.gupt 10278 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10279 
      oprot.writeI64(self.customer_id)
10280 
      oprot.writeFieldEnd()
3431 rajveer 10281 
    if self.limit is not None:
1382 varun.gupt 10282 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10283 
      oprot.writeI64(self.limit)
10284 
      oprot.writeFieldEnd()
10285 
    oprot.writeFieldStop()
10286 
    oprot.writeStructEnd()
10287 
 
3431 rajveer 10288 
  def validate(self):
10289 
    return
10290 
 
10291 
 
1382 varun.gupt 10292 
  def __repr__(self):
10293 
    L = ['%s=%r' % (key, value)
10294 
      for key, value in self.__dict__.iteritems()]
10295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10296 
 
10297 
  def __eq__(self, other):
10298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10299 
 
10300 
  def __ne__(self, other):
10301 
    return not (self == other)
10302 
 
10303 
class getReturnableOrdersForCustomer_result:
10304 
  """
10305 
  Attributes:
10306 
   - success
10307 
   - ex
10308 
  """
10309 
 
10310 
  thrift_spec = (
10311 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10313 
  )
10314 
 
10315 
  def __init__(self, success=None, ex=None,):
10316 
    self.success = success
10317 
    self.ex = ex
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 == 0:
10329 
        if ftype == TType.LIST:
10330 
          self.success = []
6188 rajveer 10331 
          (_etype172, _size169) = iprot.readListBegin()
10332 
          for _i173 in xrange(_size169):
10333 
            _elem174 = iprot.readI64();
10334 
            self.success.append(_elem174)
1382 varun.gupt 10335 
          iprot.readListEnd()
10336 
        else:
10337 
          iprot.skip(ftype)
10338 
      elif fid == 1:
10339 
        if ftype == TType.STRUCT:
10340 
          self.ex = TransactionServiceException()
10341 
          self.ex.read(iprot)
10342 
        else:
10343 
          iprot.skip(ftype)
10344 
      else:
10345 
        iprot.skip(ftype)
10346 
      iprot.readFieldEnd()
10347 
    iprot.readStructEnd()
10348 
 
10349 
  def write(self, oprot):
10350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10352 
      return
10353 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10354 
    if self.success is not None:
1382 varun.gupt 10355 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10356 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10357 
      for iter175 in self.success:
10358 
        oprot.writeI64(iter175)
1382 varun.gupt 10359 
      oprot.writeListEnd()
10360 
      oprot.writeFieldEnd()
3431 rajveer 10361 
    if self.ex is not None:
1382 varun.gupt 10362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10363 
      self.ex.write(oprot)
10364 
      oprot.writeFieldEnd()
10365 
    oprot.writeFieldStop()
10366 
    oprot.writeStructEnd()
10367 
 
3431 rajveer 10368 
  def validate(self):
10369 
    return
10370 
 
10371 
 
1382 varun.gupt 10372 
  def __repr__(self):
10373 
    L = ['%s=%r' % (key, value)
10374 
      for key, value in self.__dict__.iteritems()]
10375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10376 
 
10377 
  def __eq__(self, other):
10378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10379 
 
10380 
  def __ne__(self, other):
10381 
    return not (self == other)
10382 
 
10383 
class getCancellableOrdersForCustomer_args:
10384 
  """
10385 
  Attributes:
10386 
   - customer_id
10387 
   - limit
10388 
  """
10389 
 
10390 
  thrift_spec = (
10391 
    None, # 0
10392 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10393 
    (2, TType.I64, 'limit', None, None, ), # 2
10394 
  )
10395 
 
10396 
  def __init__(self, customer_id=None, limit=None,):
10397 
    self.customer_id = customer_id
10398 
    self.limit = limit
10399 
 
10400 
  def read(self, iprot):
10401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10403 
      return
10404 
    iprot.readStructBegin()
10405 
    while True:
10406 
      (fname, ftype, fid) = iprot.readFieldBegin()
10407 
      if ftype == TType.STOP:
10408 
        break
10409 
      if fid == 1:
10410 
        if ftype == TType.I64:
10411 
          self.customer_id = iprot.readI64();
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      elif fid == 2:
10415 
        if ftype == TType.I64:
10416 
          self.limit = iprot.readI64();
10417 
        else:
10418 
          iprot.skip(ftype)
10419 
      else:
10420 
        iprot.skip(ftype)
10421 
      iprot.readFieldEnd()
10422 
    iprot.readStructEnd()
10423 
 
10424 
  def write(self, oprot):
10425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10427 
      return
10428 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10429 
    if self.customer_id is not None:
1382 varun.gupt 10430 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10431 
      oprot.writeI64(self.customer_id)
10432 
      oprot.writeFieldEnd()
3431 rajveer 10433 
    if self.limit is not None:
1382 varun.gupt 10434 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10435 
      oprot.writeI64(self.limit)
10436 
      oprot.writeFieldEnd()
10437 
    oprot.writeFieldStop()
10438 
    oprot.writeStructEnd()
10439 
 
3431 rajveer 10440 
  def validate(self):
10441 
    return
10442 
 
10443 
 
1382 varun.gupt 10444 
  def __repr__(self):
10445 
    L = ['%s=%r' % (key, value)
10446 
      for key, value in self.__dict__.iteritems()]
10447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10448 
 
10449 
  def __eq__(self, other):
10450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10451 
 
10452 
  def __ne__(self, other):
10453 
    return not (self == other)
10454 
 
10455 
class getCancellableOrdersForCustomer_result:
10456 
  """
10457 
  Attributes:
10458 
   - success
10459 
   - ex
10460 
  """
10461 
 
10462 
  thrift_spec = (
10463 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10465 
  )
10466 
 
10467 
  def __init__(self, success=None, ex=None,):
10468 
    self.success = success
10469 
    self.ex = ex
10470 
 
10471 
  def read(self, iprot):
10472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10474 
      return
10475 
    iprot.readStructBegin()
10476 
    while True:
10477 
      (fname, ftype, fid) = iprot.readFieldBegin()
10478 
      if ftype == TType.STOP:
10479 
        break
10480 
      if fid == 0:
10481 
        if ftype == TType.LIST:
10482 
          self.success = []
6188 rajveer 10483 
          (_etype179, _size176) = iprot.readListBegin()
10484 
          for _i180 in xrange(_size176):
10485 
            _elem181 = iprot.readI64();
10486 
            self.success.append(_elem181)
1382 varun.gupt 10487 
          iprot.readListEnd()
10488 
        else:
10489 
          iprot.skip(ftype)
10490 
      elif fid == 1:
10491 
        if ftype == TType.STRUCT:
10492 
          self.ex = TransactionServiceException()
10493 
          self.ex.read(iprot)
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      else:
10497 
        iprot.skip(ftype)
10498 
      iprot.readFieldEnd()
10499 
    iprot.readStructEnd()
10500 
 
10501 
  def write(self, oprot):
10502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10504 
      return
10505 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10506 
    if self.success is not None:
1382 varun.gupt 10507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10508 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10509 
      for iter182 in self.success:
10510 
        oprot.writeI64(iter182)
1382 varun.gupt 10511 
      oprot.writeListEnd()
10512 
      oprot.writeFieldEnd()
3431 rajveer 10513 
    if self.ex is not None:
1382 varun.gupt 10514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10515 
      self.ex.write(oprot)
10516 
      oprot.writeFieldEnd()
10517 
    oprot.writeFieldStop()
10518 
    oprot.writeStructEnd()
10519 
 
3431 rajveer 10520 
  def validate(self):
10521 
    return
10522 
 
10523 
 
1382 varun.gupt 10524 
  def __repr__(self):
10525 
    L = ['%s=%r' % (key, value)
10526 
      for key, value in self.__dict__.iteritems()]
10527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10528 
 
10529 
  def __eq__(self, other):
10530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10531 
 
10532 
  def __ne__(self, other):
10533 
    return not (self == other)
10534 
 
483 rajveer 10535 
class changeOrderStatus_args:
94 ashish 10536 
  """
10537 
  Attributes:
483 rajveer 10538 
   - orderId
10539 
   - status
10540 
   - description
94 ashish 10541 
  """
10542 
 
10543 
  thrift_spec = (
10544 
    None, # 0
483 rajveer 10545 
    (1, TType.I64, 'orderId', None, None, ), # 1
10546 
    (2, TType.I32, 'status', None, None, ), # 2
10547 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10548 
  )
10549 
 
483 rajveer 10550 
  def __init__(self, orderId=None, status=None, description=None,):
10551 
    self.orderId = orderId
10552 
    self.status = status
10553 
    self.description = description
94 ashish 10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 1:
10565 
        if ftype == TType.I64:
483 rajveer 10566 
          self.orderId = iprot.readI64();
94 ashish 10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      elif fid == 2:
483 rajveer 10570 
        if ftype == TType.I32:
10571 
          self.status = iprot.readI32();
94 ashish 10572 
        else:
10573 
          iprot.skip(ftype)
483 rajveer 10574 
      elif fid == 3:
10575 
        if ftype == TType.STRING:
10576 
          self.description = iprot.readString();
10577 
        else:
10578 
          iprot.skip(ftype)
94 ashish 10579 
      else:
10580 
        iprot.skip(ftype)
10581 
      iprot.readFieldEnd()
10582 
    iprot.readStructEnd()
10583 
 
10584 
  def write(self, oprot):
10585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10587 
      return
483 rajveer 10588 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10589 
    if self.orderId is not None:
483 rajveer 10590 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10591 
      oprot.writeI64(self.orderId)
94 ashish 10592 
      oprot.writeFieldEnd()
3431 rajveer 10593 
    if self.status is not None:
483 rajveer 10594 
      oprot.writeFieldBegin('status', TType.I32, 2)
10595 
      oprot.writeI32(self.status)
94 ashish 10596 
      oprot.writeFieldEnd()
3431 rajveer 10597 
    if self.description is not None:
483 rajveer 10598 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10599 
      oprot.writeString(self.description)
10600 
      oprot.writeFieldEnd()
94 ashish 10601 
    oprot.writeFieldStop()
10602 
    oprot.writeStructEnd()
10603 
 
3431 rajveer 10604 
  def validate(self):
10605 
    return
10606 
 
10607 
 
94 ashish 10608 
  def __repr__(self):
10609 
    L = ['%s=%r' % (key, value)
10610 
      for key, value in self.__dict__.iteritems()]
10611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10612 
 
10613 
  def __eq__(self, other):
10614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10615 
 
10616 
  def __ne__(self, other):
10617 
    return not (self == other)
10618 
 
483 rajveer 10619 
class changeOrderStatus_result:
94 ashish 10620 
  """
10621 
  Attributes:
10622 
   - success
10623 
   - ex
10624 
  """
10625 
 
10626 
  thrift_spec = (
10627 
    (0, TType.BOOL, 'success', None, None, ), # 0
10628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10629 
  )
10630 
 
10631 
  def __init__(self, success=None, ex=None,):
10632 
    self.success = success
10633 
    self.ex = ex
10634 
 
10635 
  def read(self, iprot):
10636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10638 
      return
10639 
    iprot.readStructBegin()
10640 
    while True:
10641 
      (fname, ftype, fid) = iprot.readFieldBegin()
10642 
      if ftype == TType.STOP:
10643 
        break
10644 
      if fid == 0:
10645 
        if ftype == TType.BOOL:
10646 
          self.success = iprot.readBool();
10647 
        else:
10648 
          iprot.skip(ftype)
10649 
      elif fid == 1:
10650 
        if ftype == TType.STRUCT:
10651 
          self.ex = TransactionServiceException()
10652 
          self.ex.read(iprot)
10653 
        else:
10654 
          iprot.skip(ftype)
10655 
      else:
10656 
        iprot.skip(ftype)
10657 
      iprot.readFieldEnd()
10658 
    iprot.readStructEnd()
10659 
 
10660 
  def write(self, oprot):
10661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10663 
      return
483 rajveer 10664 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10665 
    if self.success is not None:
94 ashish 10666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10667 
      oprot.writeBool(self.success)
10668 
      oprot.writeFieldEnd()
3431 rajveer 10669 
    if self.ex is not None:
94 ashish 10670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10671 
      self.ex.write(oprot)
10672 
      oprot.writeFieldEnd()
10673 
    oprot.writeFieldStop()
10674 
    oprot.writeStructEnd()
10675 
 
3431 rajveer 10676 
  def validate(self):
10677 
    return
10678 
 
10679 
 
94 ashish 10680 
  def __repr__(self):
10681 
    L = ['%s=%r' % (key, value)
10682 
      for key, value in self.__dict__.iteritems()]
10683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10684 
 
10685 
  def __eq__(self, other):
10686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10687 
 
10688 
  def __ne__(self, other):
10689 
    return not (self == other)
10690 
 
3064 chandransh 10691 
class getOrdersForTransaction_args:
494 rajveer 10692 
  """
10693 
  Attributes:
3064 chandransh 10694 
   - transactionId
10695 
   - customerId
494 rajveer 10696 
  """
10697 
 
10698 
  thrift_spec = (
10699 
    None, # 0
3064 chandransh 10700 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10701 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10702 
  )
10703 
 
3064 chandransh 10704 
  def __init__(self, transactionId=None, customerId=None,):
10705 
    self.transactionId = transactionId
10706 
    self.customerId = customerId
494 rajveer 10707 
 
10708 
  def read(self, iprot):
10709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10711 
      return
10712 
    iprot.readStructBegin()
10713 
    while True:
10714 
      (fname, ftype, fid) = iprot.readFieldBegin()
10715 
      if ftype == TType.STOP:
10716 
        break
10717 
      if fid == 1:
10718 
        if ftype == TType.I64:
3064 chandransh 10719 
          self.transactionId = iprot.readI64();
494 rajveer 10720 
        else:
10721 
          iprot.skip(ftype)
10722 
      elif fid == 2:
3064 chandransh 10723 
        if ftype == TType.I64:
10724 
          self.customerId = iprot.readI64();
494 rajveer 10725 
        else:
10726 
          iprot.skip(ftype)
10727 
      else:
10728 
        iprot.skip(ftype)
10729 
      iprot.readFieldEnd()
10730 
    iprot.readStructEnd()
10731 
 
10732 
  def write(self, oprot):
10733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10735 
      return
3064 chandransh 10736 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10737 
    if self.transactionId is not None:
3064 chandransh 10738 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10739 
      oprot.writeI64(self.transactionId)
494 rajveer 10740 
      oprot.writeFieldEnd()
3431 rajveer 10741 
    if self.customerId is not None:
3064 chandransh 10742 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10743 
      oprot.writeI64(self.customerId)
494 rajveer 10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
3431 rajveer 10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
494 rajveer 10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
3064 chandransh 10763 
class getOrdersForTransaction_result:
494 rajveer 10764 
  """
10765 
  Attributes:
10766 
   - success
10767 
   - ex
10768 
  """
10769 
 
10770 
  thrift_spec = (
3064 chandransh 10771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10773 
  )
10774 
 
10775 
  def __init__(self, success=None, ex=None,):
10776 
    self.success = success
10777 
    self.ex = ex
10778 
 
10779 
  def read(self, iprot):
10780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10782 
      return
10783 
    iprot.readStructBegin()
10784 
    while True:
10785 
      (fname, ftype, fid) = iprot.readFieldBegin()
10786 
      if ftype == TType.STOP:
10787 
        break
10788 
      if fid == 0:
3064 chandransh 10789 
        if ftype == TType.LIST:
10790 
          self.success = []
6188 rajveer 10791 
          (_etype186, _size183) = iprot.readListBegin()
10792 
          for _i187 in xrange(_size183):
10793 
            _elem188 = Order()
10794 
            _elem188.read(iprot)
10795 
            self.success.append(_elem188)
3064 chandransh 10796 
          iprot.readListEnd()
494 rajveer 10797 
        else:
10798 
          iprot.skip(ftype)
10799 
      elif fid == 1:
10800 
        if ftype == TType.STRUCT:
10801 
          self.ex = TransactionServiceException()
10802 
          self.ex.read(iprot)
10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      else:
10806 
        iprot.skip(ftype)
10807 
      iprot.readFieldEnd()
10808 
    iprot.readStructEnd()
10809 
 
10810 
  def write(self, oprot):
10811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10813 
      return
3064 chandransh 10814 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10815 
    if self.success is not None:
3064 chandransh 10816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10818 
      for iter189 in self.success:
10819 
        iter189.write(oprot)
3064 chandransh 10820 
      oprot.writeListEnd()
494 rajveer 10821 
      oprot.writeFieldEnd()
3431 rajveer 10822 
    if self.ex is not None:
494 rajveer 10823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10824 
      self.ex.write(oprot)
10825 
      oprot.writeFieldEnd()
10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
3431 rajveer 10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
494 rajveer 10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
3064 chandransh 10844 
class getOrdersForCustomer_args:
1149 chandransh 10845 
  """
10846 
  Attributes:
3064 chandransh 10847 
   - customerId
10848 
   - from_date
10849 
   - to_date
10850 
   - statuses
1149 chandransh 10851 
  """
10852 
 
10853 
  thrift_spec = (
10854 
    None, # 0
3064 chandransh 10855 
    (1, TType.I64, 'customerId', None, None, ), # 1
10856 
    (2, TType.I64, 'from_date', None, None, ), # 2
10857 
    (3, TType.I64, 'to_date', None, None, ), # 3
10858 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10859 
  )
10860 
 
3064 chandransh 10861 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10862 
    self.customerId = customerId
10863 
    self.from_date = from_date
10864 
    self.to_date = to_date
10865 
    self.statuses = statuses
1149 chandransh 10866 
 
10867 
  def read(self, iprot):
10868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10870 
      return
10871 
    iprot.readStructBegin()
10872 
    while True:
10873 
      (fname, ftype, fid) = iprot.readFieldBegin()
10874 
      if ftype == TType.STOP:
10875 
        break
10876 
      if fid == 1:
10877 
        if ftype == TType.I64:
3064 chandransh 10878 
          self.customerId = iprot.readI64();
1149 chandransh 10879 
        else:
10880 
          iprot.skip(ftype)
10881 
      elif fid == 2:
10882 
        if ftype == TType.I64:
3064 chandransh 10883 
          self.from_date = iprot.readI64();
1149 chandransh 10884 
        else:
10885 
          iprot.skip(ftype)
2783 chandransh 10886 
      elif fid == 3:
10887 
        if ftype == TType.I64:
3064 chandransh 10888 
          self.to_date = iprot.readI64();
2783 chandransh 10889 
        else:
10890 
          iprot.skip(ftype)
10891 
      elif fid == 4:
3064 chandransh 10892 
        if ftype == TType.LIST:
10893 
          self.statuses = []
6188 rajveer 10894 
          (_etype193, _size190) = iprot.readListBegin()
10895 
          for _i194 in xrange(_size190):
10896 
            _elem195 = iprot.readI32();
10897 
            self.statuses.append(_elem195)
3064 chandransh 10898 
          iprot.readListEnd()
2783 chandransh 10899 
        else:
10900 
          iprot.skip(ftype)
1149 chandransh 10901 
      else:
10902 
        iprot.skip(ftype)
10903 
      iprot.readFieldEnd()
10904 
    iprot.readStructEnd()
10905 
 
10906 
  def write(self, oprot):
10907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10909 
      return
3064 chandransh 10910 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10911 
    if self.customerId is not None:
3064 chandransh 10912 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10913 
      oprot.writeI64(self.customerId)
1149 chandransh 10914 
      oprot.writeFieldEnd()
3431 rajveer 10915 
    if self.from_date is not None:
3064 chandransh 10916 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10917 
      oprot.writeI64(self.from_date)
1149 chandransh 10918 
      oprot.writeFieldEnd()
3431 rajveer 10919 
    if self.to_date is not None:
3064 chandransh 10920 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10921 
      oprot.writeI64(self.to_date)
2783 chandransh 10922 
      oprot.writeFieldEnd()
3431 rajveer 10923 
    if self.statuses is not None:
3064 chandransh 10924 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10925 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10926 
      for iter196 in self.statuses:
10927 
        oprot.writeI32(iter196)
3064 chandransh 10928 
      oprot.writeListEnd()
2783 chandransh 10929 
      oprot.writeFieldEnd()
1149 chandransh 10930 
    oprot.writeFieldStop()
10931 
    oprot.writeStructEnd()
10932 
 
3431 rajveer 10933 
  def validate(self):
10934 
    return
10935 
 
10936 
 
1149 chandransh 10937 
  def __repr__(self):
10938 
    L = ['%s=%r' % (key, value)
10939 
      for key, value in self.__dict__.iteritems()]
10940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10941 
 
10942 
  def __eq__(self, other):
10943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10944 
 
10945 
  def __ne__(self, other):
10946 
    return not (self == other)
10947 
 
3064 chandransh 10948 
class getOrdersForCustomer_result:
1149 chandransh 10949 
  """
10950 
  Attributes:
10951 
   - success
10952 
   - ex
10953 
  """
10954 
 
10955 
  thrift_spec = (
3064 chandransh 10956 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10958 
  )
10959 
 
10960 
  def __init__(self, success=None, ex=None,):
10961 
    self.success = success
10962 
    self.ex = ex
10963 
 
10964 
  def read(self, iprot):
10965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10967 
      return
10968 
    iprot.readStructBegin()
10969 
    while True:
10970 
      (fname, ftype, fid) = iprot.readFieldBegin()
10971 
      if ftype == TType.STOP:
10972 
        break
10973 
      if fid == 0:
3064 chandransh 10974 
        if ftype == TType.LIST:
10975 
          self.success = []
6188 rajveer 10976 
          (_etype200, _size197) = iprot.readListBegin()
10977 
          for _i201 in xrange(_size197):
10978 
            _elem202 = Order()
10979 
            _elem202.read(iprot)
10980 
            self.success.append(_elem202)
3064 chandransh 10981 
          iprot.readListEnd()
1149 chandransh 10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      elif fid == 1:
10985 
        if ftype == TType.STRUCT:
10986 
          self.ex = TransactionServiceException()
10987 
          self.ex.read(iprot)
10988 
        else:
10989 
          iprot.skip(ftype)
10990 
      else:
10991 
        iprot.skip(ftype)
10992 
      iprot.readFieldEnd()
10993 
    iprot.readStructEnd()
10994 
 
10995 
  def write(self, oprot):
10996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10998 
      return
3064 chandransh 10999 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11000 
    if self.success is not None:
3064 chandransh 11001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11003 
      for iter203 in self.success:
11004 
        iter203.write(oprot)
3064 chandransh 11005 
      oprot.writeListEnd()
1149 chandransh 11006 
      oprot.writeFieldEnd()
3431 rajveer 11007 
    if self.ex is not None:
1149 chandransh 11008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11009 
      self.ex.write(oprot)
11010 
      oprot.writeFieldEnd()
11011 
    oprot.writeFieldStop()
11012 
    oprot.writeStructEnd()
11013 
 
3431 rajveer 11014 
  def validate(self):
11015 
    return
11016 
 
11017 
 
1149 chandransh 11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
3064 chandransh 11029 
class createOrder_args:
921 rajveer 11030 
  """
11031 
  Attributes:
3064 chandransh 11032 
   - order
921 rajveer 11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    None, # 0
3064 chandransh 11037 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11038 
  )
11039 
 
3064 chandransh 11040 
  def __init__(self, order=None,):
11041 
    self.order = order
921 rajveer 11042 
 
11043 
  def read(self, iprot):
11044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11046 
      return
11047 
    iprot.readStructBegin()
11048 
    while True:
11049 
      (fname, ftype, fid) = iprot.readFieldBegin()
11050 
      if ftype == TType.STOP:
11051 
        break
11052 
      if fid == 1:
3064 chandransh 11053 
        if ftype == TType.STRUCT:
11054 
          self.order = Order()
11055 
          self.order.read(iprot)
921 rajveer 11056 
        else:
11057 
          iprot.skip(ftype)
11058 
      else:
11059 
        iprot.skip(ftype)
11060 
      iprot.readFieldEnd()
11061 
    iprot.readStructEnd()
11062 
 
11063 
  def write(self, oprot):
11064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11066 
      return
3064 chandransh 11067 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11068 
    if self.order is not None:
3064 chandransh 11069 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11070 
      self.order.write(oprot)
921 rajveer 11071 
      oprot.writeFieldEnd()
11072 
    oprot.writeFieldStop()
11073 
    oprot.writeStructEnd()
11074 
 
3431 rajveer 11075 
  def validate(self):
11076 
    return
11077 
 
11078 
 
921 rajveer 11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
3064 chandransh 11090 
class createOrder_result:
921 rajveer 11091 
  """
11092 
  Attributes:
11093 
   - success
11094 
   - ex
11095 
  """
11096 
 
11097 
  thrift_spec = (
3064 chandransh 11098 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11100 
  )
11101 
 
11102 
  def __init__(self, success=None, ex=None,):
11103 
    self.success = success
11104 
    self.ex = ex
11105 
 
11106 
  def read(self, iprot):
11107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11109 
      return
11110 
    iprot.readStructBegin()
11111 
    while True:
11112 
      (fname, ftype, fid) = iprot.readFieldBegin()
11113 
      if ftype == TType.STOP:
11114 
        break
11115 
      if fid == 0:
3064 chandransh 11116 
        if ftype == TType.I64:
11117 
          self.success = iprot.readI64();
921 rajveer 11118 
        else:
11119 
          iprot.skip(ftype)
11120 
      elif fid == 1:
11121 
        if ftype == TType.STRUCT:
11122 
          self.ex = TransactionServiceException()
11123 
          self.ex.read(iprot)
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      else:
11127 
        iprot.skip(ftype)
11128 
      iprot.readFieldEnd()
11129 
    iprot.readStructEnd()
11130 
 
11131 
  def write(self, oprot):
11132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11134 
      return
3064 chandransh 11135 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11136 
    if self.success is not None:
3064 chandransh 11137 
      oprot.writeFieldBegin('success', TType.I64, 0)
11138 
      oprot.writeI64(self.success)
921 rajveer 11139 
      oprot.writeFieldEnd()
3431 rajveer 11140 
    if self.ex is not None:
921 rajveer 11141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11142 
      self.ex.write(oprot)
11143 
      oprot.writeFieldEnd()
11144 
    oprot.writeFieldStop()
11145 
    oprot.writeStructEnd()
11146 
 
3431 rajveer 11147 
  def validate(self):
11148 
    return
11149 
 
11150 
 
921 rajveer 11151 
  def __repr__(self):
11152 
    L = ['%s=%r' % (key, value)
11153 
      for key, value in self.__dict__.iteritems()]
11154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11155 
 
11156 
  def __eq__(self, other):
11157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11158 
 
11159 
  def __ne__(self, other):
11160 
    return not (self == other)
11161 
 
3064 chandransh 11162 
class getOrder_args:
921 rajveer 11163 
  """
11164 
  Attributes:
3064 chandransh 11165 
   - id
921 rajveer 11166 
  """
11167 
 
11168 
  thrift_spec = (
11169 
    None, # 0
3064 chandransh 11170 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11171 
  )
11172 
 
3064 chandransh 11173 
  def __init__(self, id=None,):
11174 
    self.id = id
921 rajveer 11175 
 
11176 
  def read(self, iprot):
11177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11179 
      return
11180 
    iprot.readStructBegin()
11181 
    while True:
11182 
      (fname, ftype, fid) = iprot.readFieldBegin()
11183 
      if ftype == TType.STOP:
11184 
        break
11185 
      if fid == 1:
11186 
        if ftype == TType.I64:
3064 chandransh 11187 
          self.id = iprot.readI64();
921 rajveer 11188 
        else:
11189 
          iprot.skip(ftype)
11190 
      else:
11191 
        iprot.skip(ftype)
11192 
      iprot.readFieldEnd()
11193 
    iprot.readStructEnd()
11194 
 
11195 
  def write(self, oprot):
11196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11198 
      return
3064 chandransh 11199 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11200 
    if self.id is not None:
3064 chandransh 11201 
      oprot.writeFieldBegin('id', TType.I64, 1)
11202 
      oprot.writeI64(self.id)
921 rajveer 11203 
      oprot.writeFieldEnd()
11204 
    oprot.writeFieldStop()
11205 
    oprot.writeStructEnd()
11206 
 
3431 rajveer 11207 
  def validate(self):
11208 
    return
11209 
 
11210 
 
921 rajveer 11211 
  def __repr__(self):
11212 
    L = ['%s=%r' % (key, value)
11213 
      for key, value in self.__dict__.iteritems()]
11214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11215 
 
11216 
  def __eq__(self, other):
11217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11218 
 
11219 
  def __ne__(self, other):
11220 
    return not (self == other)
11221 
 
3064 chandransh 11222 
class getOrder_result:
921 rajveer 11223 
  """
11224 
  Attributes:
11225 
   - success
11226 
   - ex
11227 
  """
11228 
 
11229 
  thrift_spec = (
3064 chandransh 11230 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11232 
  )
11233 
 
11234 
  def __init__(self, success=None, ex=None,):
11235 
    self.success = success
11236 
    self.ex = ex
11237 
 
11238 
  def read(self, iprot):
11239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11241 
      return
11242 
    iprot.readStructBegin()
11243 
    while True:
11244 
      (fname, ftype, fid) = iprot.readFieldBegin()
11245 
      if ftype == TType.STOP:
11246 
        break
11247 
      if fid == 0:
3064 chandransh 11248 
        if ftype == TType.STRUCT:
11249 
          self.success = Order()
11250 
          self.success.read(iprot)
921 rajveer 11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      elif fid == 1:
11254 
        if ftype == TType.STRUCT:
11255 
          self.ex = TransactionServiceException()
11256 
          self.ex.read(iprot)
11257 
        else:
11258 
          iprot.skip(ftype)
11259 
      else:
11260 
        iprot.skip(ftype)
11261 
      iprot.readFieldEnd()
11262 
    iprot.readStructEnd()
11263 
 
11264 
  def write(self, oprot):
11265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11267 
      return
3064 chandransh 11268 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11269 
    if self.success is not None:
3064 chandransh 11270 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11271 
      self.success.write(oprot)
921 rajveer 11272 
      oprot.writeFieldEnd()
3431 rajveer 11273 
    if self.ex is not None:
921 rajveer 11274 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11275 
      self.ex.write(oprot)
11276 
      oprot.writeFieldEnd()
11277 
    oprot.writeFieldStop()
11278 
    oprot.writeStructEnd()
11279 
 
3431 rajveer 11280 
  def validate(self):
11281 
    return
11282 
 
11283 
 
921 rajveer 11284 
  def __repr__(self):
11285 
    L = ['%s=%r' % (key, value)
11286 
      for key, value in self.__dict__.iteritems()]
11287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11288 
 
11289 
  def __eq__(self, other):
11290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11291 
 
11292 
  def __ne__(self, other):
11293 
    return not (self == other)
11294 
 
3064 chandransh 11295 
class getLineItemsForOrder_args:
94 ashish 11296 
  """
11297 
  Attributes:
3064 chandransh 11298 
   - orderId
94 ashish 11299 
  """
11300 
 
11301 
  thrift_spec = (
11302 
    None, # 0
3064 chandransh 11303 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11304 
  )
11305 
 
3064 chandransh 11306 
  def __init__(self, orderId=None,):
11307 
    self.orderId = orderId
94 ashish 11308 
 
11309 
  def read(self, iprot):
11310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11312 
      return
11313 
    iprot.readStructBegin()
11314 
    while True:
11315 
      (fname, ftype, fid) = iprot.readFieldBegin()
11316 
      if ftype == TType.STOP:
11317 
        break
11318 
      if fid == 1:
11319 
        if ftype == TType.I64:
3064 chandransh 11320 
          self.orderId = iprot.readI64();
94 ashish 11321 
        else:
11322 
          iprot.skip(ftype)
11323 
      else:
11324 
        iprot.skip(ftype)
11325 
      iprot.readFieldEnd()
11326 
    iprot.readStructEnd()
11327 
 
11328 
  def write(self, oprot):
11329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11331 
      return
3064 chandransh 11332 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11333 
    if self.orderId is not None:
3064 chandransh 11334 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11335 
      oprot.writeI64(self.orderId)
94 ashish 11336 
      oprot.writeFieldEnd()
11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
3431 rajveer 11340 
  def validate(self):
11341 
    return
11342 
 
11343 
 
94 ashish 11344 
  def __repr__(self):
11345 
    L = ['%s=%r' % (key, value)
11346 
      for key, value in self.__dict__.iteritems()]
11347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11348 
 
11349 
  def __eq__(self, other):
11350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11351 
 
11352 
  def __ne__(self, other):
11353 
    return not (self == other)
11354 
 
3064 chandransh 11355 
class getLineItemsForOrder_result:
94 ashish 11356 
  """
11357 
  Attributes:
11358 
   - success
11359 
   - ex
11360 
  """
11361 
 
11362 
  thrift_spec = (
3064 chandransh 11363 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11365 
  )
11366 
 
11367 
  def __init__(self, success=None, ex=None,):
11368 
    self.success = success
11369 
    self.ex = ex
11370 
 
11371 
  def read(self, iprot):
11372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11374 
      return
11375 
    iprot.readStructBegin()
11376 
    while True:
11377 
      (fname, ftype, fid) = iprot.readFieldBegin()
11378 
      if ftype == TType.STOP:
11379 
        break
11380 
      if fid == 0:
483 rajveer 11381 
        if ftype == TType.LIST:
11382 
          self.success = []
6188 rajveer 11383 
          (_etype207, _size204) = iprot.readListBegin()
11384 
          for _i208 in xrange(_size204):
11385 
            _elem209 = LineItem()
11386 
            _elem209.read(iprot)
11387 
            self.success.append(_elem209)
483 rajveer 11388 
          iprot.readListEnd()
94 ashish 11389 
        else:
11390 
          iprot.skip(ftype)
11391 
      elif fid == 1:
11392 
        if ftype == TType.STRUCT:
11393 
          self.ex = TransactionServiceException()
11394 
          self.ex.read(iprot)
11395 
        else:
11396 
          iprot.skip(ftype)
11397 
      else:
11398 
        iprot.skip(ftype)
11399 
      iprot.readFieldEnd()
11400 
    iprot.readStructEnd()
11401 
 
11402 
  def write(self, oprot):
11403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11405 
      return
3064 chandransh 11406 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11407 
    if self.success is not None:
483 rajveer 11408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11410 
      for iter210 in self.success:
11411 
        iter210.write(oprot)
483 rajveer 11412 
      oprot.writeListEnd()
94 ashish 11413 
      oprot.writeFieldEnd()
3431 rajveer 11414 
    if self.ex is not None:
94 ashish 11415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11416 
      self.ex.write(oprot)
11417 
      oprot.writeFieldEnd()
11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
3431 rajveer 11421 
  def validate(self):
11422 
    return
11423 
 
11424 
 
94 ashish 11425 
  def __repr__(self):
11426 
    L = ['%s=%r' % (key, value)
11427 
      for key, value in self.__dict__.iteritems()]
11428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11429 
 
11430 
  def __eq__(self, other):
11431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11432 
 
11433 
  def __ne__(self, other):
11434 
    return not (self == other)
11435 
 
4999 phani.kuma 11436 
class getOrderList_args:
11437 
  """
11438 
  Attributes:
11439 
   - order_ids
11440 
  """
11441 
 
11442 
  thrift_spec = (
11443 
    None, # 0
11444 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11445 
  )
11446 
 
11447 
  def __init__(self, order_ids=None,):
11448 
    self.order_ids = order_ids
11449 
 
11450 
  def read(self, iprot):
11451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11453 
      return
11454 
    iprot.readStructBegin()
11455 
    while True:
11456 
      (fname, ftype, fid) = iprot.readFieldBegin()
11457 
      if ftype == TType.STOP:
11458 
        break
11459 
      if fid == 1:
11460 
        if ftype == TType.LIST:
11461 
          self.order_ids = []
6188 rajveer 11462 
          (_etype214, _size211) = iprot.readListBegin()
11463 
          for _i215 in xrange(_size211):
11464 
            _elem216 = iprot.readI64();
11465 
            self.order_ids.append(_elem216)
4999 phani.kuma 11466 
          iprot.readListEnd()
11467 
        else:
11468 
          iprot.skip(ftype)
11469 
      else:
11470 
        iprot.skip(ftype)
11471 
      iprot.readFieldEnd()
11472 
    iprot.readStructEnd()
11473 
 
11474 
  def write(self, oprot):
11475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11477 
      return
11478 
    oprot.writeStructBegin('getOrderList_args')
11479 
    if self.order_ids is not None:
11480 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11481 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11482 
      for iter217 in self.order_ids:
11483 
        oprot.writeI64(iter217)
4999 phani.kuma 11484 
      oprot.writeListEnd()
11485 
      oprot.writeFieldEnd()
11486 
    oprot.writeFieldStop()
11487 
    oprot.writeStructEnd()
11488 
 
11489 
  def validate(self):
11490 
    return
11491 
 
11492 
 
11493 
  def __repr__(self):
11494 
    L = ['%s=%r' % (key, value)
11495 
      for key, value in self.__dict__.iteritems()]
11496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11497 
 
11498 
  def __eq__(self, other):
11499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11500 
 
11501 
  def __ne__(self, other):
11502 
    return not (self == other)
11503 
 
11504 
class getOrderList_result:
11505 
  """
11506 
  Attributes:
11507 
   - success
11508 
  """
11509 
 
11510 
  thrift_spec = (
11511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11512 
  )
11513 
 
11514 
  def __init__(self, success=None,):
11515 
    self.success = success
11516 
 
11517 
  def read(self, iprot):
11518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11520 
      return
11521 
    iprot.readStructBegin()
11522 
    while True:
11523 
      (fname, ftype, fid) = iprot.readFieldBegin()
11524 
      if ftype == TType.STOP:
11525 
        break
11526 
      if fid == 0:
11527 
        if ftype == TType.LIST:
11528 
          self.success = []
6188 rajveer 11529 
          (_etype221, _size218) = iprot.readListBegin()
11530 
          for _i222 in xrange(_size218):
11531 
            _elem223 = Order()
11532 
            _elem223.read(iprot)
11533 
            self.success.append(_elem223)
4999 phani.kuma 11534 
          iprot.readListEnd()
11535 
        else:
11536 
          iprot.skip(ftype)
11537 
      else:
11538 
        iprot.skip(ftype)
11539 
      iprot.readFieldEnd()
11540 
    iprot.readStructEnd()
11541 
 
11542 
  def write(self, oprot):
11543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11545 
      return
11546 
    oprot.writeStructBegin('getOrderList_result')
11547 
    if self.success is not None:
11548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11549 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11550 
      for iter224 in self.success:
11551 
        iter224.write(oprot)
4999 phani.kuma 11552 
      oprot.writeListEnd()
11553 
      oprot.writeFieldEnd()
11554 
    oprot.writeFieldStop()
11555 
    oprot.writeStructEnd()
11556 
 
11557 
  def validate(self):
11558 
    return
11559 
 
11560 
 
11561 
  def __repr__(self):
11562 
    L = ['%s=%r' % (key, value)
11563 
      for key, value in self.__dict__.iteritems()]
11564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11565 
 
11566 
  def __eq__(self, other):
11567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11568 
 
11569 
  def __ne__(self, other):
11570 
    return not (self == other)
11571 
 
5386 phani.kuma 11572 
class getOrderListForVendor_args:
11573 
  """
11574 
  Attributes:
11575 
   - order_ids
11576 
   - vendorId
11577 
  """
11578 
 
11579 
  thrift_spec = (
11580 
    None, # 0
11581 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11582 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11583 
  )
11584 
 
11585 
  def __init__(self, order_ids=None, vendorId=None,):
11586 
    self.order_ids = order_ids
11587 
    self.vendorId = vendorId
11588 
 
11589 
  def read(self, iprot):
11590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11592 
      return
11593 
    iprot.readStructBegin()
11594 
    while True:
11595 
      (fname, ftype, fid) = iprot.readFieldBegin()
11596 
      if ftype == TType.STOP:
11597 
        break
11598 
      if fid == 1:
11599 
        if ftype == TType.LIST:
11600 
          self.order_ids = []
6188 rajveer 11601 
          (_etype228, _size225) = iprot.readListBegin()
11602 
          for _i229 in xrange(_size225):
11603 
            _elem230 = iprot.readI64();
11604 
            self.order_ids.append(_elem230)
5386 phani.kuma 11605 
          iprot.readListEnd()
11606 
        else:
11607 
          iprot.skip(ftype)
11608 
      elif fid == 2:
11609 
        if ftype == TType.I64:
11610 
          self.vendorId = iprot.readI64();
11611 
        else:
11612 
          iprot.skip(ftype)
11613 
      else:
11614 
        iprot.skip(ftype)
11615 
      iprot.readFieldEnd()
11616 
    iprot.readStructEnd()
11617 
 
11618 
  def write(self, oprot):
11619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11621 
      return
11622 
    oprot.writeStructBegin('getOrderListForVendor_args')
11623 
    if self.order_ids is not None:
11624 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11625 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11626 
      for iter231 in self.order_ids:
11627 
        oprot.writeI64(iter231)
5386 phani.kuma 11628 
      oprot.writeListEnd()
11629 
      oprot.writeFieldEnd()
11630 
    if self.vendorId is not None:
11631 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11632 
      oprot.writeI64(self.vendorId)
11633 
      oprot.writeFieldEnd()
11634 
    oprot.writeFieldStop()
11635 
    oprot.writeStructEnd()
11636 
 
11637 
  def validate(self):
11638 
    return
11639 
 
11640 
 
11641 
  def __repr__(self):
11642 
    L = ['%s=%r' % (key, value)
11643 
      for key, value in self.__dict__.iteritems()]
11644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11645 
 
11646 
  def __eq__(self, other):
11647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11648 
 
11649 
  def __ne__(self, other):
11650 
    return not (self == other)
11651 
 
11652 
class getOrderListForVendor_result:
11653 
  """
11654 
  Attributes:
11655 
   - success
11656 
  """
11657 
 
11658 
  thrift_spec = (
11659 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11660 
  )
11661 
 
11662 
  def __init__(self, success=None,):
11663 
    self.success = success
11664 
 
11665 
  def read(self, iprot):
11666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11668 
      return
11669 
    iprot.readStructBegin()
11670 
    while True:
11671 
      (fname, ftype, fid) = iprot.readFieldBegin()
11672 
      if ftype == TType.STOP:
11673 
        break
11674 
      if fid == 0:
11675 
        if ftype == TType.LIST:
11676 
          self.success = []
6188 rajveer 11677 
          (_etype235, _size232) = iprot.readListBegin()
11678 
          for _i236 in xrange(_size232):
11679 
            _elem237 = Order()
11680 
            _elem237.read(iprot)
11681 
            self.success.append(_elem237)
5386 phani.kuma 11682 
          iprot.readListEnd()
11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      else:
11686 
        iprot.skip(ftype)
11687 
      iprot.readFieldEnd()
11688 
    iprot.readStructEnd()
11689 
 
11690 
  def write(self, oprot):
11691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11693 
      return
11694 
    oprot.writeStructBegin('getOrderListForVendor_result')
11695 
    if self.success is not None:
11696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11698 
      for iter238 in self.success:
11699 
        iter238.write(oprot)
5386 phani.kuma 11700 
      oprot.writeListEnd()
11701 
      oprot.writeFieldEnd()
11702 
    oprot.writeFieldStop()
11703 
    oprot.writeStructEnd()
11704 
 
11705 
  def validate(self):
11706 
    return
11707 
 
11708 
 
11709 
  def __repr__(self):
11710 
    L = ['%s=%r' % (key, value)
11711 
      for key, value in self.__dict__.iteritems()]
11712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11713 
 
11714 
  def __eq__(self, other):
11715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11716 
 
11717 
  def __ne__(self, other):
11718 
    return not (self == other)
11719 
 
3064 chandransh 11720 
class getOrderForCustomer_args:
94 ashish 11721 
  """
11722 
  Attributes:
3064 chandransh 11723 
   - orderId
483 rajveer 11724 
   - customerId
94 ashish 11725 
  """
11726 
 
11727 
  thrift_spec = (
11728 
    None, # 0
3064 chandransh 11729 
    (1, TType.I64, 'orderId', None, None, ), # 1
11730 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11731 
  )
11732 
 
3064 chandransh 11733 
  def __init__(self, orderId=None, customerId=None,):
11734 
    self.orderId = orderId
483 rajveer 11735 
    self.customerId = customerId
94 ashish 11736 
 
11737 
  def read(self, iprot):
11738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11740 
      return
11741 
    iprot.readStructBegin()
11742 
    while True:
11743 
      (fname, ftype, fid) = iprot.readFieldBegin()
11744 
      if ftype == TType.STOP:
11745 
        break
11746 
      if fid == 1:
11747 
        if ftype == TType.I64:
3064 chandransh 11748 
          self.orderId = iprot.readI64();
94 ashish 11749 
        else:
11750 
          iprot.skip(ftype)
11751 
      elif fid == 2:
11752 
        if ftype == TType.I64:
3064 chandransh 11753 
          self.customerId = iprot.readI64();
94 ashish 11754 
        else:
11755 
          iprot.skip(ftype)
11756 
      else:
11757 
        iprot.skip(ftype)
11758 
      iprot.readFieldEnd()
11759 
    iprot.readStructEnd()
11760 
 
11761 
  def write(self, oprot):
11762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11764 
      return
3064 chandransh 11765 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11766 
    if self.orderId is not None:
3064 chandransh 11767 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11768 
      oprot.writeI64(self.orderId)
11769 
      oprot.writeFieldEnd()
3431 rajveer 11770 
    if self.customerId is not None:
3064 chandransh 11771 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11772 
      oprot.writeI64(self.customerId)
94 ashish 11773 
      oprot.writeFieldEnd()
11774 
    oprot.writeFieldStop()
11775 
    oprot.writeStructEnd()
11776 
 
3431 rajveer 11777 
  def validate(self):
11778 
    return
11779 
 
11780 
 
94 ashish 11781 
  def __repr__(self):
11782 
    L = ['%s=%r' % (key, value)
11783 
      for key, value in self.__dict__.iteritems()]
11784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11785 
 
11786 
  def __eq__(self, other):
11787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11788 
 
11789 
  def __ne__(self, other):
11790 
    return not (self == other)
11791 
 
3064 chandransh 11792 
class getOrderForCustomer_result:
94 ashish 11793 
  """
11794 
  Attributes:
11795 
   - success
11796 
   - ex
11797 
  """
11798 
 
11799 
  thrift_spec = (
3064 chandransh 11800 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11802 
  )
11803 
 
11804 
  def __init__(self, success=None, ex=None,):
11805 
    self.success = success
11806 
    self.ex = ex
11807 
 
11808 
  def read(self, iprot):
11809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11811 
      return
11812 
    iprot.readStructBegin()
11813 
    while True:
11814 
      (fname, ftype, fid) = iprot.readFieldBegin()
11815 
      if ftype == TType.STOP:
11816 
        break
11817 
      if fid == 0:
3064 chandransh 11818 
        if ftype == TType.STRUCT:
11819 
          self.success = Order()
11820 
          self.success.read(iprot)
94 ashish 11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      elif fid == 1:
11824 
        if ftype == TType.STRUCT:
11825 
          self.ex = TransactionServiceException()
11826 
          self.ex.read(iprot)
11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
3064 chandransh 11838 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11839 
    if self.success is not None:
3064 chandransh 11840 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11841 
      self.success.write(oprot)
94 ashish 11842 
      oprot.writeFieldEnd()
3431 rajveer 11843 
    if self.ex is not None:
94 ashish 11844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11845 
      self.ex.write(oprot)
11846 
      oprot.writeFieldEnd()
11847 
    oprot.writeFieldStop()
11848 
    oprot.writeStructEnd()
11849 
 
3431 rajveer 11850 
  def validate(self):
11851 
    return
11852 
 
11853 
 
94 ashish 11854 
  def __repr__(self):
11855 
    L = ['%s=%r' % (key, value)
11856 
      for key, value in self.__dict__.iteritems()]
11857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11858 
 
11859 
  def __eq__(self, other):
11860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11861 
 
11862 
  def __ne__(self, other):
11863 
    return not (self == other)
11864 
 
3064 chandransh 11865 
class getAlerts_args:
94 ashish 11866 
  """
11867 
  Attributes:
4394 rajveer 11868 
   - type
4444 rajveer 11869 
   - warehouseId
4394 rajveer 11870 
   - status
11871 
   - timestamp
94 ashish 11872 
  """
11873 
 
11874 
  thrift_spec = (
11875 
    None, # 0
4394 rajveer 11876 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11877 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11878 
    (3, TType.I64, 'status', None, None, ), # 3
11879 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11880 
  )
11881 
 
4444 rajveer 11882 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11883 
    self.type = type
4444 rajveer 11884 
    self.warehouseId = warehouseId
4394 rajveer 11885 
    self.status = status
11886 
    self.timestamp = timestamp
94 ashish 11887 
 
11888 
  def read(self, iprot):
11889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11891 
      return
11892 
    iprot.readStructBegin()
11893 
    while True:
11894 
      (fname, ftype, fid) = iprot.readFieldBegin()
11895 
      if ftype == TType.STOP:
11896 
        break
11897 
      if fid == 1:
3064 chandransh 11898 
        if ftype == TType.I64:
4394 rajveer 11899 
          self.type = iprot.readI64();
94 ashish 11900 
        else:
11901 
          iprot.skip(ftype)
3064 chandransh 11902 
      elif fid == 2:
4394 rajveer 11903 
        if ftype == TType.I64:
4444 rajveer 11904 
          self.warehouseId = iprot.readI64();
3064 chandransh 11905 
        else:
11906 
          iprot.skip(ftype)
4394 rajveer 11907 
      elif fid == 3:
11908 
        if ftype == TType.I64:
4444 rajveer 11909 
          self.status = iprot.readI64();
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      elif fid == 4:
11913 
        if ftype == TType.I64:
4394 rajveer 11914 
          self.timestamp = iprot.readI64();
11915 
        else:
11916 
          iprot.skip(ftype)
94 ashish 11917 
      else:
11918 
        iprot.skip(ftype)
11919 
      iprot.readFieldEnd()
11920 
    iprot.readStructEnd()
11921 
 
11922 
  def write(self, oprot):
11923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11925 
      return
3064 chandransh 11926 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11927 
    if self.type is not None:
11928 
      oprot.writeFieldBegin('type', TType.I64, 1)
11929 
      oprot.writeI64(self.type)
94 ashish 11930 
      oprot.writeFieldEnd()
4444 rajveer 11931 
    if self.warehouseId is not None:
11932 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11933 
      oprot.writeI64(self.warehouseId)
11934 
      oprot.writeFieldEnd()
4394 rajveer 11935 
    if self.status is not None:
4444 rajveer 11936 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11937 
      oprot.writeI64(self.status)
3064 chandransh 11938 
      oprot.writeFieldEnd()
4394 rajveer 11939 
    if self.timestamp is not None:
4444 rajveer 11940 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11941 
      oprot.writeI64(self.timestamp)
11942 
      oprot.writeFieldEnd()
94 ashish 11943 
    oprot.writeFieldStop()
11944 
    oprot.writeStructEnd()
11945 
 
3431 rajveer 11946 
  def validate(self):
11947 
    return
11948 
 
11949 
 
94 ashish 11950 
  def __repr__(self):
11951 
    L = ['%s=%r' % (key, value)
11952 
      for key, value in self.__dict__.iteritems()]
11953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11954 
 
11955 
  def __eq__(self, other):
11956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11957 
 
11958 
  def __ne__(self, other):
11959 
    return not (self == other)
11960 
 
3064 chandransh 11961 
class getAlerts_result:
94 ashish 11962 
  """
11963 
  Attributes:
11964 
   - success
11965 
  """
11966 
 
11967 
  thrift_spec = (
3064 chandransh 11968 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11969 
  )
11970 
 
3064 chandransh 11971 
  def __init__(self, success=None,):
94 ashish 11972 
    self.success = success
11973 
 
11974 
  def read(self, iprot):
11975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11977 
      return
11978 
    iprot.readStructBegin()
11979 
    while True:
11980 
      (fname, ftype, fid) = iprot.readFieldBegin()
11981 
      if ftype == TType.STOP:
11982 
        break
11983 
      if fid == 0:
3064 chandransh 11984 
        if ftype == TType.LIST:
11985 
          self.success = []
6188 rajveer 11986 
          (_etype242, _size239) = iprot.readListBegin()
11987 
          for _i243 in xrange(_size239):
11988 
            _elem244 = Alert()
11989 
            _elem244.read(iprot)
11990 
            self.success.append(_elem244)
3064 chandransh 11991 
          iprot.readListEnd()
94 ashish 11992 
        else:
11993 
          iprot.skip(ftype)
11994 
      else:
11995 
        iprot.skip(ftype)
11996 
      iprot.readFieldEnd()
11997 
    iprot.readStructEnd()
11998 
 
11999 
  def write(self, oprot):
12000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12002 
      return
3064 chandransh 12003 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12004 
    if self.success is not None:
3064 chandransh 12005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12007 
      for iter245 in self.success:
12008 
        iter245.write(oprot)
3064 chandransh 12009 
      oprot.writeListEnd()
94 ashish 12010 
      oprot.writeFieldEnd()
12011 
    oprot.writeFieldStop()
12012 
    oprot.writeStructEnd()
12013 
 
3431 rajveer 12014 
  def validate(self):
12015 
    return
12016 
 
12017 
 
94 ashish 12018 
  def __repr__(self):
12019 
    L = ['%s=%r' % (key, value)
12020 
      for key, value in self.__dict__.iteritems()]
12021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12022 
 
12023 
  def __eq__(self, other):
12024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12025 
 
12026 
  def __ne__(self, other):
12027 
    return not (self == other)
12028 
 
4394 rajveer 12029 
class addAlert_args:
94 ashish 12030 
  """
12031 
  Attributes:
3064 chandransh 12032 
   - type
4444 rajveer 12033 
   - warehouseId
4394 rajveer 12034 
   - description
94 ashish 12035 
  """
12036 
 
12037 
  thrift_spec = (
12038 
    None, # 0
4394 rajveer 12039 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12040 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12041 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12042 
  )
12043 
 
4444 rajveer 12044 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12045 
    self.type = type
4444 rajveer 12046 
    self.warehouseId = warehouseId
4394 rajveer 12047 
    self.description = description
94 ashish 12048 
 
12049 
  def read(self, iprot):
12050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12052 
      return
12053 
    iprot.readStructBegin()
12054 
    while True:
12055 
      (fname, ftype, fid) = iprot.readFieldBegin()
12056 
      if ftype == TType.STOP:
12057 
        break
12058 
      if fid == 1:
12059 
        if ftype == TType.I64:
4394 rajveer 12060 
          self.type = iprot.readI64();
94 ashish 12061 
        else:
12062 
          iprot.skip(ftype)
3064 chandransh 12063 
      elif fid == 2:
4444 rajveer 12064 
        if ftype == TType.I64:
12065 
          self.warehouseId = iprot.readI64();
12066 
        else:
12067 
          iprot.skip(ftype)
12068 
      elif fid == 3:
3064 chandransh 12069 
        if ftype == TType.STRING:
4394 rajveer 12070 
          self.description = iprot.readString();
3064 chandransh 12071 
        else:
12072 
          iprot.skip(ftype)
94 ashish 12073 
      else:
12074 
        iprot.skip(ftype)
12075 
      iprot.readFieldEnd()
12076 
    iprot.readStructEnd()
12077 
 
12078 
  def write(self, oprot):
12079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12081 
      return
4394 rajveer 12082 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12083 
    if self.type is not None:
4394 rajveer 12084 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12085 
      oprot.writeI64(self.type)
12086 
      oprot.writeFieldEnd()
4444 rajveer 12087 
    if self.warehouseId is not None:
12088 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12089 
      oprot.writeI64(self.warehouseId)
12090 
      oprot.writeFieldEnd()
4394 rajveer 12091 
    if self.description is not None:
4444 rajveer 12092 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12093 
      oprot.writeString(self.description)
3064 chandransh 12094 
      oprot.writeFieldEnd()
94 ashish 12095 
    oprot.writeFieldStop()
12096 
    oprot.writeStructEnd()
12097 
 
3431 rajveer 12098 
  def validate(self):
12099 
    return
12100 
 
12101 
 
94 ashish 12102 
  def __repr__(self):
12103 
    L = ['%s=%r' % (key, value)
12104 
      for key, value in self.__dict__.iteritems()]
12105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12106 
 
12107 
  def __eq__(self, other):
12108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12109 
 
12110 
  def __ne__(self, other):
12111 
    return not (self == other)
12112 
 
4394 rajveer 12113 
class addAlert_result:
3064 chandransh 12114 
 
12115 
  thrift_spec = (
12116 
  )
12117 
 
12118 
  def read(self, iprot):
12119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12121 
      return
12122 
    iprot.readStructBegin()
12123 
    while True:
12124 
      (fname, ftype, fid) = iprot.readFieldBegin()
12125 
      if ftype == TType.STOP:
12126 
        break
12127 
      else:
12128 
        iprot.skip(ftype)
12129 
      iprot.readFieldEnd()
12130 
    iprot.readStructEnd()
12131 
 
12132 
  def write(self, oprot):
12133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12135 
      return
4394 rajveer 12136 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12137 
    oprot.writeFieldStop()
12138 
    oprot.writeStructEnd()
12139 
 
3431 rajveer 12140 
  def validate(self):
12141 
    return
12142 
 
12143 
 
3064 chandransh 12144 
  def __repr__(self):
12145 
    L = ['%s=%r' % (key, value)
12146 
      for key, value in self.__dict__.iteritems()]
12147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12148 
 
12149 
  def __eq__(self, other):
12150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12151 
 
12152 
  def __ne__(self, other):
12153 
    return not (self == other)
12154 
 
4444 rajveer 12155 
class markAlertsAsSeen_args:
12156 
  """
12157 
  Attributes:
12158 
   - warehouseId
12159 
  """
12160 
 
12161 
  thrift_spec = (
12162 
    None, # 0
12163 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12164 
  )
12165 
 
12166 
  def __init__(self, warehouseId=None,):
12167 
    self.warehouseId = warehouseId
12168 
 
12169 
  def read(self, iprot):
12170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12172 
      return
12173 
    iprot.readStructBegin()
12174 
    while True:
12175 
      (fname, ftype, fid) = iprot.readFieldBegin()
12176 
      if ftype == TType.STOP:
12177 
        break
12178 
      if fid == 1:
12179 
        if ftype == TType.I64:
12180 
          self.warehouseId = iprot.readI64();
12181 
        else:
12182 
          iprot.skip(ftype)
12183 
      else:
12184 
        iprot.skip(ftype)
12185 
      iprot.readFieldEnd()
12186 
    iprot.readStructEnd()
12187 
 
12188 
  def write(self, oprot):
12189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12191 
      return
12192 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12193 
    if self.warehouseId is not None:
12194 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12195 
      oprot.writeI64(self.warehouseId)
12196 
      oprot.writeFieldEnd()
12197 
    oprot.writeFieldStop()
12198 
    oprot.writeStructEnd()
12199 
 
12200 
  def validate(self):
12201 
    return
12202 
 
12203 
 
12204 
  def __repr__(self):
12205 
    L = ['%s=%r' % (key, value)
12206 
      for key, value in self.__dict__.iteritems()]
12207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12208 
 
12209 
  def __eq__(self, other):
12210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12211 
 
12212 
  def __ne__(self, other):
12213 
    return not (self == other)
12214 
 
12215 
class markAlertsAsSeen_result:
12216 
 
12217 
  thrift_spec = (
12218 
  )
12219 
 
12220 
  def read(self, iprot):
12221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12223 
      return
12224 
    iprot.readStructBegin()
12225 
    while True:
12226 
      (fname, ftype, fid) = iprot.readFieldBegin()
12227 
      if ftype == TType.STOP:
12228 
        break
12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
12238 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12239 
    oprot.writeFieldStop()
12240 
    oprot.writeStructEnd()
12241 
 
12242 
  def validate(self):
12243 
    return
12244 
 
12245 
 
12246 
  def __repr__(self):
12247 
    L = ['%s=%r' % (key, value)
12248 
      for key, value in self.__dict__.iteritems()]
12249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12250 
 
12251 
  def __eq__(self, other):
12252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12253 
 
12254 
  def __ne__(self, other):
12255 
    return not (self == other)
12256 
 
3064 chandransh 12257 
class getValidOrderCount_args:
12258 
 
12259 
  thrift_spec = (
12260 
  )
12261 
 
12262 
  def read(self, iprot):
12263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12265 
      return
12266 
    iprot.readStructBegin()
12267 
    while True:
12268 
      (fname, ftype, fid) = iprot.readFieldBegin()
12269 
      if ftype == TType.STOP:
12270 
        break
12271 
      else:
12272 
        iprot.skip(ftype)
12273 
      iprot.readFieldEnd()
12274 
    iprot.readStructEnd()
12275 
 
12276 
  def write(self, oprot):
12277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12279 
      return
12280 
    oprot.writeStructBegin('getValidOrderCount_args')
12281 
    oprot.writeFieldStop()
12282 
    oprot.writeStructEnd()
12283 
 
3431 rajveer 12284 
  def validate(self):
12285 
    return
12286 
 
12287 
 
3064 chandransh 12288 
  def __repr__(self):
12289 
    L = ['%s=%r' % (key, value)
12290 
      for key, value in self.__dict__.iteritems()]
12291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12292 
 
12293 
  def __eq__(self, other):
12294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12295 
 
12296 
  def __ne__(self, other):
12297 
    return not (self == other)
12298 
 
12299 
class getValidOrderCount_result:
94 ashish 12300 
  """
12301 
  Attributes:
12302 
   - success
12303 
  """
12304 
 
12305 
  thrift_spec = (
3064 chandransh 12306 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12307 
  )
12308 
 
3064 chandransh 12309 
  def __init__(self, success=None,):
94 ashish 12310 
    self.success = success
12311 
 
12312 
  def read(self, iprot):
12313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12315 
      return
12316 
    iprot.readStructBegin()
12317 
    while True:
12318 
      (fname, ftype, fid) = iprot.readFieldBegin()
12319 
      if ftype == TType.STOP:
12320 
        break
12321 
      if fid == 0:
3064 chandransh 12322 
        if ftype == TType.I64:
12323 
          self.success = iprot.readI64();
94 ashish 12324 
        else:
12325 
          iprot.skip(ftype)
12326 
      else:
12327 
        iprot.skip(ftype)
12328 
      iprot.readFieldEnd()
12329 
    iprot.readStructEnd()
12330 
 
12331 
  def write(self, oprot):
12332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12334 
      return
3064 chandransh 12335 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12336 
    if self.success is not None:
3064 chandransh 12337 
      oprot.writeFieldBegin('success', TType.I64, 0)
12338 
      oprot.writeI64(self.success)
94 ashish 12339 
      oprot.writeFieldEnd()
12340 
    oprot.writeFieldStop()
12341 
    oprot.writeStructEnd()
12342 
 
3431 rajveer 12343 
  def validate(self):
12344 
    return
12345 
 
12346 
 
94 ashish 12347 
  def __repr__(self):
12348 
    L = ['%s=%r' % (key, value)
12349 
      for key, value in self.__dict__.iteritems()]
12350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12351 
 
12352 
  def __eq__(self, other):
12353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12354 
 
12355 
  def __ne__(self, other):
12356 
    return not (self == other)
12357 
 
3064 chandransh 12358 
class getNoOfCustomersWithSuccessfulTransaction_args:
12359 
 
12360 
  thrift_spec = (
12361 
  )
12362 
 
12363 
  def read(self, iprot):
12364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12366 
      return
12367 
    iprot.readStructBegin()
12368 
    while True:
12369 
      (fname, ftype, fid) = iprot.readFieldBegin()
12370 
      if ftype == TType.STOP:
12371 
        break
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
12381 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12382 
    oprot.writeFieldStop()
12383 
    oprot.writeStructEnd()
12384 
 
3431 rajveer 12385 
  def validate(self):
12386 
    return
12387 
 
12388 
 
3064 chandransh 12389 
  def __repr__(self):
12390 
    L = ['%s=%r' % (key, value)
12391 
      for key, value in self.__dict__.iteritems()]
12392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12393 
 
12394 
  def __eq__(self, other):
12395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12396 
 
12397 
  def __ne__(self, other):
12398 
    return not (self == other)
12399 
 
12400 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12401 
  """
12402 
  Attributes:
3064 chandransh 12403 
   - success
94 ashish 12404 
  """
12405 
 
12406 
  thrift_spec = (
3064 chandransh 12407 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12408 
  )
12409 
 
3064 chandransh 12410 
  def __init__(self, success=None,):
12411 
    self.success = success
94 ashish 12412 
 
12413 
  def read(self, iprot):
12414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12416 
      return
12417 
    iprot.readStructBegin()
12418 
    while True:
12419 
      (fname, ftype, fid) = iprot.readFieldBegin()
12420 
      if ftype == TType.STOP:
12421 
        break
3064 chandransh 12422 
      if fid == 0:
94 ashish 12423 
        if ftype == TType.I64:
3064 chandransh 12424 
          self.success = iprot.readI64();
94 ashish 12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      else:
12428 
        iprot.skip(ftype)
12429 
      iprot.readFieldEnd()
12430 
    iprot.readStructEnd()
12431 
 
12432 
  def write(self, oprot):
12433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12435 
      return
3064 chandransh 12436 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12437 
    if self.success is not None:
3064 chandransh 12438 
      oprot.writeFieldBegin('success', TType.I64, 0)
12439 
      oprot.writeI64(self.success)
94 ashish 12440 
      oprot.writeFieldEnd()
12441 
    oprot.writeFieldStop()
12442 
    oprot.writeStructEnd()
12443 
 
3431 rajveer 12444 
  def validate(self):
12445 
    return
12446 
 
12447 
 
94 ashish 12448 
  def __repr__(self):
12449 
    L = ['%s=%r' % (key, value)
12450 
      for key, value in self.__dict__.iteritems()]
12451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12452 
 
12453 
  def __eq__(self, other):
12454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12455 
 
12456 
  def __ne__(self, other):
12457 
    return not (self == other)
12458 
 
3064 chandransh 12459 
class getValidOrdersAmountRange_args:
12460 
 
12461 
  thrift_spec = (
12462 
  )
12463 
 
12464 
  def read(self, iprot):
12465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12467 
      return
12468 
    iprot.readStructBegin()
12469 
    while True:
12470 
      (fname, ftype, fid) = iprot.readFieldBegin()
12471 
      if ftype == TType.STOP:
12472 
        break
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12483 
    oprot.writeFieldStop()
12484 
    oprot.writeStructEnd()
12485 
 
3431 rajveer 12486 
  def validate(self):
12487 
    return
12488 
 
12489 
 
3064 chandransh 12490 
  def __repr__(self):
12491 
    L = ['%s=%r' % (key, value)
12492 
      for key, value in self.__dict__.iteritems()]
12493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12494 
 
12495 
  def __eq__(self, other):
12496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12497 
 
12498 
  def __ne__(self, other):
12499 
    return not (self == other)
12500 
 
12501 
class getValidOrdersAmountRange_result:
94 ashish 12502 
  """
12503 
  Attributes:
12504 
   - success
12505 
  """
12506 
 
12507 
  thrift_spec = (
3064 chandransh 12508 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12509 
  )
12510 
 
3064 chandransh 12511 
  def __init__(self, success=None,):
94 ashish 12512 
    self.success = success
12513 
 
12514 
  def read(self, iprot):
12515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12517 
      return
12518 
    iprot.readStructBegin()
12519 
    while True:
12520 
      (fname, ftype, fid) = iprot.readFieldBegin()
12521 
      if ftype == TType.STOP:
12522 
        break
12523 
      if fid == 0:
483 rajveer 12524 
        if ftype == TType.LIST:
12525 
          self.success = []
6188 rajveer 12526 
          (_etype249, _size246) = iprot.readListBegin()
12527 
          for _i250 in xrange(_size246):
12528 
            _elem251 = iprot.readDouble();
12529 
            self.success.append(_elem251)
483 rajveer 12530 
          iprot.readListEnd()
94 ashish 12531 
        else:
12532 
          iprot.skip(ftype)
12533 
      else:
12534 
        iprot.skip(ftype)
12535 
      iprot.readFieldEnd()
12536 
    iprot.readStructEnd()
12537 
 
12538 
  def write(self, oprot):
12539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12541 
      return
3064 chandransh 12542 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12543 
    if self.success is not None:
483 rajveer 12544 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12545 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12546 
      for iter252 in self.success:
12547 
        oprot.writeDouble(iter252)
483 rajveer 12548 
      oprot.writeListEnd()
94 ashish 12549 
      oprot.writeFieldEnd()
12550 
    oprot.writeFieldStop()
12551 
    oprot.writeStructEnd()
12552 
 
3431 rajveer 12553 
  def validate(self):
12554 
    return
12555 
 
12556 
 
94 ashish 12557 
  def __repr__(self):
12558 
    L = ['%s=%r' % (key, value)
12559 
      for key, value in self.__dict__.iteritems()]
12560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12561 
 
12562 
  def __eq__(self, other):
12563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12564 
 
12565 
  def __ne__(self, other):
12566 
    return not (self == other)
12567 
 
3064 chandransh 12568 
class getValidOrders_args:
1528 ankur.sing 12569 
  """
12570 
  Attributes:
3064 chandransh 12571 
   - limit
5874 rajveer 12572 
   - onlyStore
1528 ankur.sing 12573 
  """
12574 
 
12575 
  thrift_spec = (
12576 
    None, # 0
3064 chandransh 12577 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12578 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12579 
  )
12580 
 
5874 rajveer 12581 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12582 
    self.limit = limit
5874 rajveer 12583 
    self.onlyStore = onlyStore
1528 ankur.sing 12584 
 
12585 
  def read(self, iprot):
12586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12588 
      return
12589 
    iprot.readStructBegin()
12590 
    while True:
12591 
      (fname, ftype, fid) = iprot.readFieldBegin()
12592 
      if ftype == TType.STOP:
12593 
        break
12594 
      if fid == 1:
12595 
        if ftype == TType.I64:
3064 chandransh 12596 
          self.limit = iprot.readI64();
1528 ankur.sing 12597 
        else:
12598 
          iprot.skip(ftype)
5874 rajveer 12599 
      elif fid == 2:
12600 
        if ftype == TType.BOOL:
12601 
          self.onlyStore = iprot.readBool();
12602 
        else:
12603 
          iprot.skip(ftype)
1528 ankur.sing 12604 
      else:
12605 
        iprot.skip(ftype)
12606 
      iprot.readFieldEnd()
12607 
    iprot.readStructEnd()
12608 
 
12609 
  def write(self, oprot):
12610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12612 
      return
3064 chandransh 12613 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12614 
    if self.limit is not None:
3064 chandransh 12615 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12616 
      oprot.writeI64(self.limit)
1528 ankur.sing 12617 
      oprot.writeFieldEnd()
5874 rajveer 12618 
    if self.onlyStore is not None:
12619 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12620 
      oprot.writeBool(self.onlyStore)
12621 
      oprot.writeFieldEnd()
1528 ankur.sing 12622 
    oprot.writeFieldStop()
12623 
    oprot.writeStructEnd()
12624 
 
3431 rajveer 12625 
  def validate(self):
12626 
    return
12627 
 
12628 
 
1528 ankur.sing 12629 
  def __repr__(self):
12630 
    L = ['%s=%r' % (key, value)
12631 
      for key, value in self.__dict__.iteritems()]
12632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12633 
 
12634 
  def __eq__(self, other):
12635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12636 
 
12637 
  def __ne__(self, other):
12638 
    return not (self == other)
12639 
 
3064 chandransh 12640 
class getValidOrders_result:
1528 ankur.sing 12641 
  """
12642 
  Attributes:
12643 
   - success
12644 
  """
12645 
 
12646 
  thrift_spec = (
3064 chandransh 12647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12648 
  )
12649 
 
3064 chandransh 12650 
  def __init__(self, success=None,):
1528 ankur.sing 12651 
    self.success = success
12652 
 
12653 
  def read(self, iprot):
12654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12656 
      return
12657 
    iprot.readStructBegin()
12658 
    while True:
12659 
      (fname, ftype, fid) = iprot.readFieldBegin()
12660 
      if ftype == TType.STOP:
12661 
        break
12662 
      if fid == 0:
3064 chandransh 12663 
        if ftype == TType.LIST:
12664 
          self.success = []
6188 rajveer 12665 
          (_etype256, _size253) = iprot.readListBegin()
12666 
          for _i257 in xrange(_size253):
12667 
            _elem258 = Order()
12668 
            _elem258.read(iprot)
12669 
            self.success.append(_elem258)
3064 chandransh 12670 
          iprot.readListEnd()
1528 ankur.sing 12671 
        else:
12672 
          iprot.skip(ftype)
12673 
      else:
12674 
        iprot.skip(ftype)
12675 
      iprot.readFieldEnd()
12676 
    iprot.readStructEnd()
12677 
 
12678 
  def write(self, oprot):
12679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12681 
      return
3064 chandransh 12682 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12683 
    if self.success is not None:
3064 chandransh 12684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12686 
      for iter259 in self.success:
12687 
        iter259.write(oprot)
3064 chandransh 12688 
      oprot.writeListEnd()
1528 ankur.sing 12689 
      oprot.writeFieldEnd()
12690 
    oprot.writeFieldStop()
12691 
    oprot.writeStructEnd()
12692 
 
3431 rajveer 12693 
  def validate(self):
12694 
    return
12695 
 
12696 
 
1528 ankur.sing 12697 
  def __repr__(self):
12698 
    L = ['%s=%r' % (key, value)
12699 
      for key, value in self.__dict__.iteritems()]
12700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12701 
 
12702 
  def __eq__(self, other):
12703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12704 
 
12705 
  def __ne__(self, other):
12706 
    return not (self == other)
12707 
 
1220 chandransh 12708 
class batchOrders_args:
12709 
  """
12710 
  Attributes:
12711 
   - warehouseId
12712 
  """
12713 
 
12714 
  thrift_spec = (
12715 
    None, # 0
12716 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12717 
  )
12718 
 
12719 
  def __init__(self, warehouseId=None,):
12720 
    self.warehouseId = warehouseId
12721 
 
12722 
  def read(self, iprot):
12723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12725 
      return
12726 
    iprot.readStructBegin()
12727 
    while True:
12728 
      (fname, ftype, fid) = iprot.readFieldBegin()
12729 
      if ftype == TType.STOP:
12730 
        break
12731 
      if fid == 1:
12732 
        if ftype == TType.I64:
12733 
          self.warehouseId = iprot.readI64();
12734 
        else:
12735 
          iprot.skip(ftype)
12736 
      else:
12737 
        iprot.skip(ftype)
12738 
      iprot.readFieldEnd()
12739 
    iprot.readStructEnd()
12740 
 
12741 
  def write(self, oprot):
12742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12744 
      return
12745 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12746 
    if self.warehouseId is not None:
1220 chandransh 12747 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12748 
      oprot.writeI64(self.warehouseId)
12749 
      oprot.writeFieldEnd()
12750 
    oprot.writeFieldStop()
12751 
    oprot.writeStructEnd()
12752 
 
3431 rajveer 12753 
  def validate(self):
12754 
    return
12755 
 
12756 
 
1220 chandransh 12757 
  def __repr__(self):
12758 
    L = ['%s=%r' % (key, value)
12759 
      for key, value in self.__dict__.iteritems()]
12760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12761 
 
12762 
  def __eq__(self, other):
12763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12764 
 
12765 
  def __ne__(self, other):
12766 
    return not (self == other)
12767 
 
12768 
class batchOrders_result:
12769 
  """
12770 
  Attributes:
12771 
   - success
12772 
   - ex
12773 
  """
12774 
 
12775 
  thrift_spec = (
12776 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12778 
  )
12779 
 
12780 
  def __init__(self, success=None, ex=None,):
12781 
    self.success = success
12782 
    self.ex = ex
12783 
 
12784 
  def read(self, iprot):
12785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12787 
      return
12788 
    iprot.readStructBegin()
12789 
    while True:
12790 
      (fname, ftype, fid) = iprot.readFieldBegin()
12791 
      if ftype == TType.STOP:
12792 
        break
12793 
      if fid == 0:
12794 
        if ftype == TType.LIST:
12795 
          self.success = []
6188 rajveer 12796 
          (_etype263, _size260) = iprot.readListBegin()
12797 
          for _i264 in xrange(_size260):
12798 
            _elem265 = Order()
12799 
            _elem265.read(iprot)
12800 
            self.success.append(_elem265)
1220 chandransh 12801 
          iprot.readListEnd()
12802 
        else:
12803 
          iprot.skip(ftype)
12804 
      elif fid == 1:
12805 
        if ftype == TType.STRUCT:
12806 
          self.ex = TransactionServiceException()
12807 
          self.ex.read(iprot)
12808 
        else:
12809 
          iprot.skip(ftype)
12810 
      else:
12811 
        iprot.skip(ftype)
12812 
      iprot.readFieldEnd()
12813 
    iprot.readStructEnd()
12814 
 
12815 
  def write(self, oprot):
12816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12818 
      return
12819 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12820 
    if self.success is not None:
1220 chandransh 12821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12823 
      for iter266 in self.success:
12824 
        iter266.write(oprot)
1220 chandransh 12825 
      oprot.writeListEnd()
12826 
      oprot.writeFieldEnd()
3431 rajveer 12827 
    if self.ex is not None:
1220 chandransh 12828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12829 
      self.ex.write(oprot)
12830 
      oprot.writeFieldEnd()
12831 
    oprot.writeFieldStop()
12832 
    oprot.writeStructEnd()
12833 
 
3431 rajveer 12834 
  def validate(self):
12835 
    return
12836 
 
12837 
 
1220 chandransh 12838 
  def __repr__(self):
12839 
    L = ['%s=%r' % (key, value)
12840 
      for key, value in self.__dict__.iteritems()]
12841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12842 
 
12843 
  def __eq__(self, other):
12844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12845 
 
12846 
  def __ne__(self, other):
12847 
    return not (self == other)
12848 
 
1208 chandransh 12849 
class markOrderAsOutOfStock_args:
12850 
  """
12851 
  Attributes:
12852 
   - orderId
12853 
  """
12854 
 
12855 
  thrift_spec = (
12856 
    None, # 0
12857 
    (1, TType.I64, 'orderId', None, None, ), # 1
12858 
  )
12859 
 
12860 
  def __init__(self, orderId=None,):
12861 
    self.orderId = orderId
12862 
 
12863 
  def read(self, iprot):
12864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12866 
      return
12867 
    iprot.readStructBegin()
12868 
    while True:
12869 
      (fname, ftype, fid) = iprot.readFieldBegin()
12870 
      if ftype == TType.STOP:
12871 
        break
12872 
      if fid == 1:
12873 
        if ftype == TType.I64:
12874 
          self.orderId = iprot.readI64();
12875 
        else:
12876 
          iprot.skip(ftype)
12877 
      else:
12878 
        iprot.skip(ftype)
12879 
      iprot.readFieldEnd()
12880 
    iprot.readStructEnd()
12881 
 
12882 
  def write(self, oprot):
12883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12885 
      return
12886 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12887 
    if self.orderId is not None:
1208 chandransh 12888 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12889 
      oprot.writeI64(self.orderId)
12890 
      oprot.writeFieldEnd()
12891 
    oprot.writeFieldStop()
12892 
    oprot.writeStructEnd()
12893 
 
3431 rajveer 12894 
  def validate(self):
12895 
    return
12896 
 
12897 
 
1208 chandransh 12898 
  def __repr__(self):
12899 
    L = ['%s=%r' % (key, value)
12900 
      for key, value in self.__dict__.iteritems()]
12901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12902 
 
12903 
  def __eq__(self, other):
12904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12905 
 
12906 
  def __ne__(self, other):
12907 
    return not (self == other)
12908 
 
12909 
class markOrderAsOutOfStock_result:
12910 
  """
12911 
  Attributes:
12912 
   - success
12913 
   - ex
12914 
  """
12915 
 
12916 
  thrift_spec = (
12917 
    (0, TType.BOOL, 'success', None, None, ), # 0
12918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12919 
  )
12920 
 
12921 
  def __init__(self, success=None, ex=None,):
12922 
    self.success = success
12923 
    self.ex = ex
12924 
 
12925 
  def read(self, iprot):
12926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12928 
      return
12929 
    iprot.readStructBegin()
12930 
    while True:
12931 
      (fname, ftype, fid) = iprot.readFieldBegin()
12932 
      if ftype == TType.STOP:
12933 
        break
12934 
      if fid == 0:
12935 
        if ftype == TType.BOOL:
12936 
          self.success = iprot.readBool();
12937 
        else:
12938 
          iprot.skip(ftype)
12939 
      elif fid == 1:
12940 
        if ftype == TType.STRUCT:
12941 
          self.ex = TransactionServiceException()
12942 
          self.ex.read(iprot)
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      else:
12946 
        iprot.skip(ftype)
12947 
      iprot.readFieldEnd()
12948 
    iprot.readStructEnd()
12949 
 
12950 
  def write(self, oprot):
12951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12953 
      return
12954 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12955 
    if self.success is not None:
1208 chandransh 12956 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12957 
      oprot.writeBool(self.success)
12958 
      oprot.writeFieldEnd()
3431 rajveer 12959 
    if self.ex is not None:
1208 chandransh 12960 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12961 
      self.ex.write(oprot)
12962 
      oprot.writeFieldEnd()
12963 
    oprot.writeFieldStop()
12964 
    oprot.writeStructEnd()
12965 
 
3431 rajveer 12966 
  def validate(self):
12967 
    return
12968 
 
12969 
 
1208 chandransh 12970 
  def __repr__(self):
12971 
    L = ['%s=%r' % (key, value)
12972 
      for key, value in self.__dict__.iteritems()]
12973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12974 
 
12975 
  def __eq__(self, other):
12976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12977 
 
12978 
  def __ne__(self, other):
12979 
    return not (self == other)
12980 
 
3064 chandransh 12981 
class verifyOrder_args:
759 chandransh 12982 
  """
12983 
  Attributes:
3064 chandransh 12984 
   - orderId
759 chandransh 12985 
  """
12986 
 
12987 
  thrift_spec = (
12988 
    None, # 0
3064 chandransh 12989 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12990 
  )
12991 
 
3064 chandransh 12992 
  def __init__(self, orderId=None,):
12993 
    self.orderId = orderId
759 chandransh 12994 
 
12995 
  def read(self, iprot):
12996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12998 
      return
12999 
    iprot.readStructBegin()
13000 
    while True:
13001 
      (fname, ftype, fid) = iprot.readFieldBegin()
13002 
      if ftype == TType.STOP:
13003 
        break
13004 
      if fid == 1:
13005 
        if ftype == TType.I64:
3064 chandransh 13006 
          self.orderId = iprot.readI64();
759 chandransh 13007 
        else:
13008 
          iprot.skip(ftype)
13009 
      else:
13010 
        iprot.skip(ftype)
13011 
      iprot.readFieldEnd()
13012 
    iprot.readStructEnd()
13013 
 
13014 
  def write(self, oprot):
13015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13017 
      return
3064 chandransh 13018 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13019 
    if self.orderId is not None:
3064 chandransh 13020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13021 
      oprot.writeI64(self.orderId)
759 chandransh 13022 
      oprot.writeFieldEnd()
13023 
    oprot.writeFieldStop()
13024 
    oprot.writeStructEnd()
13025 
 
3431 rajveer 13026 
  def validate(self):
13027 
    return
13028 
 
13029 
 
759 chandransh 13030 
  def __repr__(self):
13031 
    L = ['%s=%r' % (key, value)
13032 
      for key, value in self.__dict__.iteritems()]
13033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13034 
 
13035 
  def __eq__(self, other):
13036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13037 
 
13038 
  def __ne__(self, other):
13039 
    return not (self == other)
13040 
 
3064 chandransh 13041 
class verifyOrder_result:
759 chandransh 13042 
  """
13043 
  Attributes:
13044 
   - success
13045 
   - ex
13046 
  """
13047 
 
13048 
  thrift_spec = (
13049 
    (0, TType.BOOL, 'success', None, None, ), # 0
13050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13051 
  )
13052 
 
13053 
  def __init__(self, success=None, ex=None,):
13054 
    self.success = success
13055 
    self.ex = ex
13056 
 
13057 
  def read(self, iprot):
13058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13060 
      return
13061 
    iprot.readStructBegin()
13062 
    while True:
13063 
      (fname, ftype, fid) = iprot.readFieldBegin()
13064 
      if ftype == TType.STOP:
13065 
        break
13066 
      if fid == 0:
13067 
        if ftype == TType.BOOL:
13068 
          self.success = iprot.readBool();
13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      elif fid == 1:
13072 
        if ftype == TType.STRUCT:
13073 
          self.ex = TransactionServiceException()
13074 
          self.ex.read(iprot)
13075 
        else:
13076 
          iprot.skip(ftype)
13077 
      else:
13078 
        iprot.skip(ftype)
13079 
      iprot.readFieldEnd()
13080 
    iprot.readStructEnd()
13081 
 
13082 
  def write(self, oprot):
13083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13085 
      return
3064 chandransh 13086 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13087 
    if self.success is not None:
759 chandransh 13088 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13089 
      oprot.writeBool(self.success)
13090 
      oprot.writeFieldEnd()
3431 rajveer 13091 
    if self.ex is not None:
759 chandransh 13092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13093 
      self.ex.write(oprot)
13094 
      oprot.writeFieldEnd()
13095 
    oprot.writeFieldStop()
13096 
    oprot.writeStructEnd()
13097 
 
3431 rajveer 13098 
  def validate(self):
13099 
    return
13100 
 
13101 
 
759 chandransh 13102 
  def __repr__(self):
13103 
    L = ['%s=%r' % (key, value)
13104 
      for key, value in self.__dict__.iteritems()]
13105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13106 
 
13107 
  def __eq__(self, other):
13108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13109 
 
13110 
  def __ne__(self, other):
13111 
    return not (self == other)
13112 
 
3064 chandransh 13113 
class acceptOrder_args:
1113 chandransh 13114 
  """
13115 
  Attributes:
3064 chandransh 13116 
   - orderId
1113 chandransh 13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
3064 chandransh 13121 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13122 
  )
13123 
 
3064 chandransh 13124 
  def __init__(self, orderId=None,):
13125 
    self.orderId = orderId
1113 chandransh 13126 
 
13127 
  def read(self, iprot):
13128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13130 
      return
13131 
    iprot.readStructBegin()
13132 
    while True:
13133 
      (fname, ftype, fid) = iprot.readFieldBegin()
13134 
      if ftype == TType.STOP:
13135 
        break
13136 
      if fid == 1:
13137 
        if ftype == TType.I64:
3064 chandransh 13138 
          self.orderId = iprot.readI64();
1113 chandransh 13139 
        else:
13140 
          iprot.skip(ftype)
13141 
      else:
13142 
        iprot.skip(ftype)
13143 
      iprot.readFieldEnd()
13144 
    iprot.readStructEnd()
13145 
 
13146 
  def write(self, oprot):
13147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13149 
      return
3064 chandransh 13150 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13151 
    if self.orderId is not None:
3064 chandransh 13152 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13153 
      oprot.writeI64(self.orderId)
1113 chandransh 13154 
      oprot.writeFieldEnd()
13155 
    oprot.writeFieldStop()
13156 
    oprot.writeStructEnd()
13157 
 
3431 rajveer 13158 
  def validate(self):
13159 
    return
13160 
 
13161 
 
1113 chandransh 13162 
  def __repr__(self):
13163 
    L = ['%s=%r' % (key, value)
13164 
      for key, value in self.__dict__.iteritems()]
13165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13166 
 
13167 
  def __eq__(self, other):
13168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13169 
 
13170 
  def __ne__(self, other):
13171 
    return not (self == other)
13172 
 
3064 chandransh 13173 
class acceptOrder_result:
1113 chandransh 13174 
  """
13175 
  Attributes:
13176 
   - success
13177 
   - ex
13178 
  """
13179 
 
13180 
  thrift_spec = (
3064 chandransh 13181 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13183 
  )
13184 
 
13185 
  def __init__(self, success=None, ex=None,):
13186 
    self.success = success
13187 
    self.ex = ex
13188 
 
13189 
  def read(self, iprot):
13190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13192 
      return
13193 
    iprot.readStructBegin()
13194 
    while True:
13195 
      (fname, ftype, fid) = iprot.readFieldBegin()
13196 
      if ftype == TType.STOP:
13197 
        break
13198 
      if fid == 0:
3064 chandransh 13199 
        if ftype == TType.BOOL:
13200 
          self.success = iprot.readBool();
1113 chandransh 13201 
        else:
13202 
          iprot.skip(ftype)
13203 
      elif fid == 1:
13204 
        if ftype == TType.STRUCT:
13205 
          self.ex = TransactionServiceException()
13206 
          self.ex.read(iprot)
13207 
        else:
13208 
          iprot.skip(ftype)
13209 
      else:
13210 
        iprot.skip(ftype)
13211 
      iprot.readFieldEnd()
13212 
    iprot.readStructEnd()
13213 
 
13214 
  def write(self, oprot):
13215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13217 
      return
3064 chandransh 13218 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13219 
    if self.success is not None:
3064 chandransh 13220 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13221 
      oprot.writeBool(self.success)
1113 chandransh 13222 
      oprot.writeFieldEnd()
3431 rajveer 13223 
    if self.ex is not None:
1113 chandransh 13224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13225 
      self.ex.write(oprot)
13226 
      oprot.writeFieldEnd()
13227 
    oprot.writeFieldStop()
13228 
    oprot.writeStructEnd()
13229 
 
3431 rajveer 13230 
  def validate(self):
13231 
    return
13232 
 
13233 
 
1113 chandransh 13234 
  def __repr__(self):
13235 
    L = ['%s=%r' % (key, value)
13236 
      for key, value in self.__dict__.iteritems()]
13237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13238 
 
13239 
  def __eq__(self, other):
13240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13241 
 
13242 
  def __ne__(self, other):
13243 
    return not (self == other)
13244 
 
3064 chandransh 13245 
class addBillingDetails_args:
1135 chandransh 13246 
  """
13247 
  Attributes:
3064 chandransh 13248 
   - orderId
13249 
   - invoice_number
4658 mandeep.dh 13250 
   - serialNumber
4283 anupam.sin 13251 
   - itemNumber
3064 chandransh 13252 
   - billed_by
4264 rajveer 13253 
   - jacketNumber
4283 anupam.sin 13254 
   - billingType
5110 mandeep.dh 13255 
   - fulfilmentWarehouseId
4763 rajveer 13256 
   - authorize
1135 chandransh 13257 
  """
13258 
 
13259 
  thrift_spec = (
13260 
    None, # 0
3064 chandransh 13261 
    (1, TType.I64, 'orderId', None, None, ), # 1
13262 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13263 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13264 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13265 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13266 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13267 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13268 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13269 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13270 
  )
13271 
 
5110 mandeep.dh 13272 
  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 13273 
    self.orderId = orderId
13274 
    self.invoice_number = invoice_number
4658 mandeep.dh 13275 
    self.serialNumber = serialNumber
4283 anupam.sin 13276 
    self.itemNumber = itemNumber
3064 chandransh 13277 
    self.billed_by = billed_by
4264 rajveer 13278 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13279 
    self.billingType = billingType
5110 mandeep.dh 13280 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13281 
    self.authorize = authorize
1135 chandransh 13282 
 
13283 
  def read(self, iprot):
13284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13286 
      return
13287 
    iprot.readStructBegin()
13288 
    while True:
13289 
      (fname, ftype, fid) = iprot.readFieldBegin()
13290 
      if ftype == TType.STOP:
13291 
        break
13292 
      if fid == 1:
13293 
        if ftype == TType.I64:
3064 chandransh 13294 
          self.orderId = iprot.readI64();
1135 chandransh 13295 
        else:
13296 
          iprot.skip(ftype)
13297 
      elif fid == 2:
3064 chandransh 13298 
        if ftype == TType.STRING:
13299 
          self.invoice_number = iprot.readString();
1135 chandransh 13300 
        else:
13301 
          iprot.skip(ftype)
3064 chandransh 13302 
      elif fid == 3:
5411 rajveer 13303 
        if ftype == TType.LIST:
13304 
          self.serialNumber = []
6188 rajveer 13305 
          (_etype270, _size267) = iprot.readListBegin()
13306 
          for _i271 in xrange(_size267):
13307 
            _elem272 = iprot.readString();
13308 
            self.serialNumber.append(_elem272)
5411 rajveer 13309 
          iprot.readListEnd()
3064 chandransh 13310 
        else:
13311 
          iprot.skip(ftype)
13312 
      elif fid == 4:
5411 rajveer 13313 
        if ftype == TType.LIST:
13314 
          self.itemNumber = []
6188 rajveer 13315 
          (_etype276, _size273) = iprot.readListBegin()
13316 
          for _i277 in xrange(_size273):
13317 
            _elem278 = iprot.readString();
13318 
            self.itemNumber.append(_elem278)
5411 rajveer 13319 
          iprot.readListEnd()
3064 chandransh 13320 
        else:
13321 
          iprot.skip(ftype)
13322 
      elif fid == 5:
13323 
        if ftype == TType.STRING:
4283 anupam.sin 13324 
          self.billed_by = iprot.readString();
3064 chandransh 13325 
        else:
13326 
          iprot.skip(ftype)
13327 
      elif fid == 6:
13328 
        if ftype == TType.I64:
4283 anupam.sin 13329 
          self.jacketNumber = iprot.readI64();
13330 
        else:
13331 
          iprot.skip(ftype)
13332 
      elif fid == 7:
13333 
        if ftype == TType.I64:
3064 chandransh 13334 
          self.billingType = iprot.readI64();
13335 
        else:
13336 
          iprot.skip(ftype)
4283 anupam.sin 13337 
      elif fid == 8:
13338 
        if ftype == TType.I64:
5110 mandeep.dh 13339 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13340 
        else:
13341 
          iprot.skip(ftype)
4763 rajveer 13342 
      elif fid == 9:
13343 
        if ftype == TType.BOOL:
13344 
          self.authorize = iprot.readBool();
13345 
        else:
13346 
          iprot.skip(ftype)
1246 chandransh 13347 
      else:
13348 
        iprot.skip(ftype)
13349 
      iprot.readFieldEnd()
13350 
    iprot.readStructEnd()
13351 
 
13352 
  def write(self, oprot):
13353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13355 
      return
4283 anupam.sin 13356 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13357 
    if self.orderId is not None:
3064 chandransh 13358 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13359 
      oprot.writeI64(self.orderId)
1246 chandransh 13360 
      oprot.writeFieldEnd()
4283 anupam.sin 13361 
    if self.invoice_number is not None:
13362 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13363 
      oprot.writeString(self.invoice_number)
1246 chandransh 13364 
      oprot.writeFieldEnd()
4658 mandeep.dh 13365 
    if self.serialNumber is not None:
5411 rajveer 13366 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13367 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13368 
      for iter279 in self.serialNumber:
13369 
        oprot.writeString(iter279)
5411 rajveer 13370 
      oprot.writeListEnd()
3064 chandransh 13371 
      oprot.writeFieldEnd()
3431 rajveer 13372 
    if self.itemNumber is not None:
5411 rajveer 13373 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13374 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13375 
      for iter280 in self.itemNumber:
13376 
        oprot.writeString(iter280)
5411 rajveer 13377 
      oprot.writeListEnd()
3064 chandransh 13378 
      oprot.writeFieldEnd()
4283 anupam.sin 13379 
    if self.billed_by is not None:
13380 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13381 
      oprot.writeString(self.billed_by)
3064 chandransh 13382 
      oprot.writeFieldEnd()
4283 anupam.sin 13383 
    if self.jacketNumber is not None:
13384 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13385 
      oprot.writeI64(self.jacketNumber)
13386 
      oprot.writeFieldEnd()
3431 rajveer 13387 
    if self.billingType is not None:
4283 anupam.sin 13388 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13389 
      oprot.writeI64(self.billingType)
13390 
      oprot.writeFieldEnd()
5110 mandeep.dh 13391 
    if self.fulfilmentWarehouseId is not None:
13392 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13393 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13394 
      oprot.writeFieldEnd()
4763 rajveer 13395 
    if self.authorize is not None:
13396 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13397 
      oprot.writeBool(self.authorize)
13398 
      oprot.writeFieldEnd()
1246 chandransh 13399 
    oprot.writeFieldStop()
13400 
    oprot.writeStructEnd()
13401 
 
3431 rajveer 13402 
  def validate(self):
13403 
    return
13404 
 
13405 
 
1246 chandransh 13406 
  def __repr__(self):
13407 
    L = ['%s=%r' % (key, value)
13408 
      for key, value in self.__dict__.iteritems()]
13409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13410 
 
13411 
  def __eq__(self, other):
13412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13413 
 
13414 
  def __ne__(self, other):
13415 
    return not (self == other)
13416 
 
4283 anupam.sin 13417 
class addBillingDetails_result:
1246 chandransh 13418 
  """
13419 
  Attributes:
3064 chandransh 13420 
   - success
1246 chandransh 13421 
   - ex
13422 
  """
13423 
 
13424 
  thrift_spec = (
3064 chandransh 13425 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13427 
  )
13428 
 
3064 chandransh 13429 
  def __init__(self, success=None, ex=None,):
13430 
    self.success = success
1246 chandransh 13431 
    self.ex = ex
13432 
 
13433 
  def read(self, iprot):
13434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13436 
      return
13437 
    iprot.readStructBegin()
13438 
    while True:
13439 
      (fname, ftype, fid) = iprot.readFieldBegin()
13440 
      if ftype == TType.STOP:
13441 
        break
3064 chandransh 13442 
      if fid == 0:
13443 
        if ftype == TType.BOOL:
13444 
          self.success = iprot.readBool();
13445 
        else:
13446 
          iprot.skip(ftype)
13447 
      elif fid == 1:
1246 chandransh 13448 
        if ftype == TType.STRUCT:
13449 
          self.ex = TransactionServiceException()
13450 
          self.ex.read(iprot)
13451 
        else:
13452 
          iprot.skip(ftype)
13453 
      else:
13454 
        iprot.skip(ftype)
13455 
      iprot.readFieldEnd()
13456 
    iprot.readStructEnd()
13457 
 
13458 
  def write(self, oprot):
13459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13461 
      return
4283 anupam.sin 13462 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13463 
    if self.success is not None:
3064 chandransh 13464 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13465 
      oprot.writeBool(self.success)
13466 
      oprot.writeFieldEnd()
3431 rajveer 13467 
    if self.ex is not None:
1246 chandransh 13468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13469 
      self.ex.write(oprot)
13470 
      oprot.writeFieldEnd()
13471 
    oprot.writeFieldStop()
13472 
    oprot.writeStructEnd()
13473 
 
3431 rajveer 13474 
  def validate(self):
13475 
    return
13476 
 
13477 
 
1246 chandransh 13478 
  def __repr__(self):
13479 
    L = ['%s=%r' % (key, value)
13480 
      for key, value in self.__dict__.iteritems()]
13481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13482 
 
13483 
  def __eq__(self, other):
13484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13485 
 
13486 
  def __ne__(self, other):
13487 
    return not (self == other)
13488 
 
4579 rajveer 13489 
class addInvoiceNumber_args:
13490 
  """
13491 
  Attributes:
13492 
   - orderId
13493 
   - invoiceNumber
4763 rajveer 13494 
   - color
4579 rajveer 13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    None, # 0
13499 
    (1, TType.I64, 'orderId', None, None, ), # 1
13500 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13501 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13502 
  )
13503 
 
4763 rajveer 13504 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13505 
    self.orderId = orderId
13506 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13507 
    self.color = color
4579 rajveer 13508 
 
13509 
  def read(self, iprot):
13510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13512 
      return
13513 
    iprot.readStructBegin()
13514 
    while True:
13515 
      (fname, ftype, fid) = iprot.readFieldBegin()
13516 
      if ftype == TType.STOP:
13517 
        break
13518 
      if fid == 1:
13519 
        if ftype == TType.I64:
13520 
          self.orderId = iprot.readI64();
13521 
        else:
13522 
          iprot.skip(ftype)
13523 
      elif fid == 2:
13524 
        if ftype == TType.STRING:
13525 
          self.invoiceNumber = iprot.readString();
13526 
        else:
13527 
          iprot.skip(ftype)
4763 rajveer 13528 
      elif fid == 3:
13529 
        if ftype == TType.STRING:
13530 
          self.color = iprot.readString();
13531 
        else:
13532 
          iprot.skip(ftype)
4579 rajveer 13533 
      else:
13534 
        iprot.skip(ftype)
13535 
      iprot.readFieldEnd()
13536 
    iprot.readStructEnd()
13537 
 
13538 
  def write(self, oprot):
13539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13541 
      return
13542 
    oprot.writeStructBegin('addInvoiceNumber_args')
13543 
    if self.orderId is not None:
13544 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13545 
      oprot.writeI64(self.orderId)
13546 
      oprot.writeFieldEnd()
13547 
    if self.invoiceNumber is not None:
13548 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13549 
      oprot.writeString(self.invoiceNumber)
13550 
      oprot.writeFieldEnd()
4763 rajveer 13551 
    if self.color is not None:
13552 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13553 
      oprot.writeString(self.color)
13554 
      oprot.writeFieldEnd()
4579 rajveer 13555 
    oprot.writeFieldStop()
13556 
    oprot.writeStructEnd()
13557 
 
13558 
  def validate(self):
13559 
    return
13560 
 
13561 
 
13562 
  def __repr__(self):
13563 
    L = ['%s=%r' % (key, value)
13564 
      for key, value in self.__dict__.iteritems()]
13565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13566 
 
13567 
  def __eq__(self, other):
13568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13569 
 
13570 
  def __ne__(self, other):
13571 
    return not (self == other)
13572 
 
13573 
class addInvoiceNumber_result:
13574 
  """
13575 
  Attributes:
13576 
   - ex
13577 
  """
13578 
 
13579 
  thrift_spec = (
13580 
    None, # 0
13581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13582 
  )
13583 
 
13584 
  def __init__(self, ex=None,):
13585 
    self.ex = ex
13586 
 
13587 
  def read(self, iprot):
13588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13590 
      return
13591 
    iprot.readStructBegin()
13592 
    while True:
13593 
      (fname, ftype, fid) = iprot.readFieldBegin()
13594 
      if ftype == TType.STOP:
13595 
        break
13596 
      if fid == 1:
13597 
        if ftype == TType.STRUCT:
13598 
          self.ex = TransactionServiceException()
13599 
          self.ex.read(iprot)
13600 
        else:
13601 
          iprot.skip(ftype)
13602 
      else:
13603 
        iprot.skip(ftype)
13604 
      iprot.readFieldEnd()
13605 
    iprot.readStructEnd()
13606 
 
13607 
  def write(self, oprot):
13608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13610 
      return
13611 
    oprot.writeStructBegin('addInvoiceNumber_result')
13612 
    if self.ex is not None:
13613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13614 
      self.ex.write(oprot)
13615 
      oprot.writeFieldEnd()
13616 
    oprot.writeFieldStop()
13617 
    oprot.writeStructEnd()
13618 
 
13619 
  def validate(self):
13620 
    return
13621 
 
13622 
 
13623 
  def __repr__(self):
13624 
    L = ['%s=%r' % (key, value)
13625 
      for key, value in self.__dict__.iteritems()]
13626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13627 
 
13628 
  def __eq__(self, other):
13629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13630 
 
13631 
  def __ne__(self, other):
13632 
    return not (self == other)
13633 
 
4910 phani.kuma 13634 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13635 
  """
13636 
  Attributes:
3064 chandransh 13637 
   - warehouseId
1408 ankur.sing 13638 
   - providerId
3064 chandransh 13639 
   - cod
4910 phani.kuma 13640 
   - orderIds
1408 ankur.sing 13641 
  """
13642 
 
13643 
  thrift_spec = (
13644 
    None, # 0
3064 chandransh 13645 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13646 
    (2, TType.I64, 'providerId', None, None, ), # 2
13647 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13648 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13649 
  )
13650 
 
4910 phani.kuma 13651 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13652 
    self.warehouseId = warehouseId
1408 ankur.sing 13653 
    self.providerId = providerId
3064 chandransh 13654 
    self.cod = cod
4910 phani.kuma 13655 
    self.orderIds = orderIds
1408 ankur.sing 13656 
 
13657 
  def read(self, iprot):
13658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13660 
      return
13661 
    iprot.readStructBegin()
13662 
    while True:
13663 
      (fname, ftype, fid) = iprot.readFieldBegin()
13664 
      if ftype == TType.STOP:
13665 
        break
13666 
      if fid == 1:
13667 
        if ftype == TType.I64:
3064 chandransh 13668 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13669 
        else:
13670 
          iprot.skip(ftype)
13671 
      elif fid == 2:
13672 
        if ftype == TType.I64:
3064 chandransh 13673 
          self.providerId = iprot.readI64();
1408 ankur.sing 13674 
        else:
13675 
          iprot.skip(ftype)
3064 chandransh 13676 
      elif fid == 3:
13677 
        if ftype == TType.BOOL:
13678 
          self.cod = iprot.readBool();
13679 
        else:
13680 
          iprot.skip(ftype)
4910 phani.kuma 13681 
      elif fid == 4:
13682 
        if ftype == TType.LIST:
13683 
          self.orderIds = []
6188 rajveer 13684 
          (_etype284, _size281) = iprot.readListBegin()
13685 
          for _i285 in xrange(_size281):
13686 
            _elem286 = iprot.readI64();
13687 
            self.orderIds.append(_elem286)
4910 phani.kuma 13688 
          iprot.readListEnd()
13689 
        else:
13690 
          iprot.skip(ftype)
1408 ankur.sing 13691 
      else:
13692 
        iprot.skip(ftype)
13693 
      iprot.readFieldEnd()
13694 
    iprot.readStructEnd()
13695 
 
13696 
  def write(self, oprot):
13697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13699 
      return
4910 phani.kuma 13700 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13701 
    if self.warehouseId is not None:
3064 chandransh 13702 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13703 
      oprot.writeI64(self.warehouseId)
13704 
      oprot.writeFieldEnd()
3431 rajveer 13705 
    if self.providerId is not None:
3064 chandransh 13706 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13707 
      oprot.writeI64(self.providerId)
13708 
      oprot.writeFieldEnd()
3431 rajveer 13709 
    if self.cod is not None:
3064 chandransh 13710 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13711 
      oprot.writeBool(self.cod)
1408 ankur.sing 13712 
      oprot.writeFieldEnd()
4910 phani.kuma 13713 
    if self.orderIds is not None:
13714 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13715 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13716 
      for iter287 in self.orderIds:
13717 
        oprot.writeI64(iter287)
4910 phani.kuma 13718 
      oprot.writeListEnd()
13719 
      oprot.writeFieldEnd()
1408 ankur.sing 13720 
    oprot.writeFieldStop()
13721 
    oprot.writeStructEnd()
13722 
 
3431 rajveer 13723 
  def validate(self):
13724 
    return
13725 
 
13726 
 
1408 ankur.sing 13727 
  def __repr__(self):
13728 
    L = ['%s=%r' % (key, value)
13729 
      for key, value in self.__dict__.iteritems()]
13730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13731 
 
13732 
  def __eq__(self, other):
13733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13734 
 
13735 
  def __ne__(self, other):
13736 
    return not (self == other)
13737 
 
4910 phani.kuma 13738 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13739 
  """
13740 
  Attributes:
13741 
   - success
3064 chandransh 13742 
   - ex
1408 ankur.sing 13743 
  """
13744 
 
13745 
  thrift_spec = (
3064 chandransh 13746 
    (0, TType.BOOL, 'success', None, None, ), # 0
13747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13748 
  )
13749 
 
3064 chandransh 13750 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13751 
    self.success = success
3064 chandransh 13752 
    self.ex = ex
1408 ankur.sing 13753 
 
13754 
  def read(self, iprot):
13755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13757 
      return
13758 
    iprot.readStructBegin()
13759 
    while True:
13760 
      (fname, ftype, fid) = iprot.readFieldBegin()
13761 
      if ftype == TType.STOP:
13762 
        break
13763 
      if fid == 0:
3064 chandransh 13764 
        if ftype == TType.BOOL:
13765 
          self.success = iprot.readBool();
1408 ankur.sing 13766 
        else:
13767 
          iprot.skip(ftype)
3064 chandransh 13768 
      elif fid == 1:
13769 
        if ftype == TType.STRUCT:
13770 
          self.ex = TransactionServiceException()
13771 
          self.ex.read(iprot)
13772 
        else:
13773 
          iprot.skip(ftype)
1408 ankur.sing 13774 
      else:
13775 
        iprot.skip(ftype)
13776 
      iprot.readFieldEnd()
13777 
    iprot.readStructEnd()
13778 
 
13779 
  def write(self, oprot):
13780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13782 
      return
4910 phani.kuma 13783 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13784 
    if self.success is not None:
3064 chandransh 13785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13786 
      oprot.writeBool(self.success)
1408 ankur.sing 13787 
      oprot.writeFieldEnd()
3431 rajveer 13788 
    if self.ex is not None:
3064 chandransh 13789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13790 
      self.ex.write(oprot)
13791 
      oprot.writeFieldEnd()
1408 ankur.sing 13792 
    oprot.writeFieldStop()
13793 
    oprot.writeStructEnd()
13794 
 
3431 rajveer 13795 
  def validate(self):
13796 
    return
13797 
 
13798 
 
1408 ankur.sing 13799 
  def __repr__(self):
13800 
    L = ['%s=%r' % (key, value)
13801 
      for key, value in self.__dict__.iteritems()]
13802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13803 
 
13804 
  def __eq__(self, other):
13805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13806 
 
13807 
  def __ne__(self, other):
13808 
    return not (self == other)
13809 
 
5676 rajveer 13810 
class markOrdersAsReturnedFromStore_args:
13811 
  """
13812 
  Attributes:
13813 
   - providerId
13814 
   - orderIds
5713 rajveer 13815 
   - awbs
5676 rajveer 13816 
  """
13817 
 
13818 
  thrift_spec = (
13819 
    None, # 0
13820 
    (1, TType.I64, 'providerId', None, None, ), # 1
13821 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13822 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13823 
  )
13824 
 
5713 rajveer 13825 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13826 
    self.providerId = providerId
13827 
    self.orderIds = orderIds
5713 rajveer 13828 
    self.awbs = awbs
5676 rajveer 13829 
 
13830 
  def read(self, iprot):
13831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13833 
      return
13834 
    iprot.readStructBegin()
13835 
    while True:
13836 
      (fname, ftype, fid) = iprot.readFieldBegin()
13837 
      if ftype == TType.STOP:
13838 
        break
13839 
      if fid == 1:
13840 
        if ftype == TType.I64:
13841 
          self.providerId = iprot.readI64();
13842 
        else:
13843 
          iprot.skip(ftype)
13844 
      elif fid == 2:
13845 
        if ftype == TType.LIST:
13846 
          self.orderIds = []
6188 rajveer 13847 
          (_etype291, _size288) = iprot.readListBegin()
13848 
          for _i292 in xrange(_size288):
13849 
            _elem293 = iprot.readI64();
13850 
            self.orderIds.append(_elem293)
5676 rajveer 13851 
          iprot.readListEnd()
13852 
        else:
13853 
          iprot.skip(ftype)
5713 rajveer 13854 
      elif fid == 3:
13855 
        if ftype == TType.LIST:
13856 
          self.awbs = []
6188 rajveer 13857 
          (_etype297, _size294) = iprot.readListBegin()
13858 
          for _i298 in xrange(_size294):
13859 
            _elem299 = iprot.readString();
13860 
            self.awbs.append(_elem299)
5713 rajveer 13861 
          iprot.readListEnd()
13862 
        else:
13863 
          iprot.skip(ftype)
5676 rajveer 13864 
      else:
13865 
        iprot.skip(ftype)
13866 
      iprot.readFieldEnd()
13867 
    iprot.readStructEnd()
13868 
 
13869 
  def write(self, oprot):
13870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13872 
      return
13873 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13874 
    if self.providerId is not None:
13875 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13876 
      oprot.writeI64(self.providerId)
13877 
      oprot.writeFieldEnd()
13878 
    if self.orderIds is not None:
13879 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13880 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13881 
      for iter300 in self.orderIds:
13882 
        oprot.writeI64(iter300)
5676 rajveer 13883 
      oprot.writeListEnd()
13884 
      oprot.writeFieldEnd()
5713 rajveer 13885 
    if self.awbs is not None:
13886 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13887 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 13888 
      for iter301 in self.awbs:
13889 
        oprot.writeString(iter301)
5713 rajveer 13890 
      oprot.writeListEnd()
13891 
      oprot.writeFieldEnd()
5676 rajveer 13892 
    oprot.writeFieldStop()
13893 
    oprot.writeStructEnd()
13894 
 
13895 
  def validate(self):
13896 
    return
13897 
 
13898 
 
13899 
  def __repr__(self):
13900 
    L = ['%s=%r' % (key, value)
13901 
      for key, value in self.__dict__.iteritems()]
13902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13903 
 
13904 
  def __eq__(self, other):
13905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13906 
 
13907 
  def __ne__(self, other):
13908 
    return not (self == other)
13909 
 
13910 
class markOrdersAsReturnedFromStore_result:
13911 
  """
13912 
  Attributes:
13913 
   - success
13914 
   - ex
13915 
  """
13916 
 
13917 
  thrift_spec = (
13918 
    (0, TType.BOOL, 'success', None, None, ), # 0
13919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13920 
  )
13921 
 
13922 
  def __init__(self, success=None, ex=None,):
13923 
    self.success = success
13924 
    self.ex = ex
13925 
 
13926 
  def read(self, iprot):
13927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13929 
      return
13930 
    iprot.readStructBegin()
13931 
    while True:
13932 
      (fname, ftype, fid) = iprot.readFieldBegin()
13933 
      if ftype == TType.STOP:
13934 
        break
13935 
      if fid == 0:
13936 
        if ftype == TType.BOOL:
13937 
          self.success = iprot.readBool();
13938 
        else:
13939 
          iprot.skip(ftype)
13940 
      elif fid == 1:
13941 
        if ftype == TType.STRUCT:
13942 
          self.ex = TransactionServiceException()
13943 
          self.ex.read(iprot)
13944 
        else:
13945 
          iprot.skip(ftype)
13946 
      else:
13947 
        iprot.skip(ftype)
13948 
      iprot.readFieldEnd()
13949 
    iprot.readStructEnd()
13950 
 
13951 
  def write(self, oprot):
13952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13954 
      return
13955 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13956 
    if self.success is not None:
13957 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13958 
      oprot.writeBool(self.success)
13959 
      oprot.writeFieldEnd()
13960 
    if self.ex is not None:
13961 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13962 
      self.ex.write(oprot)
13963 
      oprot.writeFieldEnd()
13964 
    oprot.writeFieldStop()
13965 
    oprot.writeStructEnd()
13966 
 
13967 
  def validate(self):
13968 
    return
13969 
 
13970 
 
13971 
  def __repr__(self):
13972 
    L = ['%s=%r' % (key, value)
13973 
      for key, value in self.__dict__.iteritems()]
13974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13975 
 
13976 
  def __eq__(self, other):
13977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13978 
 
13979 
  def __ne__(self, other):
13980 
    return not (self == other)
13981 
 
4910 phani.kuma 13982 
class markOrdersAsPickedUp_args:
4410 rajveer 13983 
  """
13984 
  Attributes:
13985 
   - providerId
4910 phani.kuma 13986 
   - pickupDetails
4410 rajveer 13987 
  """
13988 
 
13989 
  thrift_spec = (
13990 
    None, # 0
4910 phani.kuma 13991 
    (1, TType.I64, 'providerId', None, None, ), # 1
13992 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13993 
  )
13994 
 
4910 phani.kuma 13995 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13996 
    self.providerId = providerId
4910 phani.kuma 13997 
    self.pickupDetails = pickupDetails
4410 rajveer 13998 
 
13999 
  def read(self, iprot):
14000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14002 
      return
14003 
    iprot.readStructBegin()
14004 
    while True:
14005 
      (fname, ftype, fid) = iprot.readFieldBegin()
14006 
      if ftype == TType.STOP:
14007 
        break
14008 
      if fid == 1:
14009 
        if ftype == TType.I64:
4910 phani.kuma 14010 
          self.providerId = iprot.readI64();
4410 rajveer 14011 
        else:
14012 
          iprot.skip(ftype)
14013 
      elif fid == 2:
4910 phani.kuma 14014 
        if ftype == TType.MAP:
14015 
          self.pickupDetails = {}
6188 rajveer 14016 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14017 
          for _i306 in xrange(_size302):
14018 
            _key307 = iprot.readString();
14019 
            _val308 = iprot.readString();
14020 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14021 
          iprot.readMapEnd()
4410 rajveer 14022 
        else:
14023 
          iprot.skip(ftype)
14024 
      else:
14025 
        iprot.skip(ftype)
14026 
      iprot.readFieldEnd()
14027 
    iprot.readStructEnd()
14028 
 
14029 
  def write(self, oprot):
14030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14032 
      return
4910 phani.kuma 14033 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14034 
    if self.providerId is not None:
4910 phani.kuma 14035 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14036 
      oprot.writeI64(self.providerId)
14037 
      oprot.writeFieldEnd()
4910 phani.kuma 14038 
    if self.pickupDetails is not None:
14039 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14040 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14041 
      for kiter309,viter310 in self.pickupDetails.items():
14042 
        oprot.writeString(kiter309)
14043 
        oprot.writeString(viter310)
4910 phani.kuma 14044 
      oprot.writeMapEnd()
4410 rajveer 14045 
      oprot.writeFieldEnd()
14046 
    oprot.writeFieldStop()
14047 
    oprot.writeStructEnd()
14048 
 
14049 
  def validate(self):
14050 
    return
14051 
 
14052 
 
14053 
  def __repr__(self):
14054 
    L = ['%s=%r' % (key, value)
14055 
      for key, value in self.__dict__.iteritems()]
14056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14057 
 
14058 
  def __eq__(self, other):
14059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14060 
 
14061 
  def __ne__(self, other):
14062 
    return not (self == other)
14063 
 
4910 phani.kuma 14064 
class markOrdersAsPickedUp_result:
4410 rajveer 14065 
  """
14066 
  Attributes:
14067 
   - ex
14068 
  """
14069 
 
14070 
  thrift_spec = (
4910 phani.kuma 14071 
    None, # 0
4410 rajveer 14072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14073 
  )
14074 
 
4910 phani.kuma 14075 
  def __init__(self, ex=None,):
4410 rajveer 14076 
    self.ex = ex
14077 
 
14078 
  def read(self, iprot):
14079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14081 
      return
14082 
    iprot.readStructBegin()
14083 
    while True:
14084 
      (fname, ftype, fid) = iprot.readFieldBegin()
14085 
      if ftype == TType.STOP:
14086 
        break
4910 phani.kuma 14087 
      if fid == 1:
4410 rajveer 14088 
        if ftype == TType.STRUCT:
14089 
          self.ex = TransactionServiceException()
14090 
          self.ex.read(iprot)
14091 
        else:
14092 
          iprot.skip(ftype)
14093 
      else:
14094 
        iprot.skip(ftype)
14095 
      iprot.readFieldEnd()
14096 
    iprot.readStructEnd()
14097 
 
14098 
  def write(self, oprot):
14099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14101 
      return
4910 phani.kuma 14102 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14103 
    if self.ex is not None:
14104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14105 
      self.ex.write(oprot)
14106 
      oprot.writeFieldEnd()
14107 
    oprot.writeFieldStop()
14108 
    oprot.writeStructEnd()
14109 
 
14110 
  def validate(self):
14111 
    return
14112 
 
14113 
 
14114 
  def __repr__(self):
14115 
    L = ['%s=%r' % (key, value)
14116 
      for key, value in self.__dict__.iteritems()]
14117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14118 
 
14119 
  def __eq__(self, other):
14120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14121 
 
14122 
  def __ne__(self, other):
14123 
    return not (self == other)
14124 
 
4910 phani.kuma 14125 
class getOrdersNotPickedUp_args:
304 ashish 14126 
  """
14127 
  Attributes:
3064 chandransh 14128 
   - providerId
304 ashish 14129 
  """
94 ashish 14130 
 
304 ashish 14131 
  thrift_spec = (
14132 
    None, # 0
3064 chandransh 14133 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14134 
  )
14135 
 
4910 phani.kuma 14136 
  def __init__(self, providerId=None,):
3064 chandransh 14137 
    self.providerId = providerId
304 ashish 14138 
 
14139 
  def read(self, iprot):
14140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14142 
      return
14143 
    iprot.readStructBegin()
14144 
    while True:
14145 
      (fname, ftype, fid) = iprot.readFieldBegin()
14146 
      if ftype == TType.STOP:
14147 
        break
14148 
      if fid == 1:
14149 
        if ftype == TType.I64:
3064 chandransh 14150 
          self.providerId = iprot.readI64();
304 ashish 14151 
        else:
14152 
          iprot.skip(ftype)
14153 
      else:
14154 
        iprot.skip(ftype)
14155 
      iprot.readFieldEnd()
14156 
    iprot.readStructEnd()
14157 
 
14158 
  def write(self, oprot):
14159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14161 
      return
4910 phani.kuma 14162 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14163 
    if self.providerId is not None:
3064 chandransh 14164 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14165 
      oprot.writeI64(self.providerId)
304 ashish 14166 
      oprot.writeFieldEnd()
14167 
    oprot.writeFieldStop()
14168 
    oprot.writeStructEnd()
14169 
 
3431 rajveer 14170 
  def validate(self):
14171 
    return
14172 
 
14173 
 
304 ashish 14174 
  def __repr__(self):
14175 
    L = ['%s=%r' % (key, value)
14176 
      for key, value in self.__dict__.iteritems()]
14177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14178 
 
14179 
  def __eq__(self, other):
14180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14181 
 
14182 
  def __ne__(self, other):
14183 
    return not (self == other)
14184 
 
4910 phani.kuma 14185 
class getOrdersNotPickedUp_result:
304 ashish 14186 
  """
14187 
  Attributes:
14188 
   - success
14189 
  """
14190 
 
14191 
  thrift_spec = (
3064 chandransh 14192 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14193 
  )
14194 
 
4910 phani.kuma 14195 
  def __init__(self, success=None,):
304 ashish 14196 
    self.success = success
14197 
 
14198 
  def read(self, iprot):
14199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14201 
      return
14202 
    iprot.readStructBegin()
14203 
    while True:
14204 
      (fname, ftype, fid) = iprot.readFieldBegin()
14205 
      if ftype == TType.STOP:
14206 
        break
14207 
      if fid == 0:
14208 
        if ftype == TType.LIST:
14209 
          self.success = []
6188 rajveer 14210 
          (_etype314, _size311) = iprot.readListBegin()
14211 
          for _i315 in xrange(_size311):
14212 
            _elem316 = Order()
14213 
            _elem316.read(iprot)
14214 
            self.success.append(_elem316)
304 ashish 14215 
          iprot.readListEnd()
14216 
        else:
14217 
          iprot.skip(ftype)
14218 
      else:
14219 
        iprot.skip(ftype)
14220 
      iprot.readFieldEnd()
14221 
    iprot.readStructEnd()
14222 
 
14223 
  def write(self, oprot):
14224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14226 
      return
4910 phani.kuma 14227 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14228 
    if self.success is not None:
304 ashish 14229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14231 
      for iter317 in self.success:
14232 
        iter317.write(oprot)
304 ashish 14233 
      oprot.writeListEnd()
14234 
      oprot.writeFieldEnd()
14235 
    oprot.writeFieldStop()
14236 
    oprot.writeStructEnd()
14237 
 
3431 rajveer 14238 
  def validate(self):
14239 
    return
14240 
 
14241 
 
304 ashish 14242 
  def __repr__(self):
14243 
    L = ['%s=%r' % (key, value)
14244 
      for key, value in self.__dict__.iteritems()]
14245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14246 
 
14247 
  def __eq__(self, other):
14248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14249 
 
14250 
  def __ne__(self, other):
14251 
    return not (self == other)
14252 
 
3064 chandransh 14253 
class markOrdersAsDelivered_args:
304 ashish 14254 
  """
14255 
  Attributes:
3064 chandransh 14256 
   - providerId
14257 
   - deliveredOrders
304 ashish 14258 
  """
14259 
 
14260 
  thrift_spec = (
14261 
    None, # 0
3064 chandransh 14262 
    (1, TType.I64, 'providerId', None, None, ), # 1
14263 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14264 
  )
14265 
 
3064 chandransh 14266 
  def __init__(self, providerId=None, deliveredOrders=None,):
14267 
    self.providerId = providerId
14268 
    self.deliveredOrders = deliveredOrders
304 ashish 14269 
 
14270 
  def read(self, iprot):
14271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14273 
      return
14274 
    iprot.readStructBegin()
14275 
    while True:
14276 
      (fname, ftype, fid) = iprot.readFieldBegin()
14277 
      if ftype == TType.STOP:
14278 
        break
14279 
      if fid == 1:
14280 
        if ftype == TType.I64:
3064 chandransh 14281 
          self.providerId = iprot.readI64();
304 ashish 14282 
        else:
14283 
          iprot.skip(ftype)
14284 
      elif fid == 2:
3064 chandransh 14285 
        if ftype == TType.MAP:
14286 
          self.deliveredOrders = {}
6188 rajveer 14287 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14288 
          for _i322 in xrange(_size318):
14289 
            _key323 = iprot.readString();
14290 
            _val324 = iprot.readString();
14291 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14292 
          iprot.readMapEnd()
304 ashish 14293 
        else:
14294 
          iprot.skip(ftype)
14295 
      else:
14296 
        iprot.skip(ftype)
14297 
      iprot.readFieldEnd()
14298 
    iprot.readStructEnd()
14299 
 
14300 
  def write(self, oprot):
14301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14303 
      return
3064 chandransh 14304 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14305 
    if self.providerId is not None:
3064 chandransh 14306 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14307 
      oprot.writeI64(self.providerId)
304 ashish 14308 
      oprot.writeFieldEnd()
3431 rajveer 14309 
    if self.deliveredOrders is not None:
3064 chandransh 14310 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14311 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14312 
      for kiter325,viter326 in self.deliveredOrders.items():
14313 
        oprot.writeString(kiter325)
14314 
        oprot.writeString(viter326)
3064 chandransh 14315 
      oprot.writeMapEnd()
304 ashish 14316 
      oprot.writeFieldEnd()
14317 
    oprot.writeFieldStop()
14318 
    oprot.writeStructEnd()
14319 
 
3431 rajveer 14320 
  def validate(self):
14321 
    return
14322 
 
14323 
 
304 ashish 14324 
  def __repr__(self):
14325 
    L = ['%s=%r' % (key, value)
14326 
      for key, value in self.__dict__.iteritems()]
14327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14328 
 
14329 
  def __eq__(self, other):
14330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14331 
 
14332 
  def __ne__(self, other):
14333 
    return not (self == other)
14334 
 
3064 chandransh 14335 
class markOrdersAsDelivered_result:
14336 
  """
14337 
  Attributes:
14338 
   - ex
14339 
  """
304 ashish 14340 
 
14341 
  thrift_spec = (
3064 chandransh 14342 
    None, # 0
14343 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14344 
  )
14345 
 
3064 chandransh 14346 
  def __init__(self, ex=None,):
14347 
    self.ex = ex
304 ashish 14348 
 
1596 ankur.sing 14349 
  def read(self, iprot):
14350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14352 
      return
14353 
    iprot.readStructBegin()
14354 
    while True:
14355 
      (fname, ftype, fid) = iprot.readFieldBegin()
14356 
      if ftype == TType.STOP:
14357 
        break
3064 chandransh 14358 
      if fid == 1:
14359 
        if ftype == TType.STRUCT:
14360 
          self.ex = TransactionServiceException()
14361 
          self.ex.read(iprot)
14362 
        else:
14363 
          iprot.skip(ftype)
1596 ankur.sing 14364 
      else:
14365 
        iprot.skip(ftype)
14366 
      iprot.readFieldEnd()
14367 
    iprot.readStructEnd()
14368 
 
14369 
  def write(self, oprot):
14370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14372 
      return
3064 chandransh 14373 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14374 
    if self.ex is not None:
3064 chandransh 14375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14376 
      self.ex.write(oprot)
14377 
      oprot.writeFieldEnd()
1596 ankur.sing 14378 
    oprot.writeFieldStop()
14379 
    oprot.writeStructEnd()
14380 
 
3431 rajveer 14381 
  def validate(self):
14382 
    return
14383 
 
14384 
 
1596 ankur.sing 14385 
  def __repr__(self):
14386 
    L = ['%s=%r' % (key, value)
14387 
      for key, value in self.__dict__.iteritems()]
14388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14389 
 
14390 
  def __eq__(self, other):
14391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14392 
 
14393 
  def __ne__(self, other):
14394 
    return not (self == other)
14395 
 
4910 phani.kuma 14396 
class markAsRTOrders_args:
1596 ankur.sing 14397 
  """
14398 
  Attributes:
3064 chandransh 14399 
   - providerId
14400 
   - returnedOrders
1596 ankur.sing 14401 
  """
14402 
 
14403 
  thrift_spec = (
3064 chandransh 14404 
    None, # 0
14405 
    (1, TType.I64, 'providerId', None, None, ), # 1
14406 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14407 
  )
14408 
 
3064 chandransh 14409 
  def __init__(self, providerId=None, returnedOrders=None,):
14410 
    self.providerId = providerId
14411 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14412 
 
14413 
  def read(self, iprot):
14414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14416 
      return
14417 
    iprot.readStructBegin()
14418 
    while True:
14419 
      (fname, ftype, fid) = iprot.readFieldBegin()
14420 
      if ftype == TType.STOP:
14421 
        break
3064 chandransh 14422 
      if fid == 1:
1596 ankur.sing 14423 
        if ftype == TType.I64:
3064 chandransh 14424 
          self.providerId = iprot.readI64();
1596 ankur.sing 14425 
        else:
14426 
          iprot.skip(ftype)
3064 chandransh 14427 
      elif fid == 2:
14428 
        if ftype == TType.MAP:
14429 
          self.returnedOrders = {}
6188 rajveer 14430 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14431 
          for _i331 in xrange(_size327):
14432 
            _key332 = iprot.readString();
14433 
            _val333 = iprot.readString();
14434 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14435 
          iprot.readMapEnd()
14436 
        else:
14437 
          iprot.skip(ftype)
1596 ankur.sing 14438 
      else:
14439 
        iprot.skip(ftype)
14440 
      iprot.readFieldEnd()
14441 
    iprot.readStructEnd()
14442 
 
14443 
  def write(self, oprot):
14444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14446 
      return
4910 phani.kuma 14447 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14448 
    if self.providerId is not None:
3064 chandransh 14449 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14450 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14451 
      oprot.writeFieldEnd()
3431 rajveer 14452 
    if self.returnedOrders is not None:
3064 chandransh 14453 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14454 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14455 
      for kiter334,viter335 in self.returnedOrders.items():
14456 
        oprot.writeString(kiter334)
14457 
        oprot.writeString(viter335)
3064 chandransh 14458 
      oprot.writeMapEnd()
14459 
      oprot.writeFieldEnd()
1596 ankur.sing 14460 
    oprot.writeFieldStop()
14461 
    oprot.writeStructEnd()
14462 
 
3431 rajveer 14463 
  def validate(self):
14464 
    return
14465 
 
14466 
 
1596 ankur.sing 14467 
  def __repr__(self):
14468 
    L = ['%s=%r' % (key, value)
14469 
      for key, value in self.__dict__.iteritems()]
14470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14471 
 
14472 
  def __eq__(self, other):
14473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14474 
 
14475 
  def __ne__(self, other):
14476 
    return not (self == other)
14477 
 
4910 phani.kuma 14478 
class markAsRTOrders_result:
3064 chandransh 14479 
  """
14480 
  Attributes:
14481 
   - ex
14482 
  """
1596 ankur.sing 14483 
 
1627 ankur.sing 14484 
  thrift_spec = (
3064 chandransh 14485 
    None, # 0
14486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14487 
  )
14488 
 
3064 chandransh 14489 
  def __init__(self, ex=None,):
14490 
    self.ex = ex
14491 
 
1627 ankur.sing 14492 
  def read(self, iprot):
14493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14495 
      return
14496 
    iprot.readStructBegin()
14497 
    while True:
14498 
      (fname, ftype, fid) = iprot.readFieldBegin()
14499 
      if ftype == TType.STOP:
14500 
        break
3064 chandransh 14501 
      if fid == 1:
14502 
        if ftype == TType.STRUCT:
14503 
          self.ex = TransactionServiceException()
14504 
          self.ex.read(iprot)
14505 
        else:
14506 
          iprot.skip(ftype)
1627 ankur.sing 14507 
      else:
14508 
        iprot.skip(ftype)
14509 
      iprot.readFieldEnd()
14510 
    iprot.readStructEnd()
14511 
 
14512 
  def write(self, oprot):
14513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14515 
      return
4910 phani.kuma 14516 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14517 
    if self.ex is not None:
3064 chandransh 14518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14519 
      self.ex.write(oprot)
14520 
      oprot.writeFieldEnd()
1627 ankur.sing 14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
3431 rajveer 14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
1627 ankur.sing 14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
4910 phani.kuma 14539 
class getRTOrders_args:
14540 
  """
14541 
  Attributes:
14542 
   - providerId
14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    None, # 0
14547 
    (1, TType.I64, 'providerId', None, None, ), # 1
14548 
  )
14549 
 
14550 
  def __init__(self, providerId=None,):
14551 
    self.providerId = providerId
14552 
 
14553 
  def read(self, iprot):
14554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14556 
      return
14557 
    iprot.readStructBegin()
14558 
    while True:
14559 
      (fname, ftype, fid) = iprot.readFieldBegin()
14560 
      if ftype == TType.STOP:
14561 
        break
14562 
      if fid == 1:
14563 
        if ftype == TType.I64:
14564 
          self.providerId = iprot.readI64();
14565 
        else:
14566 
          iprot.skip(ftype)
14567 
      else:
14568 
        iprot.skip(ftype)
14569 
      iprot.readFieldEnd()
14570 
    iprot.readStructEnd()
14571 
 
14572 
  def write(self, oprot):
14573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14575 
      return
14576 
    oprot.writeStructBegin('getRTOrders_args')
14577 
    if self.providerId is not None:
14578 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14579 
      oprot.writeI64(self.providerId)
14580 
      oprot.writeFieldEnd()
14581 
    oprot.writeFieldStop()
14582 
    oprot.writeStructEnd()
14583 
 
14584 
  def validate(self):
14585 
    return
14586 
 
14587 
 
14588 
  def __repr__(self):
14589 
    L = ['%s=%r' % (key, value)
14590 
      for key, value in self.__dict__.iteritems()]
14591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14592 
 
14593 
  def __eq__(self, other):
14594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14595 
 
14596 
  def __ne__(self, other):
14597 
    return not (self == other)
14598 
 
14599 
class getRTOrders_result:
14600 
  """
14601 
  Attributes:
14602 
   - success
14603 
  """
14604 
 
14605 
  thrift_spec = (
14606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14607 
  )
14608 
 
14609 
  def __init__(self, success=None,):
14610 
    self.success = success
14611 
 
14612 
  def read(self, iprot):
14613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14615 
      return
14616 
    iprot.readStructBegin()
14617 
    while True:
14618 
      (fname, ftype, fid) = iprot.readFieldBegin()
14619 
      if ftype == TType.STOP:
14620 
        break
14621 
      if fid == 0:
14622 
        if ftype == TType.LIST:
14623 
          self.success = []
6188 rajveer 14624 
          (_etype339, _size336) = iprot.readListBegin()
14625 
          for _i340 in xrange(_size336):
14626 
            _elem341 = Order()
14627 
            _elem341.read(iprot)
14628 
            self.success.append(_elem341)
4910 phani.kuma 14629 
          iprot.readListEnd()
14630 
        else:
14631 
          iprot.skip(ftype)
14632 
      else:
14633 
        iprot.skip(ftype)
14634 
      iprot.readFieldEnd()
14635 
    iprot.readStructEnd()
14636 
 
14637 
  def write(self, oprot):
14638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14640 
      return
14641 
    oprot.writeStructBegin('getRTOrders_result')
14642 
    if self.success is not None:
14643 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14644 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14645 
      for iter342 in self.success:
14646 
        iter342.write(oprot)
4910 phani.kuma 14647 
      oprot.writeListEnd()
14648 
      oprot.writeFieldEnd()
14649 
    oprot.writeFieldStop()
14650 
    oprot.writeStructEnd()
14651 
 
14652 
  def validate(self):
14653 
    return
14654 
 
14655 
 
14656 
  def __repr__(self):
14657 
    L = ['%s=%r' % (key, value)
14658 
      for key, value in self.__dict__.iteritems()]
14659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14660 
 
14661 
  def __eq__(self, other):
14662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14663 
 
14664 
  def __ne__(self, other):
14665 
    return not (self == other)
14666 
 
3064 chandransh 14667 
class updateNonDeliveryReason_args:
1627 ankur.sing 14668 
  """
14669 
  Attributes:
3064 chandransh 14670 
   - providerId
14671 
   - undeliveredOrders
1627 ankur.sing 14672 
  """
14673 
 
14674 
  thrift_spec = (
3064 chandransh 14675 
    None, # 0
14676 
    (1, TType.I64, 'providerId', None, None, ), # 1
14677 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14678 
  )
14679 
 
3064 chandransh 14680 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14681 
    self.providerId = providerId
14682 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14683 
 
14684 
  def read(self, iprot):
14685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14687 
      return
14688 
    iprot.readStructBegin()
14689 
    while True:
14690 
      (fname, ftype, fid) = iprot.readFieldBegin()
14691 
      if ftype == TType.STOP:
14692 
        break
3064 chandransh 14693 
      if fid == 1:
1627 ankur.sing 14694 
        if ftype == TType.I64:
3064 chandransh 14695 
          self.providerId = iprot.readI64();
1627 ankur.sing 14696 
        else:
14697 
          iprot.skip(ftype)
3064 chandransh 14698 
      elif fid == 2:
14699 
        if ftype == TType.MAP:
14700 
          self.undeliveredOrders = {}
6188 rajveer 14701 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14702 
          for _i347 in xrange(_size343):
14703 
            _key348 = iprot.readString();
14704 
            _val349 = iprot.readString();
14705 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14706 
          iprot.readMapEnd()
14707 
        else:
14708 
          iprot.skip(ftype)
1627 ankur.sing 14709 
      else:
14710 
        iprot.skip(ftype)
14711 
      iprot.readFieldEnd()
14712 
    iprot.readStructEnd()
14713 
 
14714 
  def write(self, oprot):
14715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14717 
      return
3064 chandransh 14718 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14719 
    if self.providerId is not None:
3064 chandransh 14720 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14721 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14722 
      oprot.writeFieldEnd()
3431 rajveer 14723 
    if self.undeliveredOrders is not None:
3064 chandransh 14724 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14725 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14726 
      for kiter350,viter351 in self.undeliveredOrders.items():
14727 
        oprot.writeString(kiter350)
14728 
        oprot.writeString(viter351)
3064 chandransh 14729 
      oprot.writeMapEnd()
14730 
      oprot.writeFieldEnd()
1627 ankur.sing 14731 
    oprot.writeFieldStop()
14732 
    oprot.writeStructEnd()
14733 
 
3431 rajveer 14734 
  def validate(self):
14735 
    return
14736 
 
14737 
 
1627 ankur.sing 14738 
  def __repr__(self):
14739 
    L = ['%s=%r' % (key, value)
14740 
      for key, value in self.__dict__.iteritems()]
14741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14742 
 
14743 
  def __eq__(self, other):
14744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14745 
 
14746 
  def __ne__(self, other):
14747 
    return not (self == other)
14748 
 
3064 chandransh 14749 
class updateNonDeliveryReason_result:
1627 ankur.sing 14750 
  """
14751 
  Attributes:
3064 chandransh 14752 
   - ex
1627 ankur.sing 14753 
  """
14754 
 
14755 
  thrift_spec = (
4910 phani.kuma 14756 
    None, # 0
3064 chandransh 14757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14758 
  )
14759 
 
4910 phani.kuma 14760 
  def __init__(self, ex=None,):
3064 chandransh 14761 
    self.ex = ex
1627 ankur.sing 14762 
 
14763 
  def read(self, iprot):
14764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14766 
      return
14767 
    iprot.readStructBegin()
14768 
    while True:
14769 
      (fname, ftype, fid) = iprot.readFieldBegin()
14770 
      if ftype == TType.STOP:
14771 
        break
4910 phani.kuma 14772 
      if fid == 1:
14773 
        if ftype == TType.STRUCT:
14774 
          self.ex = TransactionServiceException()
14775 
          self.ex.read(iprot)
14776 
        else:
14777 
          iprot.skip(ftype)
14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14788 
    if self.ex is not None:
14789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14790 
      self.ex.write(oprot)
14791 
      oprot.writeFieldEnd()
14792 
    oprot.writeFieldStop()
14793 
    oprot.writeStructEnd()
14794 
 
14795 
  def validate(self):
14796 
    return
14797 
 
14798 
 
14799 
  def __repr__(self):
14800 
    L = ['%s=%r' % (key, value)
14801 
      for key, value in self.__dict__.iteritems()]
14802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14803 
 
14804 
  def __eq__(self, other):
14805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14806 
 
14807 
  def __ne__(self, other):
14808 
    return not (self == other)
14809 
 
14810 
class getNonDeliveredOrdersbyCourier_args:
14811 
  """
14812 
  Attributes:
14813 
   - providerId
14814 
  """
14815 
 
14816 
  thrift_spec = (
14817 
    None, # 0
14818 
    (1, TType.I64, 'providerId', None, None, ), # 1
14819 
  )
14820 
 
14821 
  def __init__(self, providerId=None,):
14822 
    self.providerId = providerId
14823 
 
14824 
  def read(self, iprot):
14825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14827 
      return
14828 
    iprot.readStructBegin()
14829 
    while True:
14830 
      (fname, ftype, fid) = iprot.readFieldBegin()
14831 
      if ftype == TType.STOP:
14832 
        break
14833 
      if fid == 1:
14834 
        if ftype == TType.I64:
14835 
          self.providerId = iprot.readI64();
14836 
        else:
14837 
          iprot.skip(ftype)
14838 
      else:
14839 
        iprot.skip(ftype)
14840 
      iprot.readFieldEnd()
14841 
    iprot.readStructEnd()
14842 
 
14843 
  def write(self, oprot):
14844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14846 
      return
14847 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14848 
    if self.providerId is not None:
14849 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14850 
      oprot.writeI64(self.providerId)
14851 
      oprot.writeFieldEnd()
14852 
    oprot.writeFieldStop()
14853 
    oprot.writeStructEnd()
14854 
 
14855 
  def validate(self):
14856 
    return
14857 
 
14858 
 
14859 
  def __repr__(self):
14860 
    L = ['%s=%r' % (key, value)
14861 
      for key, value in self.__dict__.iteritems()]
14862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14863 
 
14864 
  def __eq__(self, other):
14865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14866 
 
14867 
  def __ne__(self, other):
14868 
    return not (self == other)
14869 
 
14870 
class getNonDeliveredOrdersbyCourier_result:
14871 
  """
14872 
  Attributes:
14873 
   - success
14874 
  """
14875 
 
14876 
  thrift_spec = (
14877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14878 
  )
14879 
 
14880 
  def __init__(self, success=None,):
14881 
    self.success = success
14882 
 
14883 
  def read(self, iprot):
14884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14886 
      return
14887 
    iprot.readStructBegin()
14888 
    while True:
14889 
      (fname, ftype, fid) = iprot.readFieldBegin()
14890 
      if ftype == TType.STOP:
14891 
        break
4581 phani.kuma 14892 
      if fid == 0:
14893 
        if ftype == TType.LIST:
14894 
          self.success = []
6188 rajveer 14895 
          (_etype355, _size352) = iprot.readListBegin()
14896 
          for _i356 in xrange(_size352):
14897 
            _elem357 = Order()
14898 
            _elem357.read(iprot)
14899 
            self.success.append(_elem357)
4581 phani.kuma 14900 
          iprot.readListEnd()
14901 
        else:
14902 
          iprot.skip(ftype)
4910 phani.kuma 14903 
      else:
14904 
        iprot.skip(ftype)
14905 
      iprot.readFieldEnd()
14906 
    iprot.readStructEnd()
14907 
 
14908 
  def write(self, oprot):
14909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14911 
      return
14912 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14913 
    if self.success is not None:
14914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14916 
      for iter358 in self.success:
14917 
        iter358.write(oprot)
4910 phani.kuma 14918 
      oprot.writeListEnd()
14919 
      oprot.writeFieldEnd()
14920 
    oprot.writeFieldStop()
14921 
    oprot.writeStructEnd()
14922 
 
14923 
  def validate(self):
14924 
    return
14925 
 
14926 
 
14927 
  def __repr__(self):
14928 
    L = ['%s=%r' % (key, value)
14929 
      for key, value in self.__dict__.iteritems()]
14930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14931 
 
14932 
  def __eq__(self, other):
14933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14934 
 
14935 
  def __ne__(self, other):
14936 
    return not (self == other)
14937 
 
14938 
class markOrdersAsLocalConnected_args:
14939 
  """
14940 
  Attributes:
14941 
   - providerId
14942 
   - local_connected_orders
14943 
  """
14944 
 
14945 
  thrift_spec = (
14946 
    None, # 0
14947 
    (1, TType.I64, 'providerId', None, None, ), # 1
14948 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14949 
  )
14950 
 
14951 
  def __init__(self, providerId=None, local_connected_orders=None,):
14952 
    self.providerId = providerId
14953 
    self.local_connected_orders = local_connected_orders
14954 
 
14955 
  def read(self, iprot):
14956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14958 
      return
14959 
    iprot.readStructBegin()
14960 
    while True:
14961 
      (fname, ftype, fid) = iprot.readFieldBegin()
14962 
      if ftype == TType.STOP:
14963 
        break
14964 
      if fid == 1:
14965 
        if ftype == TType.I64:
14966 
          self.providerId = iprot.readI64();
14967 
        else:
14968 
          iprot.skip(ftype)
14969 
      elif fid == 2:
14970 
        if ftype == TType.MAP:
14971 
          self.local_connected_orders = {}
6188 rajveer 14972 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
14973 
          for _i363 in xrange(_size359):
14974 
            _key364 = iprot.readString();
14975 
            _val365 = iprot.readString();
14976 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 14977 
          iprot.readMapEnd()
14978 
        else:
14979 
          iprot.skip(ftype)
14980 
      else:
14981 
        iprot.skip(ftype)
14982 
      iprot.readFieldEnd()
14983 
    iprot.readStructEnd()
14984 
 
14985 
  def write(self, oprot):
14986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14988 
      return
14989 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14990 
    if self.providerId is not None:
14991 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14992 
      oprot.writeI64(self.providerId)
14993 
      oprot.writeFieldEnd()
14994 
    if self.local_connected_orders is not None:
14995 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14996 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 14997 
      for kiter366,viter367 in self.local_connected_orders.items():
14998 
        oprot.writeString(kiter366)
14999 
        oprot.writeString(viter367)
4910 phani.kuma 15000 
      oprot.writeMapEnd()
15001 
      oprot.writeFieldEnd()
15002 
    oprot.writeFieldStop()
15003 
    oprot.writeStructEnd()
15004 
 
15005 
  def validate(self):
15006 
    return
15007 
 
15008 
 
15009 
  def __repr__(self):
15010 
    L = ['%s=%r' % (key, value)
15011 
      for key, value in self.__dict__.iteritems()]
15012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15013 
 
15014 
  def __eq__(self, other):
15015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15016 
 
15017 
  def __ne__(self, other):
15018 
    return not (self == other)
15019 
 
15020 
class markOrdersAsLocalConnected_result:
15021 
  """
15022 
  Attributes:
15023 
   - ex
15024 
  """
15025 
 
15026 
  thrift_spec = (
15027 
    None, # 0
15028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15029 
  )
15030 
 
15031 
  def __init__(self, ex=None,):
15032 
    self.ex = ex
15033 
 
15034 
  def read(self, iprot):
15035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15037 
      return
15038 
    iprot.readStructBegin()
15039 
    while True:
15040 
      (fname, ftype, fid) = iprot.readFieldBegin()
15041 
      if ftype == TType.STOP:
15042 
        break
15043 
      if fid == 1:
3064 chandransh 15044 
        if ftype == TType.STRUCT:
15045 
          self.ex = TransactionServiceException()
15046 
          self.ex.read(iprot)
1627 ankur.sing 15047 
        else:
15048 
          iprot.skip(ftype)
15049 
      else:
15050 
        iprot.skip(ftype)
15051 
      iprot.readFieldEnd()
15052 
    iprot.readStructEnd()
15053 
 
15054 
  def write(self, oprot):
15055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15057 
      return
4910 phani.kuma 15058 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15059 
    if self.ex is not None:
15060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15061 
      self.ex.write(oprot)
15062 
      oprot.writeFieldEnd()
15063 
    oprot.writeFieldStop()
15064 
    oprot.writeStructEnd()
15065 
 
15066 
  def validate(self):
15067 
    return
15068 
 
15069 
 
15070 
  def __repr__(self):
15071 
    L = ['%s=%r' % (key, value)
15072 
      for key, value in self.__dict__.iteritems()]
15073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15074 
 
15075 
  def __eq__(self, other):
15076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15077 
 
15078 
  def __ne__(self, other):
15079 
    return not (self == other)
15080 
 
15081 
class getOrdersNotLocalConnected_args:
15082 
  """
15083 
  Attributes:
15084 
   - providerId
15085 
  """
15086 
 
15087 
  thrift_spec = (
15088 
    None, # 0
15089 
    (1, TType.I64, 'providerId', None, None, ), # 1
15090 
  )
15091 
 
15092 
  def __init__(self, providerId=None,):
15093 
    self.providerId = providerId
15094 
 
15095 
  def read(self, iprot):
15096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15098 
      return
15099 
    iprot.readStructBegin()
15100 
    while True:
15101 
      (fname, ftype, fid) = iprot.readFieldBegin()
15102 
      if ftype == TType.STOP:
15103 
        break
15104 
      if fid == 1:
15105 
        if ftype == TType.I64:
15106 
          self.providerId = iprot.readI64();
15107 
        else:
15108 
          iprot.skip(ftype)
15109 
      else:
15110 
        iprot.skip(ftype)
15111 
      iprot.readFieldEnd()
15112 
    iprot.readStructEnd()
15113 
 
15114 
  def write(self, oprot):
15115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15117 
      return
15118 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15119 
    if self.providerId is not None:
15120 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15121 
      oprot.writeI64(self.providerId)
15122 
      oprot.writeFieldEnd()
15123 
    oprot.writeFieldStop()
15124 
    oprot.writeStructEnd()
15125 
 
15126 
  def validate(self):
15127 
    return
15128 
 
15129 
 
15130 
  def __repr__(self):
15131 
    L = ['%s=%r' % (key, value)
15132 
      for key, value in self.__dict__.iteritems()]
15133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15134 
 
15135 
  def __eq__(self, other):
15136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15137 
 
15138 
  def __ne__(self, other):
15139 
    return not (self == other)
15140 
 
15141 
class getOrdersNotLocalConnected_result:
15142 
  """
15143 
  Attributes:
15144 
   - success
15145 
  """
15146 
 
15147 
  thrift_spec = (
15148 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15149 
  )
15150 
 
15151 
  def __init__(self, success=None,):
15152 
    self.success = success
15153 
 
15154 
  def read(self, iprot):
15155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15157 
      return
15158 
    iprot.readStructBegin()
15159 
    while True:
15160 
      (fname, ftype, fid) = iprot.readFieldBegin()
15161 
      if ftype == TType.STOP:
15162 
        break
15163 
      if fid == 0:
15164 
        if ftype == TType.LIST:
15165 
          self.success = []
6188 rajveer 15166 
          (_etype371, _size368) = iprot.readListBegin()
15167 
          for _i372 in xrange(_size368):
15168 
            _elem373 = Order()
15169 
            _elem373.read(iprot)
15170 
            self.success.append(_elem373)
4910 phani.kuma 15171 
          iprot.readListEnd()
15172 
        else:
15173 
          iprot.skip(ftype)
15174 
      else:
15175 
        iprot.skip(ftype)
15176 
      iprot.readFieldEnd()
15177 
    iprot.readStructEnd()
15178 
 
15179 
  def write(self, oprot):
15180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15182 
      return
15183 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15184 
    if self.success is not None:
15185 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15186 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15187 
      for iter374 in self.success:
15188 
        iter374.write(oprot)
4581 phani.kuma 15189 
      oprot.writeListEnd()
15190 
      oprot.writeFieldEnd()
4910 phani.kuma 15191 
    oprot.writeFieldStop()
15192 
    oprot.writeStructEnd()
15193 
 
15194 
  def validate(self):
15195 
    return
15196 
 
15197 
 
15198 
  def __repr__(self):
15199 
    L = ['%s=%r' % (key, value)
15200 
      for key, value in self.__dict__.iteritems()]
15201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15202 
 
15203 
  def __eq__(self, other):
15204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15205 
 
15206 
  def __ne__(self, other):
15207 
    return not (self == other)
15208 
 
15209 
class markOrdersAsDestinationCityReached_args:
15210 
  """
15211 
  Attributes:
15212 
   - providerId
15213 
   - destination_city_reached_orders
15214 
  """
15215 
 
15216 
  thrift_spec = (
15217 
    None, # 0
15218 
    (1, TType.I64, 'providerId', None, None, ), # 1
15219 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15220 
  )
15221 
 
15222 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15223 
    self.providerId = providerId
15224 
    self.destination_city_reached_orders = destination_city_reached_orders
15225 
 
15226 
  def read(self, iprot):
15227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15229 
      return
15230 
    iprot.readStructBegin()
15231 
    while True:
15232 
      (fname, ftype, fid) = iprot.readFieldBegin()
15233 
      if ftype == TType.STOP:
15234 
        break
15235 
      if fid == 1:
15236 
        if ftype == TType.I64:
15237 
          self.providerId = iprot.readI64();
15238 
        else:
15239 
          iprot.skip(ftype)
15240 
      elif fid == 2:
15241 
        if ftype == TType.MAP:
15242 
          self.destination_city_reached_orders = {}
6188 rajveer 15243 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15244 
          for _i379 in xrange(_size375):
15245 
            _key380 = iprot.readString();
15246 
            _val381 = iprot.readString();
15247 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15248 
          iprot.readMapEnd()
15249 
        else:
15250 
          iprot.skip(ftype)
15251 
      else:
15252 
        iprot.skip(ftype)
15253 
      iprot.readFieldEnd()
15254 
    iprot.readStructEnd()
15255 
 
15256 
  def write(self, oprot):
15257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15259 
      return
15260 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15261 
    if self.providerId is not None:
15262 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15263 
      oprot.writeI64(self.providerId)
15264 
      oprot.writeFieldEnd()
15265 
    if self.destination_city_reached_orders is not None:
15266 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15267 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15268 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15269 
        oprot.writeString(kiter382)
15270 
        oprot.writeString(viter383)
4910 phani.kuma 15271 
      oprot.writeMapEnd()
15272 
      oprot.writeFieldEnd()
15273 
    oprot.writeFieldStop()
15274 
    oprot.writeStructEnd()
15275 
 
15276 
  def validate(self):
15277 
    return
15278 
 
15279 
 
15280 
  def __repr__(self):
15281 
    L = ['%s=%r' % (key, value)
15282 
      for key, value in self.__dict__.iteritems()]
15283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15284 
 
15285 
  def __eq__(self, other):
15286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15287 
 
15288 
  def __ne__(self, other):
15289 
    return not (self == other)
15290 
 
15291 
class markOrdersAsDestinationCityReached_result:
15292 
  """
15293 
  Attributes:
15294 
   - ex
15295 
  """
15296 
 
15297 
  thrift_spec = (
15298 
    None, # 0
15299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15300 
  )
15301 
 
15302 
  def __init__(self, ex=None,):
15303 
    self.ex = ex
15304 
 
15305 
  def read(self, iprot):
15306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15308 
      return
15309 
    iprot.readStructBegin()
15310 
    while True:
15311 
      (fname, ftype, fid) = iprot.readFieldBegin()
15312 
      if ftype == TType.STOP:
15313 
        break
15314 
      if fid == 1:
15315 
        if ftype == TType.STRUCT:
15316 
          self.ex = TransactionServiceException()
15317 
          self.ex.read(iprot)
15318 
        else:
15319 
          iprot.skip(ftype)
15320 
      else:
15321 
        iprot.skip(ftype)
15322 
      iprot.readFieldEnd()
15323 
    iprot.readStructEnd()
15324 
 
15325 
  def write(self, oprot):
15326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15328 
      return
15329 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15330 
    if self.ex is not None:
3064 chandransh 15331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15332 
      self.ex.write(oprot)
1627 ankur.sing 15333 
      oprot.writeFieldEnd()
15334 
    oprot.writeFieldStop()
15335 
    oprot.writeStructEnd()
15336 
 
3431 rajveer 15337 
  def validate(self):
15338 
    return
15339 
 
15340 
 
1627 ankur.sing 15341 
  def __repr__(self):
15342 
    L = ['%s=%r' % (key, value)
15343 
      for key, value in self.__dict__.iteritems()]
15344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15345 
 
15346 
  def __eq__(self, other):
15347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15348 
 
15349 
  def __ne__(self, other):
15350 
    return not (self == other)
15351 
 
4910 phani.kuma 15352 
class markOrdersAsFirstDeliveryAttempted_args:
15353 
  """
15354 
  Attributes:
15355 
   - providerId
15356 
   - first_atdl_orders
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    None, # 0
15361 
    (1, TType.I64, 'providerId', None, None, ), # 1
15362 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15363 
  )
15364 
 
15365 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15366 
    self.providerId = providerId
15367 
    self.first_atdl_orders = first_atdl_orders
15368 
 
15369 
  def read(self, iprot):
15370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15372 
      return
15373 
    iprot.readStructBegin()
15374 
    while True:
15375 
      (fname, ftype, fid) = iprot.readFieldBegin()
15376 
      if ftype == TType.STOP:
15377 
        break
15378 
      if fid == 1:
15379 
        if ftype == TType.I64:
15380 
          self.providerId = iprot.readI64();
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      elif fid == 2:
15384 
        if ftype == TType.MAP:
15385 
          self.first_atdl_orders = {}
6188 rajveer 15386 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15387 
          for _i388 in xrange(_size384):
15388 
            _key389 = iprot.readString();
15389 
            _val390 = iprot.readString();
15390 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15391 
          iprot.readMapEnd()
15392 
        else:
15393 
          iprot.skip(ftype)
15394 
      else:
15395 
        iprot.skip(ftype)
15396 
      iprot.readFieldEnd()
15397 
    iprot.readStructEnd()
15398 
 
15399 
  def write(self, oprot):
15400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15402 
      return
15403 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15404 
    if self.providerId is not None:
15405 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15406 
      oprot.writeI64(self.providerId)
15407 
      oprot.writeFieldEnd()
15408 
    if self.first_atdl_orders is not None:
15409 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15410 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15411 
      for kiter391,viter392 in self.first_atdl_orders.items():
15412 
        oprot.writeString(kiter391)
15413 
        oprot.writeString(viter392)
4910 phani.kuma 15414 
      oprot.writeMapEnd()
15415 
      oprot.writeFieldEnd()
15416 
    oprot.writeFieldStop()
15417 
    oprot.writeStructEnd()
15418 
 
15419 
  def validate(self):
15420 
    return
15421 
 
15422 
 
15423 
  def __repr__(self):
15424 
    L = ['%s=%r' % (key, value)
15425 
      for key, value in self.__dict__.iteritems()]
15426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15427 
 
15428 
  def __eq__(self, other):
15429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15430 
 
15431 
  def __ne__(self, other):
15432 
    return not (self == other)
15433 
 
15434 
class markOrdersAsFirstDeliveryAttempted_result:
15435 
  """
15436 
  Attributes:
15437 
   - ex
15438 
  """
15439 
 
15440 
  thrift_spec = (
15441 
    None, # 0
15442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15443 
  )
15444 
 
15445 
  def __init__(self, ex=None,):
15446 
    self.ex = ex
15447 
 
15448 
  def read(self, iprot):
15449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15451 
      return
15452 
    iprot.readStructBegin()
15453 
    while True:
15454 
      (fname, ftype, fid) = iprot.readFieldBegin()
15455 
      if ftype == TType.STOP:
15456 
        break
15457 
      if fid == 1:
15458 
        if ftype == TType.STRUCT:
15459 
          self.ex = TransactionServiceException()
15460 
          self.ex.read(iprot)
15461 
        else:
15462 
          iprot.skip(ftype)
15463 
      else:
15464 
        iprot.skip(ftype)
15465 
      iprot.readFieldEnd()
15466 
    iprot.readStructEnd()
15467 
 
15468 
  def write(self, oprot):
15469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15471 
      return
15472 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15473 
    if self.ex is not None:
15474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15475 
      self.ex.write(oprot)
15476 
      oprot.writeFieldEnd()
15477 
    oprot.writeFieldStop()
15478 
    oprot.writeStructEnd()
15479 
 
15480 
  def validate(self):
15481 
    return
15482 
 
15483 
 
15484 
  def __repr__(self):
15485 
    L = ['%s=%r' % (key, value)
15486 
      for key, value in self.__dict__.iteritems()]
15487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15488 
 
15489 
  def __eq__(self, other):
15490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15491 
 
15492 
  def __ne__(self, other):
15493 
    return not (self == other)
15494 
 
3064 chandransh 15495 
class getUndeliveredOrders_args:
1886 ankur.sing 15496 
  """
15497 
  Attributes:
3064 chandransh 15498 
   - providerId
15499 
   - warehouseId
1886 ankur.sing 15500 
  """
1627 ankur.sing 15501 
 
1886 ankur.sing 15502 
  thrift_spec = (
15503 
    None, # 0
3064 chandransh 15504 
    (1, TType.I64, 'providerId', None, None, ), # 1
15505 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15506 
  )
15507 
 
3064 chandransh 15508 
  def __init__(self, providerId=None, warehouseId=None,):
15509 
    self.providerId = providerId
15510 
    self.warehouseId = warehouseId
1886 ankur.sing 15511 
 
15512 
  def read(self, iprot):
15513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15515 
      return
15516 
    iprot.readStructBegin()
15517 
    while True:
15518 
      (fname, ftype, fid) = iprot.readFieldBegin()
15519 
      if ftype == TType.STOP:
15520 
        break
15521 
      if fid == 1:
15522 
        if ftype == TType.I64:
3064 chandransh 15523 
          self.providerId = iprot.readI64();
1886 ankur.sing 15524 
        else:
15525 
          iprot.skip(ftype)
3064 chandransh 15526 
      elif fid == 2:
15527 
        if ftype == TType.I64:
15528 
          self.warehouseId = iprot.readI64();
15529 
        else:
15530 
          iprot.skip(ftype)
1886 ankur.sing 15531 
      else:
15532 
        iprot.skip(ftype)
15533 
      iprot.readFieldEnd()
15534 
    iprot.readStructEnd()
15535 
 
15536 
  def write(self, oprot):
15537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15539 
      return
3064 chandransh 15540 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15541 
    if self.providerId is not None:
3064 chandransh 15542 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15543 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15544 
      oprot.writeFieldEnd()
3431 rajveer 15545 
    if self.warehouseId is not None:
3064 chandransh 15546 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15547 
      oprot.writeI64(self.warehouseId)
15548 
      oprot.writeFieldEnd()
1886 ankur.sing 15549 
    oprot.writeFieldStop()
15550 
    oprot.writeStructEnd()
15551 
 
3431 rajveer 15552 
  def validate(self):
15553 
    return
15554 
 
15555 
 
1886 ankur.sing 15556 
  def __repr__(self):
15557 
    L = ['%s=%r' % (key, value)
15558 
      for key, value in self.__dict__.iteritems()]
15559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15560 
 
15561 
  def __eq__(self, other):
15562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15563 
 
15564 
  def __ne__(self, other):
15565 
    return not (self == other)
15566 
 
3064 chandransh 15567 
class getUndeliveredOrders_result:
1886 ankur.sing 15568 
  """
15569 
  Attributes:
15570 
   - success
15571 
  """
15572 
 
15573 
  thrift_spec = (
15574 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15575 
  )
15576 
 
15577 
  def __init__(self, success=None,):
15578 
    self.success = success
15579 
 
15580 
  def read(self, iprot):
15581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15583 
      return
15584 
    iprot.readStructBegin()
15585 
    while True:
15586 
      (fname, ftype, fid) = iprot.readFieldBegin()
15587 
      if ftype == TType.STOP:
15588 
        break
15589 
      if fid == 0:
15590 
        if ftype == TType.LIST:
15591 
          self.success = []
6188 rajveer 15592 
          (_etype396, _size393) = iprot.readListBegin()
15593 
          for _i397 in xrange(_size393):
15594 
            _elem398 = Order()
15595 
            _elem398.read(iprot)
15596 
            self.success.append(_elem398)
1886 ankur.sing 15597 
          iprot.readListEnd()
15598 
        else:
15599 
          iprot.skip(ftype)
15600 
      else:
15601 
        iprot.skip(ftype)
15602 
      iprot.readFieldEnd()
15603 
    iprot.readStructEnd()
15604 
 
15605 
  def write(self, oprot):
15606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15608 
      return
3064 chandransh 15609 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15610 
    if self.success is not None:
1886 ankur.sing 15611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15612 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15613 
      for iter399 in self.success:
15614 
        iter399.write(oprot)
1886 ankur.sing 15615 
      oprot.writeListEnd()
15616 
      oprot.writeFieldEnd()
15617 
    oprot.writeFieldStop()
15618 
    oprot.writeStructEnd()
15619 
 
3431 rajveer 15620 
  def validate(self):
15621 
    return
15622 
 
15623 
 
1886 ankur.sing 15624 
  def __repr__(self):
15625 
    L = ['%s=%r' % (key, value)
15626 
      for key, value in self.__dict__.iteritems()]
15627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15628 
 
15629 
  def __eq__(self, other):
15630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15631 
 
15632 
  def __ne__(self, other):
15633 
    return not (self == other)
15634 
 
4783 phani.kuma 15635 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15636 
 
15637 
  thrift_spec = (
15638 
  )
15639 
 
15640 
  def read(self, iprot):
15641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15643 
      return
15644 
    iprot.readStructBegin()
15645 
    while True:
15646 
      (fname, ftype, fid) = iprot.readFieldBegin()
15647 
      if ftype == TType.STOP:
15648 
        break
15649 
      else:
15650 
        iprot.skip(ftype)
15651 
      iprot.readFieldEnd()
15652 
    iprot.readStructEnd()
15653 
 
15654 
  def write(self, oprot):
15655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15657 
      return
15658 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15659 
    oprot.writeFieldStop()
15660 
    oprot.writeStructEnd()
15661 
 
15662 
  def validate(self):
15663 
    return
15664 
 
15665 
 
15666 
  def __repr__(self):
15667 
    L = ['%s=%r' % (key, value)
15668 
      for key, value in self.__dict__.iteritems()]
15669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15670 
 
15671 
  def __eq__(self, other):
15672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15673 
 
15674 
  def __ne__(self, other):
15675 
    return not (self == other)
15676 
 
15677 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15678 
  """
15679 
  Attributes:
15680 
   - success
15681 
  """
15682 
 
15683 
  thrift_spec = (
15684 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15685 
  )
15686 
 
15687 
  def __init__(self, success=None,):
15688 
    self.success = success
15689 
 
15690 
  def read(self, iprot):
15691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15693 
      return
15694 
    iprot.readStructBegin()
15695 
    while True:
15696 
      (fname, ftype, fid) = iprot.readFieldBegin()
15697 
      if ftype == TType.STOP:
15698 
        break
15699 
      if fid == 0:
15700 
        if ftype == TType.LIST:
15701 
          self.success = []
6188 rajveer 15702 
          (_etype403, _size400) = iprot.readListBegin()
15703 
          for _i404 in xrange(_size400):
15704 
            _elem405 = Order()
15705 
            _elem405.read(iprot)
15706 
            self.success.append(_elem405)
4783 phani.kuma 15707 
          iprot.readListEnd()
15708 
        else:
15709 
          iprot.skip(ftype)
15710 
      else:
15711 
        iprot.skip(ftype)
15712 
      iprot.readFieldEnd()
15713 
    iprot.readStructEnd()
15714 
 
15715 
  def write(self, oprot):
15716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15718 
      return
15719 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15720 
    if self.success is not None:
15721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15722 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15723 
      for iter406 in self.success:
15724 
        iter406.write(oprot)
4783 phani.kuma 15725 
      oprot.writeListEnd()
15726 
      oprot.writeFieldEnd()
15727 
    oprot.writeFieldStop()
15728 
    oprot.writeStructEnd()
15729 
 
15730 
  def validate(self):
15731 
    return
15732 
 
15733 
 
15734 
  def __repr__(self):
15735 
    L = ['%s=%r' % (key, value)
15736 
      for key, value in self.__dict__.iteritems()]
15737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15738 
 
15739 
  def __eq__(self, other):
15740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15741 
 
15742 
  def __ne__(self, other):
15743 
    return not (self == other)
15744 
 
2536 chandransh 15745 
class toggleDOAFlag_args:
15746 
  """
15747 
  Attributes:
15748 
   - orderId
15749 
  """
1886 ankur.sing 15750 
 
2536 chandransh 15751 
  thrift_spec = (
15752 
    None, # 0
15753 
    (1, TType.I64, 'orderId', None, None, ), # 1
15754 
  )
15755 
 
15756 
  def __init__(self, orderId=None,):
15757 
    self.orderId = orderId
15758 
 
15759 
  def read(self, iprot):
15760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15762 
      return
15763 
    iprot.readStructBegin()
15764 
    while True:
15765 
      (fname, ftype, fid) = iprot.readFieldBegin()
15766 
      if ftype == TType.STOP:
15767 
        break
15768 
      if fid == 1:
15769 
        if ftype == TType.I64:
15770 
          self.orderId = iprot.readI64();
15771 
        else:
15772 
          iprot.skip(ftype)
15773 
      else:
15774 
        iprot.skip(ftype)
15775 
      iprot.readFieldEnd()
15776 
    iprot.readStructEnd()
15777 
 
15778 
  def write(self, oprot):
15779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15781 
      return
15782 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15783 
    if self.orderId is not None:
2536 chandransh 15784 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15785 
      oprot.writeI64(self.orderId)
15786 
      oprot.writeFieldEnd()
15787 
    oprot.writeFieldStop()
15788 
    oprot.writeStructEnd()
15789 
 
3431 rajveer 15790 
  def validate(self):
15791 
    return
15792 
 
15793 
 
2536 chandransh 15794 
  def __repr__(self):
15795 
    L = ['%s=%r' % (key, value)
15796 
      for key, value in self.__dict__.iteritems()]
15797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15798 
 
15799 
  def __eq__(self, other):
15800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15801 
 
15802 
  def __ne__(self, other):
15803 
    return not (self == other)
15804 
 
15805 
class toggleDOAFlag_result:
15806 
  """
15807 
  Attributes:
15808 
   - success
15809 
   - ex
15810 
  """
15811 
 
15812 
  thrift_spec = (
15813 
    (0, TType.BOOL, 'success', None, None, ), # 0
15814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15815 
  )
15816 
 
15817 
  def __init__(self, success=None, ex=None,):
15818 
    self.success = success
15819 
    self.ex = ex
15820 
 
15821 
  def read(self, iprot):
15822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15824 
      return
15825 
    iprot.readStructBegin()
15826 
    while True:
15827 
      (fname, ftype, fid) = iprot.readFieldBegin()
15828 
      if ftype == TType.STOP:
15829 
        break
15830 
      if fid == 0:
15831 
        if ftype == TType.BOOL:
15832 
          self.success = iprot.readBool();
15833 
        else:
15834 
          iprot.skip(ftype)
15835 
      elif fid == 1:
15836 
        if ftype == TType.STRUCT:
15837 
          self.ex = TransactionServiceException()
15838 
          self.ex.read(iprot)
15839 
        else:
15840 
          iprot.skip(ftype)
15841 
      else:
15842 
        iprot.skip(ftype)
15843 
      iprot.readFieldEnd()
15844 
    iprot.readStructEnd()
15845 
 
15846 
  def write(self, oprot):
15847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15849 
      return
15850 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15851 
    if self.success is not None:
2536 chandransh 15852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15853 
      oprot.writeBool(self.success)
15854 
      oprot.writeFieldEnd()
3431 rajveer 15855 
    if self.ex is not None:
2536 chandransh 15856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15857 
      self.ex.write(oprot)
15858 
      oprot.writeFieldEnd()
15859 
    oprot.writeFieldStop()
15860 
    oprot.writeStructEnd()
15861 
 
3431 rajveer 15862 
  def validate(self):
15863 
    return
15864 
 
15865 
 
2536 chandransh 15866 
  def __repr__(self):
15867 
    L = ['%s=%r' % (key, value)
15868 
      for key, value in self.__dict__.iteritems()]
15869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15870 
 
15871 
  def __eq__(self, other):
15872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15873 
 
15874 
  def __ne__(self, other):
15875 
    return not (self == other)
15876 
 
4712 rajveer 15877 
class markOrderAsDelivered_args:
15878 
  """
15879 
  Attributes:
15880 
   - orderId
15881 
   - deliveryTimestamp
15882 
   - receiver
15883 
  """
15884 
 
15885 
  thrift_spec = None
15886 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15887 
    self.orderId = orderId
15888 
    self.deliveryTimestamp = deliveryTimestamp
15889 
    self.receiver = receiver
15890 
 
15891 
  def read(self, iprot):
15892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15894 
      return
15895 
    iprot.readStructBegin()
15896 
    while True:
15897 
      (fname, ftype, fid) = iprot.readFieldBegin()
15898 
      if ftype == TType.STOP:
15899 
        break
15900 
      if fid == 1:
15901 
        if ftype == TType.I64:
15902 
          self.orderId = iprot.readI64();
15903 
        else:
15904 
          iprot.skip(ftype)
15905 
      elif fid == 2:
15906 
        if ftype == TType.I64:
15907 
          self.deliveryTimestamp = iprot.readI64();
15908 
        else:
15909 
          iprot.skip(ftype)
15910 
      elif fid == -1:
15911 
        if ftype == TType.STRING:
15912 
          self.receiver = iprot.readString();
15913 
        else:
15914 
          iprot.skip(ftype)
15915 
      else:
15916 
        iprot.skip(ftype)
15917 
      iprot.readFieldEnd()
15918 
    iprot.readStructEnd()
15919 
 
15920 
  def write(self, oprot):
15921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15923 
      return
15924 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15925 
    if self.receiver is not None:
15926 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15927 
      oprot.writeString(self.receiver)
15928 
      oprot.writeFieldEnd()
15929 
    if self.orderId is not None:
15930 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15931 
      oprot.writeI64(self.orderId)
15932 
      oprot.writeFieldEnd()
15933 
    if self.deliveryTimestamp is not None:
15934 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15935 
      oprot.writeI64(self.deliveryTimestamp)
15936 
      oprot.writeFieldEnd()
15937 
    oprot.writeFieldStop()
15938 
    oprot.writeStructEnd()
15939 
 
15940 
  def validate(self):
15941 
    return
15942 
 
15943 
 
15944 
  def __repr__(self):
15945 
    L = ['%s=%r' % (key, value)
15946 
      for key, value in self.__dict__.iteritems()]
15947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15948 
 
15949 
  def __eq__(self, other):
15950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15951 
 
15952 
  def __ne__(self, other):
15953 
    return not (self == other)
15954 
 
15955 
class markOrderAsDelivered_result:
15956 
  """
15957 
  Attributes:
15958 
   - ex
15959 
  """
15960 
 
15961 
  thrift_spec = (
15962 
    None, # 0
15963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15964 
  )
15965 
 
15966 
  def __init__(self, ex=None,):
15967 
    self.ex = ex
15968 
 
15969 
  def read(self, iprot):
15970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15972 
      return
15973 
    iprot.readStructBegin()
15974 
    while True:
15975 
      (fname, ftype, fid) = iprot.readFieldBegin()
15976 
      if ftype == TType.STOP:
15977 
        break
15978 
      if fid == 1:
15979 
        if ftype == TType.STRUCT:
15980 
          self.ex = TransactionServiceException()
15981 
          self.ex.read(iprot)
15982 
        else:
15983 
          iprot.skip(ftype)
15984 
      else:
15985 
        iprot.skip(ftype)
15986 
      iprot.readFieldEnd()
15987 
    iprot.readStructEnd()
15988 
 
15989 
  def write(self, oprot):
15990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15992 
      return
15993 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15994 
    if self.ex is not None:
15995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15996 
      self.ex.write(oprot)
15997 
      oprot.writeFieldEnd()
15998 
    oprot.writeFieldStop()
15999 
    oprot.writeStructEnd()
16000 
 
16001 
  def validate(self):
16002 
    return
16003 
 
16004 
 
16005 
  def __repr__(self):
16006 
    L = ['%s=%r' % (key, value)
16007 
      for key, value in self.__dict__.iteritems()]
16008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16009 
 
16010 
  def __eq__(self, other):
16011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16012 
 
16013 
  def __ne__(self, other):
16014 
    return not (self == other)
16015 
 
5553 rajveer 16016 
class markOrderAsReceivedAtStore_args:
16017 
  """
16018 
  Attributes:
16019 
   - orderId
16020 
   - deliveryTimestamp
16021 
  """
16022 
 
16023 
  thrift_spec = (
16024 
    None, # 0
16025 
    (1, TType.I64, 'orderId', None, None, ), # 1
16026 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16027 
  )
16028 
 
16029 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16030 
    self.orderId = orderId
16031 
    self.deliveryTimestamp = deliveryTimestamp
16032 
 
16033 
  def read(self, iprot):
16034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16036 
      return
16037 
    iprot.readStructBegin()
16038 
    while True:
16039 
      (fname, ftype, fid) = iprot.readFieldBegin()
16040 
      if ftype == TType.STOP:
16041 
        break
16042 
      if fid == 1:
16043 
        if ftype == TType.I64:
16044 
          self.orderId = iprot.readI64();
16045 
        else:
16046 
          iprot.skip(ftype)
16047 
      elif fid == 2:
16048 
        if ftype == TType.I64:
16049 
          self.deliveryTimestamp = iprot.readI64();
16050 
        else:
16051 
          iprot.skip(ftype)
16052 
      else:
16053 
        iprot.skip(ftype)
16054 
      iprot.readFieldEnd()
16055 
    iprot.readStructEnd()
16056 
 
16057 
  def write(self, oprot):
16058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16060 
      return
16061 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16062 
    if self.orderId is not None:
16063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16064 
      oprot.writeI64(self.orderId)
16065 
      oprot.writeFieldEnd()
16066 
    if self.deliveryTimestamp is not None:
16067 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16068 
      oprot.writeI64(self.deliveryTimestamp)
16069 
      oprot.writeFieldEnd()
16070 
    oprot.writeFieldStop()
16071 
    oprot.writeStructEnd()
16072 
 
16073 
  def validate(self):
16074 
    return
16075 
 
16076 
 
16077 
  def __repr__(self):
16078 
    L = ['%s=%r' % (key, value)
16079 
      for key, value in self.__dict__.iteritems()]
16080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16081 
 
16082 
  def __eq__(self, other):
16083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16084 
 
16085 
  def __ne__(self, other):
16086 
    return not (self == other)
16087 
 
16088 
class markOrderAsReceivedAtStore_result:
16089 
  """
16090 
  Attributes:
16091 
   - ex
16092 
  """
16093 
 
16094 
  thrift_spec = (
16095 
    None, # 0
16096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16097 
  )
16098 
 
16099 
  def __init__(self, ex=None,):
16100 
    self.ex = ex
16101 
 
16102 
  def read(self, iprot):
16103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16105 
      return
16106 
    iprot.readStructBegin()
16107 
    while True:
16108 
      (fname, ftype, fid) = iprot.readFieldBegin()
16109 
      if ftype == TType.STOP:
16110 
        break
16111 
      if fid == 1:
16112 
        if ftype == TType.STRUCT:
16113 
          self.ex = TransactionServiceException()
16114 
          self.ex.read(iprot)
16115 
        else:
16116 
          iprot.skip(ftype)
16117 
      else:
16118 
        iprot.skip(ftype)
16119 
      iprot.readFieldEnd()
16120 
    iprot.readStructEnd()
16121 
 
16122 
  def write(self, oprot):
16123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16125 
      return
16126 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16127 
    if self.ex is not None:
16128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16129 
      self.ex.write(oprot)
16130 
      oprot.writeFieldEnd()
16131 
    oprot.writeFieldStop()
16132 
    oprot.writeStructEnd()
16133 
 
16134 
  def validate(self):
16135 
    return
16136 
 
16137 
 
16138 
  def __repr__(self):
16139 
    L = ['%s=%r' % (key, value)
16140 
      for key, value in self.__dict__.iteritems()]
16141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16142 
 
16143 
  def __eq__(self, other):
16144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16145 
 
16146 
  def __ne__(self, other):
16147 
    return not (self == other)
16148 
 
4454 rajveer 16149 
class markOrderDoaRequestReceived_args:
16150 
  """
16151 
  Attributes:
16152 
   - orderId
16153 
  """
16154 
 
16155 
  thrift_spec = (
16156 
    None, # 0
16157 
    (1, TType.I64, 'orderId', None, None, ), # 1
16158 
  )
16159 
 
16160 
  def __init__(self, orderId=None,):
16161 
    self.orderId = orderId
16162 
 
16163 
  def read(self, iprot):
16164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16166 
      return
16167 
    iprot.readStructBegin()
16168 
    while True:
16169 
      (fname, ftype, fid) = iprot.readFieldBegin()
16170 
      if ftype == TType.STOP:
16171 
        break
16172 
      if fid == 1:
16173 
        if ftype == TType.I64:
16174 
          self.orderId = iprot.readI64();
16175 
        else:
16176 
          iprot.skip(ftype)
16177 
      else:
16178 
        iprot.skip(ftype)
16179 
      iprot.readFieldEnd()
16180 
    iprot.readStructEnd()
16181 
 
16182 
  def write(self, oprot):
16183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16185 
      return
16186 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16187 
    if self.orderId is not None:
16188 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16189 
      oprot.writeI64(self.orderId)
16190 
      oprot.writeFieldEnd()
16191 
    oprot.writeFieldStop()
16192 
    oprot.writeStructEnd()
16193 
 
16194 
  def validate(self):
16195 
    return
16196 
 
16197 
 
16198 
  def __repr__(self):
16199 
    L = ['%s=%r' % (key, value)
16200 
      for key, value in self.__dict__.iteritems()]
16201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16202 
 
16203 
  def __eq__(self, other):
16204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16205 
 
16206 
  def __ne__(self, other):
16207 
    return not (self == other)
16208 
 
16209 
class markOrderDoaRequestReceived_result:
16210 
  """
16211 
  Attributes:
16212 
   - success
16213 
   - ex
16214 
  """
16215 
 
16216 
  thrift_spec = (
16217 
    (0, TType.BOOL, 'success', None, None, ), # 0
16218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16219 
  )
16220 
 
16221 
  def __init__(self, success=None, ex=None,):
16222 
    self.success = success
16223 
    self.ex = ex
16224 
 
16225 
  def read(self, iprot):
16226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16228 
      return
16229 
    iprot.readStructBegin()
16230 
    while True:
16231 
      (fname, ftype, fid) = iprot.readFieldBegin()
16232 
      if ftype == TType.STOP:
16233 
        break
16234 
      if fid == 0:
16235 
        if ftype == TType.BOOL:
16236 
          self.success = iprot.readBool();
16237 
        else:
16238 
          iprot.skip(ftype)
16239 
      elif fid == 1:
16240 
        if ftype == TType.STRUCT:
16241 
          self.ex = TransactionServiceException()
16242 
          self.ex.read(iprot)
16243 
        else:
16244 
          iprot.skip(ftype)
16245 
      else:
16246 
        iprot.skip(ftype)
16247 
      iprot.readFieldEnd()
16248 
    iprot.readStructEnd()
16249 
 
16250 
  def write(self, oprot):
16251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16253 
      return
16254 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16255 
    if self.success is not None:
16256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16257 
      oprot.writeBool(self.success)
16258 
      oprot.writeFieldEnd()
16259 
    if self.ex is not None:
16260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16261 
      self.ex.write(oprot)
16262 
      oprot.writeFieldEnd()
16263 
    oprot.writeFieldStop()
16264 
    oprot.writeStructEnd()
16265 
 
16266 
  def validate(self):
16267 
    return
16268 
 
16269 
 
16270 
  def __repr__(self):
16271 
    L = ['%s=%r' % (key, value)
16272 
      for key, value in self.__dict__.iteritems()]
16273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16274 
 
16275 
  def __eq__(self, other):
16276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16277 
 
16278 
  def __ne__(self, other):
16279 
    return not (self == other)
16280 
 
16281 
class markOrderDoaRequestAuthorized_args:
16282 
  """
16283 
  Attributes:
16284 
   - orderId
16285 
   - isAuthorized
16286 
  """
16287 
 
16288 
  thrift_spec = (
16289 
    None, # 0
16290 
    (1, TType.I64, 'orderId', None, None, ), # 1
16291 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16292 
  )
16293 
 
16294 
  def __init__(self, orderId=None, isAuthorized=None,):
16295 
    self.orderId = orderId
16296 
    self.isAuthorized = isAuthorized
16297 
 
16298 
  def read(self, iprot):
16299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16301 
      return
16302 
    iprot.readStructBegin()
16303 
    while True:
16304 
      (fname, ftype, fid) = iprot.readFieldBegin()
16305 
      if ftype == TType.STOP:
16306 
        break
16307 
      if fid == 1:
16308 
        if ftype == TType.I64:
16309 
          self.orderId = iprot.readI64();
16310 
        else:
16311 
          iprot.skip(ftype)
16312 
      elif fid == 2:
16313 
        if ftype == TType.BOOL:
16314 
          self.isAuthorized = iprot.readBool();
16315 
        else:
16316 
          iprot.skip(ftype)
16317 
      else:
16318 
        iprot.skip(ftype)
16319 
      iprot.readFieldEnd()
16320 
    iprot.readStructEnd()
16321 
 
16322 
  def write(self, oprot):
16323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16325 
      return
16326 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16327 
    if self.orderId is not None:
16328 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16329 
      oprot.writeI64(self.orderId)
16330 
      oprot.writeFieldEnd()
16331 
    if self.isAuthorized is not None:
16332 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16333 
      oprot.writeBool(self.isAuthorized)
16334 
      oprot.writeFieldEnd()
16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
16352 
 
16353 
class markOrderDoaRequestAuthorized_result:
16354 
  """
16355 
  Attributes:
16356 
   - success
16357 
   - ex
16358 
  """
16359 
 
16360 
  thrift_spec = (
16361 
    (0, TType.BOOL, 'success', None, None, ), # 0
16362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16363 
  )
16364 
 
16365 
  def __init__(self, success=None, ex=None,):
16366 
    self.success = success
16367 
    self.ex = ex
16368 
 
16369 
  def read(self, iprot):
16370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16372 
      return
16373 
    iprot.readStructBegin()
16374 
    while True:
16375 
      (fname, ftype, fid) = iprot.readFieldBegin()
16376 
      if ftype == TType.STOP:
16377 
        break
16378 
      if fid == 0:
16379 
        if ftype == TType.BOOL:
16380 
          self.success = iprot.readBool();
16381 
        else:
16382 
          iprot.skip(ftype)
16383 
      elif fid == 1:
16384 
        if ftype == TType.STRUCT:
16385 
          self.ex = TransactionServiceException()
16386 
          self.ex.read(iprot)
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16399 
    if self.success is not None:
16400 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16401 
      oprot.writeBool(self.success)
16402 
      oprot.writeFieldEnd()
16403 
    if self.ex is not None:
16404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16405 
      self.ex.write(oprot)
16406 
      oprot.writeFieldEnd()
16407 
    oprot.writeFieldStop()
16408 
    oprot.writeStructEnd()
16409 
 
16410 
  def validate(self):
16411 
    return
16412 
 
16413 
 
16414 
  def __repr__(self):
16415 
    L = ['%s=%r' % (key, value)
16416 
      for key, value in self.__dict__.iteritems()]
16417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16418 
 
16419 
  def __eq__(self, other):
16420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16421 
 
16422 
  def __ne__(self, other):
16423 
    return not (self == other)
16424 
 
4488 rajveer 16425 
class markOrderReturnRequestReceived_args:
16426 
  """
16427 
  Attributes:
16428 
   - orderId
16429 
  """
16430 
 
16431 
  thrift_spec = (
16432 
    None, # 0
16433 
    (1, TType.I64, 'orderId', None, None, ), # 1
16434 
  )
16435 
 
16436 
  def __init__(self, orderId=None,):
16437 
    self.orderId = orderId
16438 
 
16439 
  def read(self, iprot):
16440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16442 
      return
16443 
    iprot.readStructBegin()
16444 
    while True:
16445 
      (fname, ftype, fid) = iprot.readFieldBegin()
16446 
      if ftype == TType.STOP:
16447 
        break
16448 
      if fid == 1:
16449 
        if ftype == TType.I64:
16450 
          self.orderId = iprot.readI64();
16451 
        else:
16452 
          iprot.skip(ftype)
16453 
      else:
16454 
        iprot.skip(ftype)
16455 
      iprot.readFieldEnd()
16456 
    iprot.readStructEnd()
16457 
 
16458 
  def write(self, oprot):
16459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16461 
      return
16462 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16463 
    if self.orderId is not None:
16464 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16465 
      oprot.writeI64(self.orderId)
16466 
      oprot.writeFieldEnd()
16467 
    oprot.writeFieldStop()
16468 
    oprot.writeStructEnd()
16469 
 
16470 
  def validate(self):
16471 
    return
16472 
 
16473 
 
16474 
  def __repr__(self):
16475 
    L = ['%s=%r' % (key, value)
16476 
      for key, value in self.__dict__.iteritems()]
16477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16478 
 
16479 
  def __eq__(self, other):
16480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16481 
 
16482 
  def __ne__(self, other):
16483 
    return not (self == other)
16484 
 
16485 
class markOrderReturnRequestReceived_result:
16486 
  """
16487 
  Attributes:
16488 
   - success
16489 
   - ex
16490 
  """
16491 
 
16492 
  thrift_spec = (
16493 
    (0, TType.BOOL, 'success', None, None, ), # 0
16494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16495 
  )
16496 
 
16497 
  def __init__(self, success=None, ex=None,):
16498 
    self.success = success
16499 
    self.ex = ex
16500 
 
16501 
  def read(self, iprot):
16502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16504 
      return
16505 
    iprot.readStructBegin()
16506 
    while True:
16507 
      (fname, ftype, fid) = iprot.readFieldBegin()
16508 
      if ftype == TType.STOP:
16509 
        break
16510 
      if fid == 0:
16511 
        if ftype == TType.BOOL:
16512 
          self.success = iprot.readBool();
16513 
        else:
16514 
          iprot.skip(ftype)
16515 
      elif fid == 1:
16516 
        if ftype == TType.STRUCT:
16517 
          self.ex = TransactionServiceException()
16518 
          self.ex.read(iprot)
16519 
        else:
16520 
          iprot.skip(ftype)
16521 
      else:
16522 
        iprot.skip(ftype)
16523 
      iprot.readFieldEnd()
16524 
    iprot.readStructEnd()
16525 
 
16526 
  def write(self, oprot):
16527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16529 
      return
16530 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16531 
    if self.success is not None:
16532 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16533 
      oprot.writeBool(self.success)
16534 
      oprot.writeFieldEnd()
16535 
    if self.ex is not None:
16536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16537 
      self.ex.write(oprot)
16538 
      oprot.writeFieldEnd()
16539 
    oprot.writeFieldStop()
16540 
    oprot.writeStructEnd()
16541 
 
16542 
  def validate(self):
16543 
    return
16544 
 
16545 
 
16546 
  def __repr__(self):
16547 
    L = ['%s=%r' % (key, value)
16548 
      for key, value in self.__dict__.iteritems()]
16549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16550 
 
16551 
  def __eq__(self, other):
16552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16553 
 
16554 
  def __ne__(self, other):
16555 
    return not (self == other)
16556 
 
16557 
class markOrderReturnRequestAuthorized_args:
16558 
  """
16559 
  Attributes:
16560 
   - orderId
16561 
   - isAuthorized
16562 
  """
16563 
 
16564 
  thrift_spec = (
16565 
    None, # 0
16566 
    (1, TType.I64, 'orderId', None, None, ), # 1
16567 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16568 
  )
16569 
 
16570 
  def __init__(self, orderId=None, isAuthorized=None,):
16571 
    self.orderId = orderId
16572 
    self.isAuthorized = isAuthorized
16573 
 
16574 
  def read(self, iprot):
16575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16577 
      return
16578 
    iprot.readStructBegin()
16579 
    while True:
16580 
      (fname, ftype, fid) = iprot.readFieldBegin()
16581 
      if ftype == TType.STOP:
16582 
        break
16583 
      if fid == 1:
16584 
        if ftype == TType.I64:
16585 
          self.orderId = iprot.readI64();
16586 
        else:
16587 
          iprot.skip(ftype)
16588 
      elif fid == 2:
16589 
        if ftype == TType.BOOL:
16590 
          self.isAuthorized = iprot.readBool();
16591 
        else:
16592 
          iprot.skip(ftype)
16593 
      else:
16594 
        iprot.skip(ftype)
16595 
      iprot.readFieldEnd()
16596 
    iprot.readStructEnd()
16597 
 
16598 
  def write(self, oprot):
16599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16601 
      return
16602 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16603 
    if self.orderId is not None:
16604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16605 
      oprot.writeI64(self.orderId)
16606 
      oprot.writeFieldEnd()
16607 
    if self.isAuthorized is not None:
16608 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16609 
      oprot.writeBool(self.isAuthorized)
16610 
      oprot.writeFieldEnd()
16611 
    oprot.writeFieldStop()
16612 
    oprot.writeStructEnd()
16613 
 
16614 
  def validate(self):
16615 
    return
16616 
 
16617 
 
16618 
  def __repr__(self):
16619 
    L = ['%s=%r' % (key, value)
16620 
      for key, value in self.__dict__.iteritems()]
16621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16622 
 
16623 
  def __eq__(self, other):
16624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16625 
 
16626 
  def __ne__(self, other):
16627 
    return not (self == other)
16628 
 
16629 
class markOrderReturnRequestAuthorized_result:
16630 
  """
16631 
  Attributes:
16632 
   - success
16633 
   - ex
16634 
  """
16635 
 
16636 
  thrift_spec = (
16637 
    (0, TType.BOOL, 'success', None, None, ), # 0
16638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16639 
  )
16640 
 
16641 
  def __init__(self, success=None, ex=None,):
16642 
    self.success = success
16643 
    self.ex = ex
16644 
 
16645 
  def read(self, iprot):
16646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16648 
      return
16649 
    iprot.readStructBegin()
16650 
    while True:
16651 
      (fname, ftype, fid) = iprot.readFieldBegin()
16652 
      if ftype == TType.STOP:
16653 
        break
16654 
      if fid == 0:
16655 
        if ftype == TType.BOOL:
16656 
          self.success = iprot.readBool();
16657 
        else:
16658 
          iprot.skip(ftype)
16659 
      elif fid == 1:
16660 
        if ftype == TType.STRUCT:
16661 
          self.ex = TransactionServiceException()
16662 
          self.ex.read(iprot)
16663 
        else:
16664 
          iprot.skip(ftype)
16665 
      else:
16666 
        iprot.skip(ftype)
16667 
      iprot.readFieldEnd()
16668 
    iprot.readStructEnd()
16669 
 
16670 
  def write(self, oprot):
16671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16673 
      return
16674 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16675 
    if self.success is not None:
16676 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16677 
      oprot.writeBool(self.success)
16678 
      oprot.writeFieldEnd()
16679 
    if self.ex is not None:
16680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16681 
      self.ex.write(oprot)
16682 
      oprot.writeFieldEnd()
16683 
    oprot.writeFieldStop()
16684 
    oprot.writeStructEnd()
16685 
 
16686 
  def validate(self):
16687 
    return
16688 
 
16689 
 
16690 
  def __repr__(self):
16691 
    L = ['%s=%r' % (key, value)
16692 
      for key, value in self.__dict__.iteritems()]
16693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16694 
 
16695 
  def __eq__(self, other):
16696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16697 
 
16698 
  def __ne__(self, other):
16699 
    return not (self == other)
16700 
 
2536 chandransh 16701 
class requestPickupNumber_args:
16702 
  """
16703 
  Attributes:
16704 
   - orderId
4579 rajveer 16705 
   - providerId
2536 chandransh 16706 
  """
16707 
 
16708 
  thrift_spec = (
16709 
    None, # 0
16710 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16711 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16712 
  )
16713 
 
4579 rajveer 16714 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16715 
    self.orderId = orderId
4579 rajveer 16716 
    self.providerId = providerId
2536 chandransh 16717 
 
16718 
  def read(self, iprot):
16719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16721 
      return
16722 
    iprot.readStructBegin()
16723 
    while True:
16724 
      (fname, ftype, fid) = iprot.readFieldBegin()
16725 
      if ftype == TType.STOP:
16726 
        break
16727 
      if fid == 1:
16728 
        if ftype == TType.I64:
16729 
          self.orderId = iprot.readI64();
16730 
        else:
16731 
          iprot.skip(ftype)
4579 rajveer 16732 
      elif fid == 2:
16733 
        if ftype == TType.I64:
16734 
          self.providerId = iprot.readI64();
16735 
        else:
16736 
          iprot.skip(ftype)
2536 chandransh 16737 
      else:
16738 
        iprot.skip(ftype)
16739 
      iprot.readFieldEnd()
16740 
    iprot.readStructEnd()
16741 
 
16742 
  def write(self, oprot):
16743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16745 
      return
16746 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16747 
    if self.orderId is not None:
2536 chandransh 16748 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16749 
      oprot.writeI64(self.orderId)
16750 
      oprot.writeFieldEnd()
4579 rajveer 16751 
    if self.providerId is not None:
16752 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16753 
      oprot.writeI64(self.providerId)
16754 
      oprot.writeFieldEnd()
2536 chandransh 16755 
    oprot.writeFieldStop()
16756 
    oprot.writeStructEnd()
16757 
 
3431 rajveer 16758 
  def validate(self):
16759 
    return
16760 
 
16761 
 
2536 chandransh 16762 
  def __repr__(self):
16763 
    L = ['%s=%r' % (key, value)
16764 
      for key, value in self.__dict__.iteritems()]
16765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16766 
 
16767 
  def __eq__(self, other):
16768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16769 
 
16770 
  def __ne__(self, other):
16771 
    return not (self == other)
16772 
 
16773 
class requestPickupNumber_result:
16774 
  """
16775 
  Attributes:
16776 
   - success
16777 
   - ex
16778 
  """
16779 
 
16780 
  thrift_spec = (
16781 
    (0, TType.BOOL, 'success', None, None, ), # 0
16782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16783 
  )
16784 
 
16785 
  def __init__(self, success=None, ex=None,):
16786 
    self.success = success
16787 
    self.ex = ex
16788 
 
16789 
  def read(self, iprot):
16790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16792 
      return
16793 
    iprot.readStructBegin()
16794 
    while True:
16795 
      (fname, ftype, fid) = iprot.readFieldBegin()
16796 
      if ftype == TType.STOP:
16797 
        break
16798 
      if fid == 0:
16799 
        if ftype == TType.BOOL:
16800 
          self.success = iprot.readBool();
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      elif fid == 1:
16804 
        if ftype == TType.STRUCT:
16805 
          self.ex = TransactionServiceException()
16806 
          self.ex.read(iprot)
16807 
        else:
16808 
          iprot.skip(ftype)
16809 
      else:
16810 
        iprot.skip(ftype)
16811 
      iprot.readFieldEnd()
16812 
    iprot.readStructEnd()
16813 
 
16814 
  def write(self, oprot):
16815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16817 
      return
16818 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16819 
    if self.success is not None:
2536 chandransh 16820 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16821 
      oprot.writeBool(self.success)
16822 
      oprot.writeFieldEnd()
3431 rajveer 16823 
    if self.ex is not None:
2536 chandransh 16824 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16825 
      self.ex.write(oprot)
16826 
      oprot.writeFieldEnd()
16827 
    oprot.writeFieldStop()
16828 
    oprot.writeStructEnd()
16829 
 
3431 rajveer 16830 
  def validate(self):
16831 
    return
16832 
 
16833 
 
2536 chandransh 16834 
  def __repr__(self):
16835 
    L = ['%s=%r' % (key, value)
16836 
      for key, value in self.__dict__.iteritems()]
16837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16838 
 
16839 
  def __eq__(self, other):
16840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16841 
 
16842 
  def __ne__(self, other):
16843 
    return not (self == other)
16844 
 
16845 
class authorizePickup_args:
16846 
  """
16847 
  Attributes:
16848 
   - orderId
16849 
   - pickupNumber
4602 rajveer 16850 
   - providerId
2536 chandransh 16851 
  """
16852 
 
16853 
  thrift_spec = (
16854 
    None, # 0
16855 
    (1, TType.I64, 'orderId', None, None, ), # 1
16856 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16857 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16858 
  )
16859 
 
4602 rajveer 16860 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16861 
    self.orderId = orderId
16862 
    self.pickupNumber = pickupNumber
4602 rajveer 16863 
    self.providerId = providerId
2536 chandransh 16864 
 
16865 
  def read(self, iprot):
16866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16868 
      return
16869 
    iprot.readStructBegin()
16870 
    while True:
16871 
      (fname, ftype, fid) = iprot.readFieldBegin()
16872 
      if ftype == TType.STOP:
16873 
        break
16874 
      if fid == 1:
16875 
        if ftype == TType.I64:
16876 
          self.orderId = iprot.readI64();
16877 
        else:
16878 
          iprot.skip(ftype)
16879 
      elif fid == 2:
16880 
        if ftype == TType.STRING:
16881 
          self.pickupNumber = iprot.readString();
16882 
        else:
16883 
          iprot.skip(ftype)
4602 rajveer 16884 
      elif fid == 3:
16885 
        if ftype == TType.I64:
16886 
          self.providerId = iprot.readI64();
16887 
        else:
16888 
          iprot.skip(ftype)
2536 chandransh 16889 
      else:
16890 
        iprot.skip(ftype)
16891 
      iprot.readFieldEnd()
16892 
    iprot.readStructEnd()
16893 
 
16894 
  def write(self, oprot):
16895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16897 
      return
16898 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16899 
    if self.orderId is not None:
2536 chandransh 16900 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16901 
      oprot.writeI64(self.orderId)
16902 
      oprot.writeFieldEnd()
3431 rajveer 16903 
    if self.pickupNumber is not None:
2536 chandransh 16904 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16905 
      oprot.writeString(self.pickupNumber)
16906 
      oprot.writeFieldEnd()
4602 rajveer 16907 
    if self.providerId is not None:
16908 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16909 
      oprot.writeI64(self.providerId)
16910 
      oprot.writeFieldEnd()
2536 chandransh 16911 
    oprot.writeFieldStop()
16912 
    oprot.writeStructEnd()
16913 
 
3431 rajveer 16914 
  def validate(self):
16915 
    return
16916 
 
16917 
 
2536 chandransh 16918 
  def __repr__(self):
16919 
    L = ['%s=%r' % (key, value)
16920 
      for key, value in self.__dict__.iteritems()]
16921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16922 
 
16923 
  def __eq__(self, other):
16924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16925 
 
16926 
  def __ne__(self, other):
16927 
    return not (self == other)
16928 
 
16929 
class authorizePickup_result:
16930 
  """
16931 
  Attributes:
16932 
   - success
16933 
   - ex
16934 
  """
16935 
 
16936 
  thrift_spec = (
16937 
    (0, TType.BOOL, 'success', None, None, ), # 0
16938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16939 
  )
16940 
 
16941 
  def __init__(self, success=None, ex=None,):
16942 
    self.success = success
16943 
    self.ex = ex
16944 
 
16945 
  def read(self, iprot):
16946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16948 
      return
16949 
    iprot.readStructBegin()
16950 
    while True:
16951 
      (fname, ftype, fid) = iprot.readFieldBegin()
16952 
      if ftype == TType.STOP:
16953 
        break
16954 
      if fid == 0:
16955 
        if ftype == TType.BOOL:
16956 
          self.success = iprot.readBool();
16957 
        else:
16958 
          iprot.skip(ftype)
16959 
      elif fid == 1:
16960 
        if ftype == TType.STRUCT:
16961 
          self.ex = TransactionServiceException()
16962 
          self.ex.read(iprot)
16963 
        else:
16964 
          iprot.skip(ftype)
16965 
      else:
16966 
        iprot.skip(ftype)
16967 
      iprot.readFieldEnd()
16968 
    iprot.readStructEnd()
16969 
 
16970 
  def write(self, oprot):
16971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16973 
      return
16974 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16975 
    if self.success is not None:
2536 chandransh 16976 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16977 
      oprot.writeBool(self.success)
16978 
      oprot.writeFieldEnd()
3431 rajveer 16979 
    if self.ex is not None:
2536 chandransh 16980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16981 
      self.ex.write(oprot)
16982 
      oprot.writeFieldEnd()
16983 
    oprot.writeFieldStop()
16984 
    oprot.writeStructEnd()
16985 
 
3431 rajveer 16986 
  def validate(self):
16987 
    return
16988 
 
16989 
 
2536 chandransh 16990 
  def __repr__(self):
16991 
    L = ['%s=%r' % (key, value)
16992 
      for key, value in self.__dict__.iteritems()]
16993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16994 
 
16995 
  def __eq__(self, other):
16996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16997 
 
16998 
  def __ne__(self, other):
16999 
    return not (self == other)
17000 
 
2764 chandransh 17001 
class markDoasAsPickedUp_args:
17002 
  """
17003 
  Attributes:
17004 
   - providerId
17005 
   - pickupDetails
17006 
  """
17007 
 
17008 
  thrift_spec = (
17009 
    None, # 0
17010 
    (1, TType.I64, 'providerId', None, None, ), # 1
17011 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17012 
  )
17013 
 
17014 
  def __init__(self, providerId=None, pickupDetails=None,):
17015 
    self.providerId = providerId
17016 
    self.pickupDetails = pickupDetails
17017 
 
17018 
  def read(self, iprot):
17019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17021 
      return
17022 
    iprot.readStructBegin()
17023 
    while True:
17024 
      (fname, ftype, fid) = iprot.readFieldBegin()
17025 
      if ftype == TType.STOP:
17026 
        break
17027 
      if fid == 1:
17028 
        if ftype == TType.I64:
17029 
          self.providerId = iprot.readI64();
17030 
        else:
17031 
          iprot.skip(ftype)
17032 
      elif fid == 2:
17033 
        if ftype == TType.MAP:
17034 
          self.pickupDetails = {}
6188 rajveer 17035 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17036 
          for _i411 in xrange(_size407):
17037 
            _key412 = iprot.readString();
17038 
            _val413 = iprot.readString();
17039 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17040 
          iprot.readMapEnd()
17041 
        else:
17042 
          iprot.skip(ftype)
17043 
      else:
17044 
        iprot.skip(ftype)
17045 
      iprot.readFieldEnd()
17046 
    iprot.readStructEnd()
17047 
 
17048 
  def write(self, oprot):
17049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17051 
      return
17052 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17053 
    if self.providerId is not None:
2764 chandransh 17054 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17055 
      oprot.writeI64(self.providerId)
17056 
      oprot.writeFieldEnd()
3431 rajveer 17057 
    if self.pickupDetails is not None:
2764 chandransh 17058 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17059 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17060 
      for kiter414,viter415 in self.pickupDetails.items():
17061 
        oprot.writeString(kiter414)
17062 
        oprot.writeString(viter415)
2764 chandransh 17063 
      oprot.writeMapEnd()
17064 
      oprot.writeFieldEnd()
17065 
    oprot.writeFieldStop()
17066 
    oprot.writeStructEnd()
17067 
 
3431 rajveer 17068 
  def validate(self):
17069 
    return
17070 
 
17071 
 
2764 chandransh 17072 
  def __repr__(self):
17073 
    L = ['%s=%r' % (key, value)
17074 
      for key, value in self.__dict__.iteritems()]
17075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17076 
 
17077 
  def __eq__(self, other):
17078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17079 
 
17080 
  def __ne__(self, other):
17081 
    return not (self == other)
17082 
 
17083 
class markDoasAsPickedUp_result:
4910 phani.kuma 17084 
 
17085 
  thrift_spec = (
17086 
  )
17087 
 
17088 
  def read(self, iprot):
17089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17091 
      return
17092 
    iprot.readStructBegin()
17093 
    while True:
17094 
      (fname, ftype, fid) = iprot.readFieldBegin()
17095 
      if ftype == TType.STOP:
17096 
        break
17097 
      else:
17098 
        iprot.skip(ftype)
17099 
      iprot.readFieldEnd()
17100 
    iprot.readStructEnd()
17101 
 
17102 
  def write(self, oprot):
17103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17105 
      return
17106 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17107 
    oprot.writeFieldStop()
17108 
    oprot.writeStructEnd()
17109 
 
17110 
  def validate(self):
17111 
    return
17112 
 
17113 
 
17114 
  def __repr__(self):
17115 
    L = ['%s=%r' % (key, value)
17116 
      for key, value in self.__dict__.iteritems()]
17117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17118 
 
17119 
  def __eq__(self, other):
17120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17121 
 
17122 
  def __ne__(self, other):
17123 
    return not (self == other)
17124 
 
17125 
class getDoasNotPickedUp_args:
2764 chandransh 17126 
  """
17127 
  Attributes:
4910 phani.kuma 17128 
   - providerId
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    None, # 0
17133 
    (1, TType.I64, 'providerId', None, None, ), # 1
17134 
  )
17135 
 
17136 
  def __init__(self, providerId=None,):
17137 
    self.providerId = providerId
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      if fid == 1:
17149 
        if ftype == TType.I64:
17150 
          self.providerId = iprot.readI64();
17151 
        else:
17152 
          iprot.skip(ftype)
17153 
      else:
17154 
        iprot.skip(ftype)
17155 
      iprot.readFieldEnd()
17156 
    iprot.readStructEnd()
17157 
 
17158 
  def write(self, oprot):
17159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17161 
      return
17162 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17163 
    if self.providerId is not None:
17164 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17165 
      oprot.writeI64(self.providerId)
17166 
      oprot.writeFieldEnd()
17167 
    oprot.writeFieldStop()
17168 
    oprot.writeStructEnd()
17169 
 
17170 
  def validate(self):
17171 
    return
17172 
 
17173 
 
17174 
  def __repr__(self):
17175 
    L = ['%s=%r' % (key, value)
17176 
      for key, value in self.__dict__.iteritems()]
17177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17178 
 
17179 
  def __eq__(self, other):
17180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17181 
 
17182 
  def __ne__(self, other):
17183 
    return not (self == other)
17184 
 
17185 
class getDoasNotPickedUp_result:
17186 
  """
17187 
  Attributes:
2764 chandransh 17188 
   - success
17189 
  """
17190 
 
17191 
  thrift_spec = (
17192 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17193 
  )
17194 
 
17195 
  def __init__(self, success=None,):
17196 
    self.success = success
17197 
 
17198 
  def read(self, iprot):
17199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17201 
      return
17202 
    iprot.readStructBegin()
17203 
    while True:
17204 
      (fname, ftype, fid) = iprot.readFieldBegin()
17205 
      if ftype == TType.STOP:
17206 
        break
17207 
      if fid == 0:
17208 
        if ftype == TType.LIST:
17209 
          self.success = []
6188 rajveer 17210 
          (_etype419, _size416) = iprot.readListBegin()
17211 
          for _i420 in xrange(_size416):
17212 
            _elem421 = Order()
17213 
            _elem421.read(iprot)
17214 
            self.success.append(_elem421)
2764 chandransh 17215 
          iprot.readListEnd()
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
4910 phani.kuma 17227 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17228 
    if self.success is not None:
2764 chandransh 17229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17231 
      for iter422 in self.success:
17232 
        iter422.write(oprot)
2764 chandransh 17233 
      oprot.writeListEnd()
17234 
      oprot.writeFieldEnd()
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
3431 rajveer 17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
2764 chandransh 17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
4741 phani.kuma 17253 
class markReturnOrdersAsPickedUp_args:
17254 
  """
17255 
  Attributes:
17256 
   - providerId
17257 
   - pickupDetails
17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    None, # 0
17262 
    (1, TType.I64, 'providerId', None, None, ), # 1
17263 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17264 
  )
17265 
 
17266 
  def __init__(self, providerId=None, pickupDetails=None,):
17267 
    self.providerId = providerId
17268 
    self.pickupDetails = pickupDetails
17269 
 
17270 
  def read(self, iprot):
17271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17273 
      return
17274 
    iprot.readStructBegin()
17275 
    while True:
17276 
      (fname, ftype, fid) = iprot.readFieldBegin()
17277 
      if ftype == TType.STOP:
17278 
        break
17279 
      if fid == 1:
17280 
        if ftype == TType.I64:
17281 
          self.providerId = iprot.readI64();
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      elif fid == 2:
17285 
        if ftype == TType.MAP:
17286 
          self.pickupDetails = {}
6188 rajveer 17287 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17288 
          for _i427 in xrange(_size423):
17289 
            _key428 = iprot.readString();
17290 
            _val429 = iprot.readString();
17291 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17292 
          iprot.readMapEnd()
17293 
        else:
17294 
          iprot.skip(ftype)
17295 
      else:
17296 
        iprot.skip(ftype)
17297 
      iprot.readFieldEnd()
17298 
    iprot.readStructEnd()
17299 
 
17300 
  def write(self, oprot):
17301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17303 
      return
17304 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17305 
    if self.providerId is not None:
17306 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17307 
      oprot.writeI64(self.providerId)
17308 
      oprot.writeFieldEnd()
17309 
    if self.pickupDetails is not None:
17310 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17311 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17312 
      for kiter430,viter431 in self.pickupDetails.items():
17313 
        oprot.writeString(kiter430)
17314 
        oprot.writeString(viter431)
4741 phani.kuma 17315 
      oprot.writeMapEnd()
17316 
      oprot.writeFieldEnd()
17317 
    oprot.writeFieldStop()
17318 
    oprot.writeStructEnd()
17319 
 
17320 
  def validate(self):
17321 
    return
17322 
 
17323 
 
17324 
  def __repr__(self):
17325 
    L = ['%s=%r' % (key, value)
17326 
      for key, value in self.__dict__.iteritems()]
17327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17328 
 
17329 
  def __eq__(self, other):
17330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17331 
 
17332 
  def __ne__(self, other):
17333 
    return not (self == other)
17334 
 
17335 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17336 
 
17337 
  thrift_spec = (
17338 
  )
17339 
 
17340 
  def read(self, iprot):
17341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17343 
      return
17344 
    iprot.readStructBegin()
17345 
    while True:
17346 
      (fname, ftype, fid) = iprot.readFieldBegin()
17347 
      if ftype == TType.STOP:
17348 
        break
17349 
      else:
17350 
        iprot.skip(ftype)
17351 
      iprot.readFieldEnd()
17352 
    iprot.readStructEnd()
17353 
 
17354 
  def write(self, oprot):
17355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17357 
      return
17358 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17359 
    oprot.writeFieldStop()
17360 
    oprot.writeStructEnd()
17361 
 
17362 
  def validate(self):
17363 
    return
17364 
 
17365 
 
17366 
  def __repr__(self):
17367 
    L = ['%s=%r' % (key, value)
17368 
      for key, value in self.__dict__.iteritems()]
17369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17370 
 
17371 
  def __eq__(self, other):
17372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17373 
 
17374 
  def __ne__(self, other):
17375 
    return not (self == other)
17376 
 
17377 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17378 
  """
17379 
  Attributes:
4910 phani.kuma 17380 
   - providerId
17381 
  """
17382 
 
17383 
  thrift_spec = (
17384 
    None, # 0
17385 
    (1, TType.I64, 'providerId', None, None, ), # 1
17386 
  )
17387 
 
17388 
  def __init__(self, providerId=None,):
17389 
    self.providerId = providerId
17390 
 
17391 
  def read(self, iprot):
17392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17394 
      return
17395 
    iprot.readStructBegin()
17396 
    while True:
17397 
      (fname, ftype, fid) = iprot.readFieldBegin()
17398 
      if ftype == TType.STOP:
17399 
        break
17400 
      if fid == 1:
17401 
        if ftype == TType.I64:
17402 
          self.providerId = iprot.readI64();
17403 
        else:
17404 
          iprot.skip(ftype)
17405 
      else:
17406 
        iprot.skip(ftype)
17407 
      iprot.readFieldEnd()
17408 
    iprot.readStructEnd()
17409 
 
17410 
  def write(self, oprot):
17411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17413 
      return
17414 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17415 
    if self.providerId is not None:
17416 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17417 
      oprot.writeI64(self.providerId)
17418 
      oprot.writeFieldEnd()
17419 
    oprot.writeFieldStop()
17420 
    oprot.writeStructEnd()
17421 
 
17422 
  def validate(self):
17423 
    return
17424 
 
17425 
 
17426 
  def __repr__(self):
17427 
    L = ['%s=%r' % (key, value)
17428 
      for key, value in self.__dict__.iteritems()]
17429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17430 
 
17431 
  def __eq__(self, other):
17432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17433 
 
17434 
  def __ne__(self, other):
17435 
    return not (self == other)
17436 
 
17437 
class getReturnOrdersNotPickedUp_result:
17438 
  """
17439 
  Attributes:
4741 phani.kuma 17440 
   - success
17441 
  """
17442 
 
17443 
  thrift_spec = (
17444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17445 
  )
17446 
 
17447 
  def __init__(self, success=None,):
17448 
    self.success = success
17449 
 
17450 
  def read(self, iprot):
17451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17453 
      return
17454 
    iprot.readStructBegin()
17455 
    while True:
17456 
      (fname, ftype, fid) = iprot.readFieldBegin()
17457 
      if ftype == TType.STOP:
17458 
        break
17459 
      if fid == 0:
17460 
        if ftype == TType.LIST:
17461 
          self.success = []
6188 rajveer 17462 
          (_etype435, _size432) = iprot.readListBegin()
17463 
          for _i436 in xrange(_size432):
17464 
            _elem437 = Order()
17465 
            _elem437.read(iprot)
17466 
            self.success.append(_elem437)
4741 phani.kuma 17467 
          iprot.readListEnd()
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      else:
17471 
        iprot.skip(ftype)
17472 
      iprot.readFieldEnd()
17473 
    iprot.readStructEnd()
17474 
 
17475 
  def write(self, oprot):
17476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17478 
      return
4910 phani.kuma 17479 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17480 
    if self.success is not None:
17481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17483 
      for iter438 in self.success:
17484 
        iter438.write(oprot)
4741 phani.kuma 17485 
      oprot.writeListEnd()
17486 
      oprot.writeFieldEnd()
17487 
    oprot.writeFieldStop()
17488 
    oprot.writeStructEnd()
17489 
 
17490 
  def validate(self):
17491 
    return
17492 
 
17493 
 
17494 
  def __repr__(self):
17495 
    L = ['%s=%r' % (key, value)
17496 
      for key, value in self.__dict__.iteritems()]
17497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17498 
 
17499 
  def __eq__(self, other):
17500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17501 
 
17502 
  def __ne__(self, other):
17503 
    return not (self == other)
17504 
 
2616 chandransh 17505 
class receiveReturn_args:
2591 chandransh 17506 
  """
17507 
  Attributes:
17508 
   - orderId
4479 rajveer 17509 
   - receiveCondition
2591 chandransh 17510 
  """
2536 chandransh 17511 
 
2591 chandransh 17512 
  thrift_spec = (
17513 
    None, # 0
17514 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17515 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17516 
  )
17517 
 
4479 rajveer 17518 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17519 
    self.orderId = orderId
4479 rajveer 17520 
    self.receiveCondition = receiveCondition
2591 chandransh 17521 
 
17522 
  def read(self, iprot):
17523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17525 
      return
17526 
    iprot.readStructBegin()
17527 
    while True:
17528 
      (fname, ftype, fid) = iprot.readFieldBegin()
17529 
      if ftype == TType.STOP:
17530 
        break
17531 
      if fid == 1:
17532 
        if ftype == TType.I64:
17533 
          self.orderId = iprot.readI64();
17534 
        else:
17535 
          iprot.skip(ftype)
4479 rajveer 17536 
      elif fid == 2:
17537 
        if ftype == TType.I64:
17538 
          self.receiveCondition = iprot.readI64();
17539 
        else:
17540 
          iprot.skip(ftype)
2591 chandransh 17541 
      else:
17542 
        iprot.skip(ftype)
17543 
      iprot.readFieldEnd()
17544 
    iprot.readStructEnd()
17545 
 
17546 
  def write(self, oprot):
17547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17549 
      return
2616 chandransh 17550 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17551 
    if self.orderId is not None:
2591 chandransh 17552 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17553 
      oprot.writeI64(self.orderId)
17554 
      oprot.writeFieldEnd()
4479 rajveer 17555 
    if self.receiveCondition is not None:
17556 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17557 
      oprot.writeI64(self.receiveCondition)
17558 
      oprot.writeFieldEnd()
2591 chandransh 17559 
    oprot.writeFieldStop()
17560 
    oprot.writeStructEnd()
17561 
 
3431 rajveer 17562 
  def validate(self):
17563 
    return
17564 
 
17565 
 
2591 chandransh 17566 
  def __repr__(self):
17567 
    L = ['%s=%r' % (key, value)
17568 
      for key, value in self.__dict__.iteritems()]
17569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17570 
 
17571 
  def __eq__(self, other):
17572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17573 
 
17574 
  def __ne__(self, other):
17575 
    return not (self == other)
17576 
 
2616 chandransh 17577 
class receiveReturn_result:
2591 chandransh 17578 
  """
17579 
  Attributes:
17580 
   - success
17581 
   - ex
17582 
  """
17583 
 
17584 
  thrift_spec = (
17585 
    (0, TType.BOOL, 'success', None, None, ), # 0
17586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17587 
  )
17588 
 
17589 
  def __init__(self, success=None, ex=None,):
17590 
    self.success = success
17591 
    self.ex = ex
17592 
 
17593 
  def read(self, iprot):
17594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17596 
      return
17597 
    iprot.readStructBegin()
17598 
    while True:
17599 
      (fname, ftype, fid) = iprot.readFieldBegin()
17600 
      if ftype == TType.STOP:
17601 
        break
17602 
      if fid == 0:
17603 
        if ftype == TType.BOOL:
17604 
          self.success = iprot.readBool();
17605 
        else:
17606 
          iprot.skip(ftype)
17607 
      elif fid == 1:
17608 
        if ftype == TType.STRUCT:
17609 
          self.ex = TransactionServiceException()
17610 
          self.ex.read(iprot)
17611 
        else:
17612 
          iprot.skip(ftype)
17613 
      else:
17614 
        iprot.skip(ftype)
17615 
      iprot.readFieldEnd()
17616 
    iprot.readStructEnd()
17617 
 
17618 
  def write(self, oprot):
17619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17621 
      return
2616 chandransh 17622 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17623 
    if self.success is not None:
2591 chandransh 17624 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17625 
      oprot.writeBool(self.success)
17626 
      oprot.writeFieldEnd()
3431 rajveer 17627 
    if self.ex is not None:
2591 chandransh 17628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17629 
      self.ex.write(oprot)
17630 
      oprot.writeFieldEnd()
17631 
    oprot.writeFieldStop()
17632 
    oprot.writeStructEnd()
17633 
 
3431 rajveer 17634 
  def validate(self):
17635 
    return
17636 
 
17637 
 
2591 chandransh 17638 
  def __repr__(self):
17639 
    L = ['%s=%r' % (key, value)
17640 
      for key, value in self.__dict__.iteritems()]
17641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17642 
 
17643 
  def __eq__(self, other):
17644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17645 
 
17646 
  def __ne__(self, other):
17647 
    return not (self == other)
17648 
 
17649 
class validateDoa_args:
17650 
  """
17651 
  Attributes:
17652 
   - orderId
17653 
   - isValid
17654 
  """
17655 
 
17656 
  thrift_spec = (
17657 
    None, # 0
17658 
    (1, TType.I64, 'orderId', None, None, ), # 1
17659 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17660 
  )
17661 
 
17662 
  def __init__(self, orderId=None, isValid=None,):
17663 
    self.orderId = orderId
17664 
    self.isValid = isValid
17665 
 
17666 
  def read(self, iprot):
17667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17669 
      return
17670 
    iprot.readStructBegin()
17671 
    while True:
17672 
      (fname, ftype, fid) = iprot.readFieldBegin()
17673 
      if ftype == TType.STOP:
17674 
        break
17675 
      if fid == 1:
17676 
        if ftype == TType.I64:
17677 
          self.orderId = iprot.readI64();
17678 
        else:
17679 
          iprot.skip(ftype)
17680 
      elif fid == 2:
17681 
        if ftype == TType.BOOL:
17682 
          self.isValid = iprot.readBool();
17683 
        else:
17684 
          iprot.skip(ftype)
17685 
      else:
17686 
        iprot.skip(ftype)
17687 
      iprot.readFieldEnd()
17688 
    iprot.readStructEnd()
17689 
 
17690 
  def write(self, oprot):
17691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17693 
      return
17694 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17695 
    if self.orderId is not None:
2591 chandransh 17696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17697 
      oprot.writeI64(self.orderId)
17698 
      oprot.writeFieldEnd()
3431 rajveer 17699 
    if self.isValid is not None:
2591 chandransh 17700 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17701 
      oprot.writeBool(self.isValid)
17702 
      oprot.writeFieldEnd()
17703 
    oprot.writeFieldStop()
17704 
    oprot.writeStructEnd()
17705 
 
3431 rajveer 17706 
  def validate(self):
17707 
    return
17708 
 
17709 
 
2591 chandransh 17710 
  def __repr__(self):
17711 
    L = ['%s=%r' % (key, value)
17712 
      for key, value in self.__dict__.iteritems()]
17713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17714 
 
17715 
  def __eq__(self, other):
17716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17717 
 
17718 
  def __ne__(self, other):
17719 
    return not (self == other)
17720 
 
17721 
class validateDoa_result:
17722 
  """
17723 
  Attributes:
17724 
   - success
17725 
   - ex
17726 
  """
17727 
 
17728 
  thrift_spec = (
17729 
    (0, TType.BOOL, 'success', None, None, ), # 0
17730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17731 
  )
17732 
 
17733 
  def __init__(self, success=None, ex=None,):
17734 
    self.success = success
17735 
    self.ex = ex
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 0:
17747 
        if ftype == TType.BOOL:
17748 
          self.success = iprot.readBool();
17749 
        else:
17750 
          iprot.skip(ftype)
17751 
      elif fid == 1:
17752 
        if ftype == TType.STRUCT:
17753 
          self.ex = TransactionServiceException()
17754 
          self.ex.read(iprot)
17755 
        else:
17756 
          iprot.skip(ftype)
17757 
      else:
17758 
        iprot.skip(ftype)
17759 
      iprot.readFieldEnd()
17760 
    iprot.readStructEnd()
17761 
 
17762 
  def write(self, oprot):
17763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17765 
      return
17766 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17767 
    if self.success is not None:
2591 chandransh 17768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17769 
      oprot.writeBool(self.success)
17770 
      oprot.writeFieldEnd()
3431 rajveer 17771 
    if self.ex is not None:
2591 chandransh 17772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17773 
      self.ex.write(oprot)
17774 
      oprot.writeFieldEnd()
17775 
    oprot.writeFieldStop()
17776 
    oprot.writeStructEnd()
17777 
 
3431 rajveer 17778 
  def validate(self):
17779 
    return
17780 
 
17781 
 
2591 chandransh 17782 
  def __repr__(self):
17783 
    L = ['%s=%r' % (key, value)
17784 
      for key, value in self.__dict__.iteritems()]
17785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17786 
 
17787 
  def __eq__(self, other):
17788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17789 
 
17790 
  def __ne__(self, other):
17791 
    return not (self == other)
17792 
 
4495 rajveer 17793 
class validateReturnProduct_args:
17794 
  """
17795 
  Attributes:
17796 
   - orderId
17797 
   - isUsable
17798 
  """
17799 
 
17800 
  thrift_spec = (
17801 
    None, # 0
17802 
    (1, TType.I64, 'orderId', None, None, ), # 1
17803 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17804 
  )
17805 
 
17806 
  def __init__(self, orderId=None, isUsable=None,):
17807 
    self.orderId = orderId
17808 
    self.isUsable = isUsable
17809 
 
17810 
  def read(self, iprot):
17811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17813 
      return
17814 
    iprot.readStructBegin()
17815 
    while True:
17816 
      (fname, ftype, fid) = iprot.readFieldBegin()
17817 
      if ftype == TType.STOP:
17818 
        break
17819 
      if fid == 1:
17820 
        if ftype == TType.I64:
17821 
          self.orderId = iprot.readI64();
17822 
        else:
17823 
          iprot.skip(ftype)
17824 
      elif fid == 2:
17825 
        if ftype == TType.BOOL:
17826 
          self.isUsable = iprot.readBool();
17827 
        else:
17828 
          iprot.skip(ftype)
17829 
      else:
17830 
        iprot.skip(ftype)
17831 
      iprot.readFieldEnd()
17832 
    iprot.readStructEnd()
17833 
 
17834 
  def write(self, oprot):
17835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17837 
      return
17838 
    oprot.writeStructBegin('validateReturnProduct_args')
17839 
    if self.orderId is not None:
17840 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17841 
      oprot.writeI64(self.orderId)
17842 
      oprot.writeFieldEnd()
17843 
    if self.isUsable is not None:
17844 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17845 
      oprot.writeBool(self.isUsable)
17846 
      oprot.writeFieldEnd()
17847 
    oprot.writeFieldStop()
17848 
    oprot.writeStructEnd()
17849 
 
17850 
  def validate(self):
17851 
    return
17852 
 
17853 
 
17854 
  def __repr__(self):
17855 
    L = ['%s=%r' % (key, value)
17856 
      for key, value in self.__dict__.iteritems()]
17857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17858 
 
17859 
  def __eq__(self, other):
17860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17861 
 
17862 
  def __ne__(self, other):
17863 
    return not (self == other)
17864 
 
17865 
class validateReturnProduct_result:
17866 
  """
17867 
  Attributes:
17868 
   - success
17869 
   - ex
17870 
  """
17871 
 
17872 
  thrift_spec = (
17873 
    (0, TType.BOOL, 'success', None, None, ), # 0
17874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17875 
  )
17876 
 
17877 
  def __init__(self, success=None, ex=None,):
17878 
    self.success = success
17879 
    self.ex = ex
17880 
 
17881 
  def read(self, iprot):
17882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17884 
      return
17885 
    iprot.readStructBegin()
17886 
    while True:
17887 
      (fname, ftype, fid) = iprot.readFieldBegin()
17888 
      if ftype == TType.STOP:
17889 
        break
17890 
      if fid == 0:
17891 
        if ftype == TType.BOOL:
17892 
          self.success = iprot.readBool();
17893 
        else:
17894 
          iprot.skip(ftype)
17895 
      elif fid == 1:
17896 
        if ftype == TType.STRUCT:
17897 
          self.ex = TransactionServiceException()
17898 
          self.ex.read(iprot)
17899 
        else:
17900 
          iprot.skip(ftype)
17901 
      else:
17902 
        iprot.skip(ftype)
17903 
      iprot.readFieldEnd()
17904 
    iprot.readStructEnd()
17905 
 
17906 
  def write(self, oprot):
17907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17909 
      return
17910 
    oprot.writeStructBegin('validateReturnProduct_result')
17911 
    if self.success is not None:
17912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17913 
      oprot.writeBool(self.success)
17914 
      oprot.writeFieldEnd()
17915 
    if self.ex is not None:
17916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17917 
      self.ex.write(oprot)
17918 
      oprot.writeFieldEnd()
17919 
    oprot.writeFieldStop()
17920 
    oprot.writeStructEnd()
17921 
 
17922 
  def validate(self):
17923 
    return
17924 
 
17925 
 
17926 
  def __repr__(self):
17927 
    L = ['%s=%r' % (key, value)
17928 
      for key, value in self.__dict__.iteritems()]
17929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17930 
 
17931 
  def __eq__(self, other):
17932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17933 
 
17934 
  def __ne__(self, other):
17935 
    return not (self == other)
17936 
 
2616 chandransh 17937 
class reshipOrder_args:
17938 
  """
17939 
  Attributes:
17940 
   - orderId
17941 
  """
2591 chandransh 17942 
 
2616 chandransh 17943 
  thrift_spec = (
17944 
    None, # 0
17945 
    (1, TType.I64, 'orderId', None, None, ), # 1
17946 
  )
17947 
 
17948 
  def __init__(self, orderId=None,):
17949 
    self.orderId = orderId
17950 
 
17951 
  def read(self, iprot):
17952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17954 
      return
17955 
    iprot.readStructBegin()
17956 
    while True:
17957 
      (fname, ftype, fid) = iprot.readFieldBegin()
17958 
      if ftype == TType.STOP:
17959 
        break
17960 
      if fid == 1:
17961 
        if ftype == TType.I64:
17962 
          self.orderId = iprot.readI64();
17963 
        else:
17964 
          iprot.skip(ftype)
17965 
      else:
17966 
        iprot.skip(ftype)
17967 
      iprot.readFieldEnd()
17968 
    iprot.readStructEnd()
17969 
 
17970 
  def write(self, oprot):
17971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17973 
      return
17974 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17975 
    if self.orderId is not None:
2616 chandransh 17976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17977 
      oprot.writeI64(self.orderId)
17978 
      oprot.writeFieldEnd()
17979 
    oprot.writeFieldStop()
17980 
    oprot.writeStructEnd()
17981 
 
3431 rajveer 17982 
  def validate(self):
17983 
    return
17984 
 
17985 
 
2616 chandransh 17986 
  def __repr__(self):
17987 
    L = ['%s=%r' % (key, value)
17988 
      for key, value in self.__dict__.iteritems()]
17989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17990 
 
17991 
  def __eq__(self, other):
17992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17993 
 
17994 
  def __ne__(self, other):
17995 
    return not (self == other)
17996 
 
17997 
class reshipOrder_result:
17998 
  """
17999 
  Attributes:
18000 
   - success
18001 
   - ex
18002 
  """
18003 
 
18004 
  thrift_spec = (
18005 
    (0, TType.I64, 'success', None, None, ), # 0
18006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18007 
  )
18008 
 
18009 
  def __init__(self, success=None, ex=None,):
18010 
    self.success = success
18011 
    self.ex = ex
18012 
 
18013 
  def read(self, iprot):
18014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18016 
      return
18017 
    iprot.readStructBegin()
18018 
    while True:
18019 
      (fname, ftype, fid) = iprot.readFieldBegin()
18020 
      if ftype == TType.STOP:
18021 
        break
18022 
      if fid == 0:
18023 
        if ftype == TType.I64:
18024 
          self.success = iprot.readI64();
18025 
        else:
18026 
          iprot.skip(ftype)
18027 
      elif fid == 1:
18028 
        if ftype == TType.STRUCT:
18029 
          self.ex = TransactionServiceException()
18030 
          self.ex.read(iprot)
18031 
        else:
18032 
          iprot.skip(ftype)
18033 
      else:
18034 
        iprot.skip(ftype)
18035 
      iprot.readFieldEnd()
18036 
    iprot.readStructEnd()
18037 
 
18038 
  def write(self, oprot):
18039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18041 
      return
18042 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18043 
    if self.success is not None:
2616 chandransh 18044 
      oprot.writeFieldBegin('success', TType.I64, 0)
18045 
      oprot.writeI64(self.success)
18046 
      oprot.writeFieldEnd()
3431 rajveer 18047 
    if self.ex is not None:
2616 chandransh 18048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18049 
      self.ex.write(oprot)
18050 
      oprot.writeFieldEnd()
18051 
    oprot.writeFieldStop()
18052 
    oprot.writeStructEnd()
18053 
 
3431 rajveer 18054 
  def validate(self):
18055 
    return
18056 
 
18057 
 
2616 chandransh 18058 
  def __repr__(self):
18059 
    L = ['%s=%r' % (key, value)
18060 
      for key, value in self.__dict__.iteritems()]
18061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18062 
 
18063 
  def __eq__(self, other):
18064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18065 
 
18066 
  def __ne__(self, other):
18067 
    return not (self == other)
18068 
 
18069 
class refundOrder_args:
18070 
  """
18071 
  Attributes:
18072 
   - orderId
3226 chandransh 18073 
   - refundedBy
18074 
   - reason
2616 chandransh 18075 
  """
18076 
 
18077 
  thrift_spec = (
18078 
    None, # 0
18079 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18080 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18081 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18082 
  )
18083 
 
3226 chandransh 18084 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18085 
    self.orderId = orderId
3226 chandransh 18086 
    self.refundedBy = refundedBy
18087 
    self.reason = reason
2616 chandransh 18088 
 
18089 
  def read(self, iprot):
18090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18092 
      return
18093 
    iprot.readStructBegin()
18094 
    while True:
18095 
      (fname, ftype, fid) = iprot.readFieldBegin()
18096 
      if ftype == TType.STOP:
18097 
        break
18098 
      if fid == 1:
18099 
        if ftype == TType.I64:
18100 
          self.orderId = iprot.readI64();
18101 
        else:
18102 
          iprot.skip(ftype)
3226 chandransh 18103 
      elif fid == 2:
18104 
        if ftype == TType.STRING:
18105 
          self.refundedBy = iprot.readString();
18106 
        else:
18107 
          iprot.skip(ftype)
18108 
      elif fid == 3:
18109 
        if ftype == TType.STRING:
18110 
          self.reason = iprot.readString();
18111 
        else:
18112 
          iprot.skip(ftype)
2616 chandransh 18113 
      else:
18114 
        iprot.skip(ftype)
18115 
      iprot.readFieldEnd()
18116 
    iprot.readStructEnd()
18117 
 
18118 
  def write(self, oprot):
18119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18121 
      return
18122 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18123 
    if self.orderId is not None:
2616 chandransh 18124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18125 
      oprot.writeI64(self.orderId)
18126 
      oprot.writeFieldEnd()
3431 rajveer 18127 
    if self.refundedBy is not None:
3226 chandransh 18128 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18129 
      oprot.writeString(self.refundedBy)
18130 
      oprot.writeFieldEnd()
3431 rajveer 18131 
    if self.reason is not None:
3226 chandransh 18132 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18133 
      oprot.writeString(self.reason)
18134 
      oprot.writeFieldEnd()
2616 chandransh 18135 
    oprot.writeFieldStop()
18136 
    oprot.writeStructEnd()
18137 
 
3431 rajveer 18138 
  def validate(self):
18139 
    return
18140 
 
18141 
 
2616 chandransh 18142 
  def __repr__(self):
18143 
    L = ['%s=%r' % (key, value)
18144 
      for key, value in self.__dict__.iteritems()]
18145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18146 
 
18147 
  def __eq__(self, other):
18148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18149 
 
18150 
  def __ne__(self, other):
18151 
    return not (self == other)
18152 
 
18153 
class refundOrder_result:
18154 
  """
18155 
  Attributes:
18156 
   - success
18157 
   - ex
18158 
  """
18159 
 
18160 
  thrift_spec = (
18161 
    (0, TType.BOOL, 'success', None, None, ), # 0
18162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18163 
  )
18164 
 
18165 
  def __init__(self, success=None, ex=None,):
18166 
    self.success = success
18167 
    self.ex = ex
18168 
 
18169 
  def read(self, iprot):
18170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18172 
      return
18173 
    iprot.readStructBegin()
18174 
    while True:
18175 
      (fname, ftype, fid) = iprot.readFieldBegin()
18176 
      if ftype == TType.STOP:
18177 
        break
18178 
      if fid == 0:
18179 
        if ftype == TType.BOOL:
18180 
          self.success = iprot.readBool();
18181 
        else:
18182 
          iprot.skip(ftype)
18183 
      elif fid == 1:
18184 
        if ftype == TType.STRUCT:
18185 
          self.ex = TransactionServiceException()
18186 
          self.ex.read(iprot)
18187 
        else:
18188 
          iprot.skip(ftype)
18189 
      else:
18190 
        iprot.skip(ftype)
18191 
      iprot.readFieldEnd()
18192 
    iprot.readStructEnd()
18193 
 
18194 
  def write(self, oprot):
18195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18197 
      return
18198 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18199 
    if self.success is not None:
2616 chandransh 18200 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18201 
      oprot.writeBool(self.success)
18202 
      oprot.writeFieldEnd()
3431 rajveer 18203 
    if self.ex is not None:
2616 chandransh 18204 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18205 
      self.ex.write(oprot)
18206 
      oprot.writeFieldEnd()
18207 
    oprot.writeFieldStop()
18208 
    oprot.writeStructEnd()
18209 
 
3431 rajveer 18210 
  def validate(self):
18211 
    return
18212 
 
18213 
 
2616 chandransh 18214 
  def __repr__(self):
18215 
    L = ['%s=%r' % (key, value)
18216 
      for key, value in self.__dict__.iteritems()]
18217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18218 
 
18219 
  def __eq__(self, other):
18220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18221 
 
18222 
  def __ne__(self, other):
18223 
    return not (self == other)
18224 
 
2690 chandransh 18225 
class getReturnOrders_args:
18226 
  """
18227 
  Attributes:
18228 
   - warehouseId
18229 
   - fromDate
18230 
   - toDate
18231 
  """
2616 chandransh 18232 
 
2690 chandransh 18233 
  thrift_spec = (
18234 
    None, # 0
18235 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18236 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18237 
    (3, TType.I64, 'toDate', None, None, ), # 3
18238 
  )
18239 
 
18240 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18241 
    self.warehouseId = warehouseId
18242 
    self.fromDate = fromDate
18243 
    self.toDate = toDate
18244 
 
18245 
  def read(self, iprot):
18246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18248 
      return
18249 
    iprot.readStructBegin()
18250 
    while True:
18251 
      (fname, ftype, fid) = iprot.readFieldBegin()
18252 
      if ftype == TType.STOP:
18253 
        break
18254 
      if fid == 1:
18255 
        if ftype == TType.I64:
18256 
          self.warehouseId = iprot.readI64();
18257 
        else:
18258 
          iprot.skip(ftype)
18259 
      elif fid == 2:
18260 
        if ftype == TType.I64:
18261 
          self.fromDate = iprot.readI64();
18262 
        else:
18263 
          iprot.skip(ftype)
18264 
      elif fid == 3:
18265 
        if ftype == TType.I64:
18266 
          self.toDate = iprot.readI64();
18267 
        else:
18268 
          iprot.skip(ftype)
18269 
      else:
18270 
        iprot.skip(ftype)
18271 
      iprot.readFieldEnd()
18272 
    iprot.readStructEnd()
18273 
 
18274 
  def write(self, oprot):
18275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18277 
      return
18278 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18279 
    if self.warehouseId is not None:
2690 chandransh 18280 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18281 
      oprot.writeI64(self.warehouseId)
18282 
      oprot.writeFieldEnd()
3431 rajveer 18283 
    if self.fromDate is not None:
2690 chandransh 18284 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18285 
      oprot.writeI64(self.fromDate)
18286 
      oprot.writeFieldEnd()
3431 rajveer 18287 
    if self.toDate is not None:
2690 chandransh 18288 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18289 
      oprot.writeI64(self.toDate)
18290 
      oprot.writeFieldEnd()
18291 
    oprot.writeFieldStop()
18292 
    oprot.writeStructEnd()
18293 
 
3431 rajveer 18294 
  def validate(self):
18295 
    return
18296 
 
18297 
 
2690 chandransh 18298 
  def __repr__(self):
18299 
    L = ['%s=%r' % (key, value)
18300 
      for key, value in self.__dict__.iteritems()]
18301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18302 
 
18303 
  def __eq__(self, other):
18304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18305 
 
18306 
  def __ne__(self, other):
18307 
    return not (self == other)
18308 
 
18309 
class getReturnOrders_result:
18310 
  """
18311 
  Attributes:
18312 
   - success
18313 
  """
18314 
 
18315 
  thrift_spec = (
18316 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18317 
  )
18318 
 
18319 
  def __init__(self, success=None,):
18320 
    self.success = success
18321 
 
18322 
  def read(self, iprot):
18323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18325 
      return
18326 
    iprot.readStructBegin()
18327 
    while True:
18328 
      (fname, ftype, fid) = iprot.readFieldBegin()
18329 
      if ftype == TType.STOP:
18330 
        break
18331 
      if fid == 0:
18332 
        if ftype == TType.LIST:
18333 
          self.success = []
6188 rajveer 18334 
          (_etype442, _size439) = iprot.readListBegin()
18335 
          for _i443 in xrange(_size439):
18336 
            _elem444 = ReturnOrder()
18337 
            _elem444.read(iprot)
18338 
            self.success.append(_elem444)
2690 chandransh 18339 
          iprot.readListEnd()
18340 
        else:
18341 
          iprot.skip(ftype)
18342 
      else:
18343 
        iprot.skip(ftype)
18344 
      iprot.readFieldEnd()
18345 
    iprot.readStructEnd()
18346 
 
18347 
  def write(self, oprot):
18348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18350 
      return
18351 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18352 
    if self.success is not None:
2690 chandransh 18353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18355 
      for iter445 in self.success:
18356 
        iter445.write(oprot)
2690 chandransh 18357 
      oprot.writeListEnd()
18358 
      oprot.writeFieldEnd()
18359 
    oprot.writeFieldStop()
18360 
    oprot.writeStructEnd()
18361 
 
3431 rajveer 18362 
  def validate(self):
18363 
    return
18364 
 
18365 
 
2690 chandransh 18366 
  def __repr__(self):
18367 
    L = ['%s=%r' % (key, value)
18368 
      for key, value in self.__dict__.iteritems()]
18369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18370 
 
18371 
  def __eq__(self, other):
18372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18373 
 
18374 
  def __ne__(self, other):
18375 
    return not (self == other)
18376 
 
5481 phani.kuma 18377 
class getAllReturnOrders_args:
18378 
  """
18379 
  Attributes:
18380 
   - onlyNotProcessed
18381 
   - fromDate
18382 
   - toDate
18383 
  """
18384 
 
18385 
  thrift_spec = (
18386 
    None, # 0
18387 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18388 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18389 
    (3, TType.I64, 'toDate', None, None, ), # 3
18390 
  )
18391 
 
18392 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18393 
    self.onlyNotProcessed = onlyNotProcessed
18394 
    self.fromDate = fromDate
18395 
    self.toDate = toDate
18396 
 
18397 
  def read(self, iprot):
18398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18400 
      return
18401 
    iprot.readStructBegin()
18402 
    while True:
18403 
      (fname, ftype, fid) = iprot.readFieldBegin()
18404 
      if ftype == TType.STOP:
18405 
        break
18406 
      if fid == 1:
18407 
        if ftype == TType.BOOL:
18408 
          self.onlyNotProcessed = iprot.readBool();
18409 
        else:
18410 
          iprot.skip(ftype)
18411 
      elif fid == 2:
18412 
        if ftype == TType.I64:
18413 
          self.fromDate = iprot.readI64();
18414 
        else:
18415 
          iprot.skip(ftype)
18416 
      elif fid == 3:
18417 
        if ftype == TType.I64:
18418 
          self.toDate = iprot.readI64();
18419 
        else:
18420 
          iprot.skip(ftype)
18421 
      else:
18422 
        iprot.skip(ftype)
18423 
      iprot.readFieldEnd()
18424 
    iprot.readStructEnd()
18425 
 
18426 
  def write(self, oprot):
18427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18429 
      return
18430 
    oprot.writeStructBegin('getAllReturnOrders_args')
18431 
    if self.onlyNotProcessed is not None:
18432 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18433 
      oprot.writeBool(self.onlyNotProcessed)
18434 
      oprot.writeFieldEnd()
18435 
    if self.fromDate is not None:
18436 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18437 
      oprot.writeI64(self.fromDate)
18438 
      oprot.writeFieldEnd()
18439 
    if self.toDate is not None:
18440 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18441 
      oprot.writeI64(self.toDate)
18442 
      oprot.writeFieldEnd()
18443 
    oprot.writeFieldStop()
18444 
    oprot.writeStructEnd()
18445 
 
18446 
  def validate(self):
18447 
    return
18448 
 
18449 
 
18450 
  def __repr__(self):
18451 
    L = ['%s=%r' % (key, value)
18452 
      for key, value in self.__dict__.iteritems()]
18453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18454 
 
18455 
  def __eq__(self, other):
18456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18457 
 
18458 
  def __ne__(self, other):
18459 
    return not (self == other)
18460 
 
18461 
class getAllReturnOrders_result:
18462 
  """
18463 
  Attributes:
18464 
   - success
18465 
  """
18466 
 
18467 
  thrift_spec = (
18468 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18469 
  )
18470 
 
18471 
  def __init__(self, success=None,):
18472 
    self.success = success
18473 
 
18474 
  def read(self, iprot):
18475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18477 
      return
18478 
    iprot.readStructBegin()
18479 
    while True:
18480 
      (fname, ftype, fid) = iprot.readFieldBegin()
18481 
      if ftype == TType.STOP:
18482 
        break
18483 
      if fid == 0:
18484 
        if ftype == TType.LIST:
18485 
          self.success = []
6188 rajveer 18486 
          (_etype449, _size446) = iprot.readListBegin()
18487 
          for _i450 in xrange(_size446):
18488 
            _elem451 = ReturnOrder()
18489 
            _elem451.read(iprot)
18490 
            self.success.append(_elem451)
5481 phani.kuma 18491 
          iprot.readListEnd()
18492 
        else:
18493 
          iprot.skip(ftype)
18494 
      else:
18495 
        iprot.skip(ftype)
18496 
      iprot.readFieldEnd()
18497 
    iprot.readStructEnd()
18498 
 
18499 
  def write(self, oprot):
18500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18502 
      return
18503 
    oprot.writeStructBegin('getAllReturnOrders_result')
18504 
    if self.success is not None:
18505 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18506 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18507 
      for iter452 in self.success:
18508 
        iter452.write(oprot)
5481 phani.kuma 18509 
      oprot.writeListEnd()
18510 
      oprot.writeFieldEnd()
18511 
    oprot.writeFieldStop()
18512 
    oprot.writeStructEnd()
18513 
 
18514 
  def validate(self):
18515 
    return
18516 
 
18517 
 
18518 
  def __repr__(self):
18519 
    L = ['%s=%r' % (key, value)
18520 
      for key, value in self.__dict__.iteritems()]
18521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18522 
 
18523 
  def __eq__(self, other):
18524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18525 
 
18526 
  def __ne__(self, other):
18527 
    return not (self == other)
18528 
 
2700 chandransh 18529 
class getReturnOrder_args:
18530 
  """
18531 
  Attributes:
18532 
   - id
18533 
  """
18534 
 
18535 
  thrift_spec = (
18536 
    None, # 0
18537 
    (1, TType.I64, 'id', None, None, ), # 1
18538 
  )
18539 
 
18540 
  def __init__(self, id=None,):
18541 
    self.id = id
18542 
 
18543 
  def read(self, iprot):
18544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18546 
      return
18547 
    iprot.readStructBegin()
18548 
    while True:
18549 
      (fname, ftype, fid) = iprot.readFieldBegin()
18550 
      if ftype == TType.STOP:
18551 
        break
18552 
      if fid == 1:
18553 
        if ftype == TType.I64:
18554 
          self.id = iprot.readI64();
18555 
        else:
18556 
          iprot.skip(ftype)
18557 
      else:
18558 
        iprot.skip(ftype)
18559 
      iprot.readFieldEnd()
18560 
    iprot.readStructEnd()
18561 
 
18562 
  def write(self, oprot):
18563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18565 
      return
18566 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18567 
    if self.id is not None:
2700 chandransh 18568 
      oprot.writeFieldBegin('id', TType.I64, 1)
18569 
      oprot.writeI64(self.id)
18570 
      oprot.writeFieldEnd()
18571 
    oprot.writeFieldStop()
18572 
    oprot.writeStructEnd()
18573 
 
3431 rajveer 18574 
  def validate(self):
18575 
    return
18576 
 
18577 
 
2700 chandransh 18578 
  def __repr__(self):
18579 
    L = ['%s=%r' % (key, value)
18580 
      for key, value in self.__dict__.iteritems()]
18581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18582 
 
18583 
  def __eq__(self, other):
18584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18585 
 
18586 
  def __ne__(self, other):
18587 
    return not (self == other)
18588 
 
18589 
class getReturnOrder_result:
18590 
  """
18591 
  Attributes:
18592 
   - success
18593 
   - ex
18594 
  """
18595 
 
18596 
  thrift_spec = (
18597 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18599 
  )
18600 
 
18601 
  def __init__(self, success=None, ex=None,):
18602 
    self.success = success
18603 
    self.ex = ex
18604 
 
18605 
  def read(self, iprot):
18606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18608 
      return
18609 
    iprot.readStructBegin()
18610 
    while True:
18611 
      (fname, ftype, fid) = iprot.readFieldBegin()
18612 
      if ftype == TType.STOP:
18613 
        break
18614 
      if fid == 0:
18615 
        if ftype == TType.STRUCT:
18616 
          self.success = ReturnOrder()
18617 
          self.success.read(iprot)
18618 
        else:
18619 
          iprot.skip(ftype)
18620 
      elif fid == 1:
18621 
        if ftype == TType.STRUCT:
18622 
          self.ex = TransactionServiceException()
18623 
          self.ex.read(iprot)
18624 
        else:
18625 
          iprot.skip(ftype)
18626 
      else:
18627 
        iprot.skip(ftype)
18628 
      iprot.readFieldEnd()
18629 
    iprot.readStructEnd()
18630 
 
18631 
  def write(self, oprot):
18632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18634 
      return
18635 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18636 
    if self.success is not None:
2700 chandransh 18637 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18638 
      self.success.write(oprot)
18639 
      oprot.writeFieldEnd()
3431 rajveer 18640 
    if self.ex is not None:
2700 chandransh 18641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18642 
      self.ex.write(oprot)
18643 
      oprot.writeFieldEnd()
18644 
    oprot.writeFieldStop()
18645 
    oprot.writeStructEnd()
18646 
 
3431 rajveer 18647 
  def validate(self):
18648 
    return
18649 
 
18650 
 
2700 chandransh 18651 
  def __repr__(self):
18652 
    L = ['%s=%r' % (key, value)
18653 
      for key, value in self.__dict__.iteritems()]
18654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18655 
 
18656 
  def __eq__(self, other):
18657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18658 
 
18659 
  def __ne__(self, other):
18660 
    return not (self == other)
18661 
 
2690 chandransh 18662 
class processReturn_args:
18663 
  """
18664 
  Attributes:
18665 
   - returnOrderId
18666 
  """
18667 
 
18668 
  thrift_spec = (
18669 
    None, # 0
18670 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18671 
  )
18672 
 
18673 
  def __init__(self, returnOrderId=None,):
18674 
    self.returnOrderId = returnOrderId
18675 
 
18676 
  def read(self, iprot):
18677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18679 
      return
18680 
    iprot.readStructBegin()
18681 
    while True:
18682 
      (fname, ftype, fid) = iprot.readFieldBegin()
18683 
      if ftype == TType.STOP:
18684 
        break
18685 
      if fid == 1:
18686 
        if ftype == TType.I64:
18687 
          self.returnOrderId = iprot.readI64();
18688 
        else:
18689 
          iprot.skip(ftype)
18690 
      else:
18691 
        iprot.skip(ftype)
18692 
      iprot.readFieldEnd()
18693 
    iprot.readStructEnd()
18694 
 
18695 
  def write(self, oprot):
18696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18698 
      return
18699 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18700 
    if self.returnOrderId is not None:
2690 chandransh 18701 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18702 
      oprot.writeI64(self.returnOrderId)
18703 
      oprot.writeFieldEnd()
18704 
    oprot.writeFieldStop()
18705 
    oprot.writeStructEnd()
18706 
 
3431 rajveer 18707 
  def validate(self):
18708 
    return
18709 
 
18710 
 
2690 chandransh 18711 
  def __repr__(self):
18712 
    L = ['%s=%r' % (key, value)
18713 
      for key, value in self.__dict__.iteritems()]
18714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18715 
 
18716 
  def __eq__(self, other):
18717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18718 
 
18719 
  def __ne__(self, other):
18720 
    return not (self == other)
18721 
 
18722 
class processReturn_result:
18723 
  """
18724 
  Attributes:
18725 
   - ex
18726 
  """
18727 
 
18728 
  thrift_spec = (
18729 
    None, # 0
18730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18731 
  )
18732 
 
18733 
  def __init__(self, ex=None,):
18734 
    self.ex = ex
18735 
 
18736 
  def read(self, iprot):
18737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18739 
      return
18740 
    iprot.readStructBegin()
18741 
    while True:
18742 
      (fname, ftype, fid) = iprot.readFieldBegin()
18743 
      if ftype == TType.STOP:
18744 
        break
18745 
      if fid == 1:
18746 
        if ftype == TType.STRUCT:
18747 
          self.ex = TransactionServiceException()
18748 
          self.ex.read(iprot)
18749 
        else:
18750 
          iprot.skip(ftype)
18751 
      else:
18752 
        iprot.skip(ftype)
18753 
      iprot.readFieldEnd()
18754 
    iprot.readStructEnd()
18755 
 
18756 
  def write(self, oprot):
18757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18759 
      return
18760 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18761 
    if self.ex is not None:
2690 chandransh 18762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18763 
      self.ex.write(oprot)
18764 
      oprot.writeFieldEnd()
18765 
    oprot.writeFieldStop()
18766 
    oprot.writeStructEnd()
18767 
 
3431 rajveer 18768 
  def validate(self):
18769 
    return
18770 
 
18771 
 
2690 chandransh 18772 
  def __repr__(self):
18773 
    L = ['%s=%r' % (key, value)
18774 
      for key, value in self.__dict__.iteritems()]
18775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18776 
 
18777 
  def __eq__(self, other):
18778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18779 
 
18780 
  def __ne__(self, other):
18781 
    return not (self == other)
18782 
 
3451 chandransh 18783 
class updateWeight_args:
18784 
  """
18785 
  Attributes:
18786 
   - orderId
18787 
   - weight
18788 
  """
18789 
 
18790 
  thrift_spec = (
18791 
    None, # 0
18792 
    (1, TType.I64, 'orderId', None, None, ), # 1
18793 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18794 
  )
18795 
 
18796 
  def __init__(self, orderId=None, weight=None,):
18797 
    self.orderId = orderId
18798 
    self.weight = weight
18799 
 
18800 
  def read(self, iprot):
18801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18803 
      return
18804 
    iprot.readStructBegin()
18805 
    while True:
18806 
      (fname, ftype, fid) = iprot.readFieldBegin()
18807 
      if ftype == TType.STOP:
18808 
        break
18809 
      if fid == 1:
18810 
        if ftype == TType.I64:
18811 
          self.orderId = iprot.readI64();
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      elif fid == 2:
18815 
        if ftype == TType.DOUBLE:
18816 
          self.weight = iprot.readDouble();
18817 
        else:
18818 
          iprot.skip(ftype)
18819 
      else:
18820 
        iprot.skip(ftype)
18821 
      iprot.readFieldEnd()
18822 
    iprot.readStructEnd()
18823 
 
18824 
  def write(self, oprot):
18825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18827 
      return
18828 
    oprot.writeStructBegin('updateWeight_args')
18829 
    if self.orderId is not None:
18830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18831 
      oprot.writeI64(self.orderId)
18832 
      oprot.writeFieldEnd()
18833 
    if self.weight is not None:
18834 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18835 
      oprot.writeDouble(self.weight)
18836 
      oprot.writeFieldEnd()
18837 
    oprot.writeFieldStop()
18838 
    oprot.writeStructEnd()
18839 
 
18840 
  def validate(self):
18841 
    return
18842 
 
18843 
 
18844 
  def __repr__(self):
18845 
    L = ['%s=%r' % (key, value)
18846 
      for key, value in self.__dict__.iteritems()]
18847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18848 
 
18849 
  def __eq__(self, other):
18850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18851 
 
18852 
  def __ne__(self, other):
18853 
    return not (self == other)
18854 
 
18855 
class updateWeight_result:
18856 
  """
18857 
  Attributes:
18858 
   - success
18859 
   - ex
18860 
  """
18861 
 
18862 
  thrift_spec = (
18863 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18865 
  )
18866 
 
18867 
  def __init__(self, success=None, ex=None,):
18868 
    self.success = success
18869 
    self.ex = ex
18870 
 
18871 
  def read(self, iprot):
18872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18874 
      return
18875 
    iprot.readStructBegin()
18876 
    while True:
18877 
      (fname, ftype, fid) = iprot.readFieldBegin()
18878 
      if ftype == TType.STOP:
18879 
        break
18880 
      if fid == 0:
18881 
        if ftype == TType.STRUCT:
18882 
          self.success = Order()
18883 
          self.success.read(iprot)
18884 
        else:
18885 
          iprot.skip(ftype)
18886 
      elif fid == 1:
18887 
        if ftype == TType.STRUCT:
18888 
          self.ex = TransactionServiceException()
18889 
          self.ex.read(iprot)
18890 
        else:
18891 
          iprot.skip(ftype)
18892 
      else:
18893 
        iprot.skip(ftype)
18894 
      iprot.readFieldEnd()
18895 
    iprot.readStructEnd()
18896 
 
18897 
  def write(self, oprot):
18898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18900 
      return
18901 
    oprot.writeStructBegin('updateWeight_result')
18902 
    if self.success is not None:
18903 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18904 
      self.success.write(oprot)
18905 
      oprot.writeFieldEnd()
18906 
    if self.ex is not None:
18907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18908 
      self.ex.write(oprot)
18909 
      oprot.writeFieldEnd()
18910 
    oprot.writeFieldStop()
18911 
    oprot.writeStructEnd()
18912 
 
18913 
  def validate(self):
18914 
    return
18915 
 
18916 
 
18917 
  def __repr__(self):
18918 
    L = ['%s=%r' % (key, value)
18919 
      for key, value in self.__dict__.iteritems()]
18920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18921 
 
18922 
  def __eq__(self, other):
18923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18924 
 
18925 
  def __ne__(self, other):
18926 
    return not (self == other)
3469 chandransh 18927 
 
18928 
class changeItem_args:
18929 
  """
18930 
  Attributes:
18931 
   - orderId
18932 
   - itemId
18933 
  """
18934 
 
18935 
  thrift_spec = (
18936 
    None, # 0
18937 
    (1, TType.I64, 'orderId', None, None, ), # 1
18938 
    (2, TType.I64, 'itemId', None, None, ), # 2
18939 
  )
18940 
 
18941 
  def __init__(self, orderId=None, itemId=None,):
18942 
    self.orderId = orderId
18943 
    self.itemId = itemId
18944 
 
18945 
  def read(self, iprot):
18946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18948 
      return
18949 
    iprot.readStructBegin()
18950 
    while True:
18951 
      (fname, ftype, fid) = iprot.readFieldBegin()
18952 
      if ftype == TType.STOP:
18953 
        break
18954 
      if fid == 1:
18955 
        if ftype == TType.I64:
18956 
          self.orderId = iprot.readI64();
18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      elif fid == 2:
18960 
        if ftype == TType.I64:
18961 
          self.itemId = iprot.readI64();
18962 
        else:
18963 
          iprot.skip(ftype)
18964 
      else:
18965 
        iprot.skip(ftype)
18966 
      iprot.readFieldEnd()
18967 
    iprot.readStructEnd()
18968 
 
18969 
  def write(self, oprot):
18970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18972 
      return
18973 
    oprot.writeStructBegin('changeItem_args')
18974 
    if self.orderId is not None:
18975 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18976 
      oprot.writeI64(self.orderId)
18977 
      oprot.writeFieldEnd()
18978 
    if self.itemId is not None:
18979 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18980 
      oprot.writeI64(self.itemId)
18981 
      oprot.writeFieldEnd()
18982 
    oprot.writeFieldStop()
18983 
    oprot.writeStructEnd()
18984 
 
18985 
  def validate(self):
18986 
    return
18987 
 
18988 
 
18989 
  def __repr__(self):
18990 
    L = ['%s=%r' % (key, value)
18991 
      for key, value in self.__dict__.iteritems()]
18992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18993 
 
18994 
  def __eq__(self, other):
18995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18996 
 
18997 
  def __ne__(self, other):
18998 
    return not (self == other)
18999 
 
19000 
class changeItem_result:
19001 
  """
19002 
  Attributes:
19003 
   - success
19004 
   - ex
19005 
  """
19006 
 
19007 
  thrift_spec = (
19008 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19010 
  )
19011 
 
19012 
  def __init__(self, success=None, ex=None,):
19013 
    self.success = success
19014 
    self.ex = ex
19015 
 
19016 
  def read(self, iprot):
19017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19019 
      return
19020 
    iprot.readStructBegin()
19021 
    while True:
19022 
      (fname, ftype, fid) = iprot.readFieldBegin()
19023 
      if ftype == TType.STOP:
19024 
        break
19025 
      if fid == 0:
19026 
        if ftype == TType.STRUCT:
19027 
          self.success = Order()
19028 
          self.success.read(iprot)
19029 
        else:
19030 
          iprot.skip(ftype)
19031 
      elif fid == 1:
19032 
        if ftype == TType.STRUCT:
19033 
          self.ex = TransactionServiceException()
19034 
          self.ex.read(iprot)
19035 
        else:
19036 
          iprot.skip(ftype)
19037 
      else:
19038 
        iprot.skip(ftype)
19039 
      iprot.readFieldEnd()
19040 
    iprot.readStructEnd()
19041 
 
19042 
  def write(self, oprot):
19043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19045 
      return
19046 
    oprot.writeStructBegin('changeItem_result')
19047 
    if self.success is not None:
19048 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19049 
      self.success.write(oprot)
19050 
      oprot.writeFieldEnd()
19051 
    if self.ex is not None:
19052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19053 
      self.ex.write(oprot)
19054 
      oprot.writeFieldEnd()
19055 
    oprot.writeFieldStop()
19056 
    oprot.writeStructEnd()
19057 
 
19058 
  def validate(self):
19059 
    return
19060 
 
19061 
 
19062 
  def __repr__(self):
19063 
    L = ['%s=%r' % (key, value)
19064 
      for key, value in self.__dict__.iteritems()]
19065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19066 
 
19067 
  def __eq__(self, other):
19068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19069 
 
19070 
  def __ne__(self, other):
19071 
    return not (self == other)
19072 
 
19073 
class shiftToWarehouse_args:
19074 
  """
19075 
  Attributes:
19076 
   - orderId
19077 
   - warehouseId
19078 
  """
19079 
 
19080 
  thrift_spec = (
19081 
    None, # 0
19082 
    (1, TType.I64, 'orderId', None, None, ), # 1
19083 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19084 
  )
19085 
 
19086 
  def __init__(self, orderId=None, warehouseId=None,):
19087 
    self.orderId = orderId
19088 
    self.warehouseId = warehouseId
19089 
 
19090 
  def read(self, iprot):
19091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19093 
      return
19094 
    iprot.readStructBegin()
19095 
    while True:
19096 
      (fname, ftype, fid) = iprot.readFieldBegin()
19097 
      if ftype == TType.STOP:
19098 
        break
19099 
      if fid == 1:
19100 
        if ftype == TType.I64:
19101 
          self.orderId = iprot.readI64();
19102 
        else:
19103 
          iprot.skip(ftype)
19104 
      elif fid == 2:
19105 
        if ftype == TType.I64:
19106 
          self.warehouseId = iprot.readI64();
19107 
        else:
19108 
          iprot.skip(ftype)
19109 
      else:
19110 
        iprot.skip(ftype)
19111 
      iprot.readFieldEnd()
19112 
    iprot.readStructEnd()
19113 
 
19114 
  def write(self, oprot):
19115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19117 
      return
19118 
    oprot.writeStructBegin('shiftToWarehouse_args')
19119 
    if self.orderId is not None:
19120 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19121 
      oprot.writeI64(self.orderId)
19122 
      oprot.writeFieldEnd()
19123 
    if self.warehouseId is not None:
19124 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19125 
      oprot.writeI64(self.warehouseId)
19126 
      oprot.writeFieldEnd()
19127 
    oprot.writeFieldStop()
19128 
    oprot.writeStructEnd()
19129 
 
19130 
  def validate(self):
19131 
    return
19132 
 
19133 
 
19134 
  def __repr__(self):
19135 
    L = ['%s=%r' % (key, value)
19136 
      for key, value in self.__dict__.iteritems()]
19137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19138 
 
19139 
  def __eq__(self, other):
19140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19141 
 
19142 
  def __ne__(self, other):
19143 
    return not (self == other)
19144 
 
19145 
class shiftToWarehouse_result:
19146 
  """
19147 
  Attributes:
19148 
   - success
19149 
   - ex
19150 
  """
19151 
 
19152 
  thrift_spec = (
19153 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19155 
  )
19156 
 
19157 
  def __init__(self, success=None, ex=None,):
19158 
    self.success = success
19159 
    self.ex = ex
19160 
 
19161 
  def read(self, iprot):
19162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19164 
      return
19165 
    iprot.readStructBegin()
19166 
    while True:
19167 
      (fname, ftype, fid) = iprot.readFieldBegin()
19168 
      if ftype == TType.STOP:
19169 
        break
19170 
      if fid == 0:
19171 
        if ftype == TType.STRUCT:
19172 
          self.success = Order()
19173 
          self.success.read(iprot)
19174 
        else:
19175 
          iprot.skip(ftype)
19176 
      elif fid == 1:
19177 
        if ftype == TType.STRUCT:
19178 
          self.ex = TransactionServiceException()
19179 
          self.ex.read(iprot)
19180 
        else:
19181 
          iprot.skip(ftype)
19182 
      else:
19183 
        iprot.skip(ftype)
19184 
      iprot.readFieldEnd()
19185 
    iprot.readStructEnd()
19186 
 
19187 
  def write(self, oprot):
19188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19190 
      return
19191 
    oprot.writeStructBegin('shiftToWarehouse_result')
19192 
    if self.success is not None:
19193 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19194 
      self.success.write(oprot)
19195 
      oprot.writeFieldEnd()
19196 
    if self.ex is not None:
19197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19198 
      self.ex.write(oprot)
19199 
      oprot.writeFieldEnd()
19200 
    oprot.writeFieldStop()
19201 
    oprot.writeStructEnd()
19202 
 
19203 
  def validate(self):
19204 
    return
19205 
 
19206 
 
19207 
  def __repr__(self):
19208 
    L = ['%s=%r' % (key, value)
19209 
      for key, value in self.__dict__.iteritems()]
19210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19211 
 
19212 
  def __eq__(self, other):
19213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19214 
 
19215 
  def __ne__(self, other):
19216 
    return not (self == other)
3553 chandransh 19217 
 
19218 
class addDelayReason_args:
19219 
  """
19220 
  Attributes:
19221 
   - orderId
19222 
   - delayReason
3986 chandransh 19223 
   - furtherDelay
4647 rajveer 19224 
   - delayReasonText
3553 chandransh 19225 
  """
19226 
 
19227 
  thrift_spec = (
19228 
    None, # 0
19229 
    (1, TType.I64, 'orderId', None, None, ), # 1
19230 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19231 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19232 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19233 
  )
19234 
 
4647 rajveer 19235 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19236 
    self.orderId = orderId
19237 
    self.delayReason = delayReason
3986 chandransh 19238 
    self.furtherDelay = furtherDelay
4647 rajveer 19239 
    self.delayReasonText = delayReasonText
3553 chandransh 19240 
 
19241 
  def read(self, iprot):
19242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19244 
      return
19245 
    iprot.readStructBegin()
19246 
    while True:
19247 
      (fname, ftype, fid) = iprot.readFieldBegin()
19248 
      if ftype == TType.STOP:
19249 
        break
19250 
      if fid == 1:
19251 
        if ftype == TType.I64:
19252 
          self.orderId = iprot.readI64();
19253 
        else:
19254 
          iprot.skip(ftype)
19255 
      elif fid == 2:
19256 
        if ftype == TType.I32:
19257 
          self.delayReason = iprot.readI32();
19258 
        else:
19259 
          iprot.skip(ftype)
3986 chandransh 19260 
      elif fid == 3:
19261 
        if ftype == TType.I64:
19262 
          self.furtherDelay = iprot.readI64();
19263 
        else:
19264 
          iprot.skip(ftype)
4647 rajveer 19265 
      elif fid == 4:
19266 
        if ftype == TType.STRING:
19267 
          self.delayReasonText = iprot.readString();
19268 
        else:
19269 
          iprot.skip(ftype)
3553 chandransh 19270 
      else:
19271 
        iprot.skip(ftype)
19272 
      iprot.readFieldEnd()
19273 
    iprot.readStructEnd()
19274 
 
19275 
  def write(self, oprot):
19276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19278 
      return
19279 
    oprot.writeStructBegin('addDelayReason_args')
19280 
    if self.orderId is not None:
19281 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19282 
      oprot.writeI64(self.orderId)
19283 
      oprot.writeFieldEnd()
19284 
    if self.delayReason is not None:
19285 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19286 
      oprot.writeI32(self.delayReason)
19287 
      oprot.writeFieldEnd()
3986 chandransh 19288 
    if self.furtherDelay is not None:
19289 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19290 
      oprot.writeI64(self.furtherDelay)
19291 
      oprot.writeFieldEnd()
4647 rajveer 19292 
    if self.delayReasonText is not None:
19293 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19294 
      oprot.writeString(self.delayReasonText)
19295 
      oprot.writeFieldEnd()
3553 chandransh 19296 
    oprot.writeFieldStop()
19297 
    oprot.writeStructEnd()
19298 
 
19299 
  def validate(self):
19300 
    return
19301 
 
19302 
 
19303 
  def __repr__(self):
19304 
    L = ['%s=%r' % (key, value)
19305 
      for key, value in self.__dict__.iteritems()]
19306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19307 
 
19308 
  def __eq__(self, other):
19309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19310 
 
19311 
  def __ne__(self, other):
19312 
    return not (self == other)
19313 
 
19314 
class addDelayReason_result:
19315 
  """
19316 
  Attributes:
19317 
   - success
19318 
   - ex
19319 
  """
19320 
 
19321 
  thrift_spec = (
19322 
    (0, TType.BOOL, 'success', None, None, ), # 0
19323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19324 
  )
19325 
 
19326 
  def __init__(self, success=None, ex=None,):
19327 
    self.success = success
19328 
    self.ex = ex
19329 
 
19330 
  def read(self, iprot):
19331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19333 
      return
19334 
    iprot.readStructBegin()
19335 
    while True:
19336 
      (fname, ftype, fid) = iprot.readFieldBegin()
19337 
      if ftype == TType.STOP:
19338 
        break
19339 
      if fid == 0:
19340 
        if ftype == TType.BOOL:
19341 
          self.success = iprot.readBool();
19342 
        else:
19343 
          iprot.skip(ftype)
19344 
      elif fid == 1:
19345 
        if ftype == TType.STRUCT:
19346 
          self.ex = TransactionServiceException()
19347 
          self.ex.read(iprot)
19348 
        else:
19349 
          iprot.skip(ftype)
19350 
      else:
19351 
        iprot.skip(ftype)
19352 
      iprot.readFieldEnd()
19353 
    iprot.readStructEnd()
19354 
 
19355 
  def write(self, oprot):
19356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19358 
      return
19359 
    oprot.writeStructBegin('addDelayReason_result')
19360 
    if self.success is not None:
19361 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19362 
      oprot.writeBool(self.success)
19363 
      oprot.writeFieldEnd()
19364 
    if self.ex is not None:
19365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19366 
      self.ex.write(oprot)
19367 
      oprot.writeFieldEnd()
19368 
    oprot.writeFieldStop()
19369 
    oprot.writeStructEnd()
19370 
 
19371 
  def validate(self):
19372 
    return
19373 
 
19374 
 
19375 
  def __repr__(self):
19376 
    L = ['%s=%r' % (key, value)
19377 
      for key, value in self.__dict__.iteritems()]
19378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19379 
 
19380 
  def __eq__(self, other):
19381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19382 
 
19383 
  def __ne__(self, other):
19384 
    return not (self == other)
3956 chandransh 19385 
 
19386 
class reconcileCodCollection_args:
19387 
  """
19388 
  Attributes:
19389 
   - collectedAmountMap
19390 
   - xferBy
19391 
   - xferTxnId
19392 
   - xferDate
19393 
  """
19394 
 
19395 
  thrift_spec = (
19396 
    None, # 0
19397 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19398 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19399 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19400 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19401 
  )
19402 
 
19403 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19404 
    self.collectedAmountMap = collectedAmountMap
19405 
    self.xferBy = xferBy
19406 
    self.xferTxnId = xferTxnId
19407 
    self.xferDate = xferDate
19408 
 
19409 
  def read(self, iprot):
19410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19412 
      return
19413 
    iprot.readStructBegin()
19414 
    while True:
19415 
      (fname, ftype, fid) = iprot.readFieldBegin()
19416 
      if ftype == TType.STOP:
19417 
        break
19418 
      if fid == 1:
19419 
        if ftype == TType.MAP:
19420 
          self.collectedAmountMap = {}
6188 rajveer 19421 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19422 
          for _i457 in xrange(_size453):
19423 
            _key458 = iprot.readString();
19424 
            _val459 = iprot.readDouble();
19425 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19426 
          iprot.readMapEnd()
19427 
        else:
19428 
          iprot.skip(ftype)
19429 
      elif fid == 2:
19430 
        if ftype == TType.STRING:
19431 
          self.xferBy = iprot.readString();
19432 
        else:
19433 
          iprot.skip(ftype)
19434 
      elif fid == 3:
19435 
        if ftype == TType.STRING:
19436 
          self.xferTxnId = iprot.readString();
19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      elif fid == 4:
19440 
        if ftype == TType.I64:
19441 
          self.xferDate = iprot.readI64();
19442 
        else:
19443 
          iprot.skip(ftype)
19444 
      else:
19445 
        iprot.skip(ftype)
19446 
      iprot.readFieldEnd()
19447 
    iprot.readStructEnd()
19448 
 
19449 
  def write(self, oprot):
19450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19452 
      return
19453 
    oprot.writeStructBegin('reconcileCodCollection_args')
19454 
    if self.collectedAmountMap is not None:
19455 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19456 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19457 
      for kiter460,viter461 in self.collectedAmountMap.items():
19458 
        oprot.writeString(kiter460)
19459 
        oprot.writeDouble(viter461)
3956 chandransh 19460 
      oprot.writeMapEnd()
19461 
      oprot.writeFieldEnd()
19462 
    if self.xferBy is not None:
19463 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19464 
      oprot.writeString(self.xferBy)
19465 
      oprot.writeFieldEnd()
19466 
    if self.xferTxnId is not None:
19467 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19468 
      oprot.writeString(self.xferTxnId)
19469 
      oprot.writeFieldEnd()
19470 
    if self.xferDate is not None:
19471 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19472 
      oprot.writeI64(self.xferDate)
19473 
      oprot.writeFieldEnd()
19474 
    oprot.writeFieldStop()
19475 
    oprot.writeStructEnd()
19476 
 
19477 
  def validate(self):
19478 
    return
19479 
 
19480 
 
19481 
  def __repr__(self):
19482 
    L = ['%s=%r' % (key, value)
19483 
      for key, value in self.__dict__.iteritems()]
19484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19485 
 
19486 
  def __eq__(self, other):
19487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19488 
 
19489 
  def __ne__(self, other):
19490 
    return not (self == other)
19491 
 
19492 
class reconcileCodCollection_result:
19493 
  """
19494 
  Attributes:
19495 
   - success
19496 
   - ex
19497 
  """
19498 
 
19499 
  thrift_spec = (
19500 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19502 
  )
19503 
 
19504 
  def __init__(self, success=None, ex=None,):
19505 
    self.success = success
19506 
    self.ex = ex
19507 
 
19508 
  def read(self, iprot):
19509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19511 
      return
19512 
    iprot.readStructBegin()
19513 
    while True:
19514 
      (fname, ftype, fid) = iprot.readFieldBegin()
19515 
      if ftype == TType.STOP:
19516 
        break
19517 
      if fid == 0:
19518 
        if ftype == TType.MAP:
19519 
          self.success = {}
6188 rajveer 19520 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19521 
          for _i466 in xrange(_size462):
19522 
            _key467 = iprot.readString();
19523 
            _val468 = iprot.readString();
19524 
            self.success[_key467] = _val468
3956 chandransh 19525 
          iprot.readMapEnd()
19526 
        else:
19527 
          iprot.skip(ftype)
19528 
      elif fid == 1:
19529 
        if ftype == TType.STRUCT:
19530 
          self.ex = TransactionServiceException()
19531 
          self.ex.read(iprot)
19532 
        else:
19533 
          iprot.skip(ftype)
19534 
      else:
19535 
        iprot.skip(ftype)
19536 
      iprot.readFieldEnd()
19537 
    iprot.readStructEnd()
19538 
 
19539 
  def write(self, oprot):
19540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19542 
      return
19543 
    oprot.writeStructBegin('reconcileCodCollection_result')
19544 
    if self.success is not None:
19545 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19546 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19547 
      for kiter469,viter470 in self.success.items():
19548 
        oprot.writeString(kiter469)
19549 
        oprot.writeString(viter470)
3956 chandransh 19550 
      oprot.writeMapEnd()
19551 
      oprot.writeFieldEnd()
19552 
    if self.ex is not None:
19553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19554 
      self.ex.write(oprot)
19555 
      oprot.writeFieldEnd()
19556 
    oprot.writeFieldStop()
19557 
    oprot.writeStructEnd()
19558 
 
19559 
  def validate(self):
19560 
    return
19561 
 
19562 
 
19563 
  def __repr__(self):
19564 
    L = ['%s=%r' % (key, value)
19565 
      for key, value in self.__dict__.iteritems()]
19566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19567 
 
19568 
  def __eq__(self, other):
19569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19570 
 
19571 
  def __ne__(self, other):
19572 
    return not (self == other)
4008 mandeep.dh 19573 
 
19574 
class getTransactionsRequiringExtraProcessing_args:
19575 
  """
19576 
  Attributes:
19577 
   - category
19578 
  """
19579 
 
19580 
  thrift_spec = (
19581 
    None, # 0
19582 
    (1, TType.I32, 'category', None, None, ), # 1
19583 
  )
19584 
 
19585 
  def __init__(self, category=None,):
19586 
    self.category = category
19587 
 
19588 
  def read(self, iprot):
19589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19591 
      return
19592 
    iprot.readStructBegin()
19593 
    while True:
19594 
      (fname, ftype, fid) = iprot.readFieldBegin()
19595 
      if ftype == TType.STOP:
19596 
        break
19597 
      if fid == 1:
19598 
        if ftype == TType.I32:
19599 
          self.category = iprot.readI32();
19600 
        else:
19601 
          iprot.skip(ftype)
19602 
      else:
19603 
        iprot.skip(ftype)
19604 
      iprot.readFieldEnd()
19605 
    iprot.readStructEnd()
19606 
 
19607 
  def write(self, oprot):
19608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19610 
      return
19611 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19612 
    if self.category is not None:
19613 
      oprot.writeFieldBegin('category', TType.I32, 1)
19614 
      oprot.writeI32(self.category)
19615 
      oprot.writeFieldEnd()
19616 
    oprot.writeFieldStop()
19617 
    oprot.writeStructEnd()
19618 
 
19619 
  def validate(self):
19620 
    return
19621 
 
19622 
 
19623 
  def __repr__(self):
19624 
    L = ['%s=%r' % (key, value)
19625 
      for key, value in self.__dict__.iteritems()]
19626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19627 
 
19628 
  def __eq__(self, other):
19629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19630 
 
19631 
  def __ne__(self, other):
19632 
    return not (self == other)
19633 
 
19634 
class getTransactionsRequiringExtraProcessing_result:
19635 
  """
19636 
  Attributes:
19637 
   - success
19638 
  """
19639 
 
19640 
  thrift_spec = (
19641 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19642 
  )
19643 
 
19644 
  def __init__(self, success=None,):
19645 
    self.success = success
19646 
 
19647 
  def read(self, iprot):
19648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19650 
      return
19651 
    iprot.readStructBegin()
19652 
    while True:
19653 
      (fname, ftype, fid) = iprot.readFieldBegin()
19654 
      if ftype == TType.STOP:
19655 
        break
19656 
      if fid == 0:
19657 
        if ftype == TType.LIST:
19658 
          self.success = []
6188 rajveer 19659 
          (_etype474, _size471) = iprot.readListBegin()
19660 
          for _i475 in xrange(_size471):
19661 
            _elem476 = iprot.readI64();
19662 
            self.success.append(_elem476)
4008 mandeep.dh 19663 
          iprot.readListEnd()
19664 
        else:
19665 
          iprot.skip(ftype)
19666 
      else:
19667 
        iprot.skip(ftype)
19668 
      iprot.readFieldEnd()
19669 
    iprot.readStructEnd()
19670 
 
19671 
  def write(self, oprot):
19672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19674 
      return
19675 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19676 
    if self.success is not None:
19677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19678 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19679 
      for iter477 in self.success:
19680 
        oprot.writeI64(iter477)
4008 mandeep.dh 19681 
      oprot.writeListEnd()
19682 
      oprot.writeFieldEnd()
19683 
    oprot.writeFieldStop()
19684 
    oprot.writeStructEnd()
19685 
 
19686 
  def validate(self):
19687 
    return
19688 
 
19689 
 
19690 
  def __repr__(self):
19691 
    L = ['%s=%r' % (key, value)
19692 
      for key, value in self.__dict__.iteritems()]
19693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19694 
 
19695 
  def __eq__(self, other):
19696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19697 
 
19698 
  def __ne__(self, other):
19699 
    return not (self == other)
19700 
 
19701 
class markTransactionAsProcessed_args:
19702 
  """
19703 
  Attributes:
19704 
   - transactionId
19705 
   - category
19706 
  """
19707 
 
19708 
  thrift_spec = (
19709 
    None, # 0
19710 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19711 
    (2, TType.I32, 'category', None, None, ), # 2
19712 
  )
19713 
 
19714 
  def __init__(self, transactionId=None, category=None,):
19715 
    self.transactionId = transactionId
19716 
    self.category = category
19717 
 
19718 
  def read(self, iprot):
19719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19721 
      return
19722 
    iprot.readStructBegin()
19723 
    while True:
19724 
      (fname, ftype, fid) = iprot.readFieldBegin()
19725 
      if ftype == TType.STOP:
19726 
        break
19727 
      if fid == 1:
19728 
        if ftype == TType.I64:
19729 
          self.transactionId = iprot.readI64();
19730 
        else:
19731 
          iprot.skip(ftype)
19732 
      elif fid == 2:
19733 
        if ftype == TType.I32:
19734 
          self.category = iprot.readI32();
19735 
        else:
19736 
          iprot.skip(ftype)
19737 
      else:
19738 
        iprot.skip(ftype)
19739 
      iprot.readFieldEnd()
19740 
    iprot.readStructEnd()
19741 
 
19742 
  def write(self, oprot):
19743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19745 
      return
19746 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19747 
    if self.transactionId is not None:
19748 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19749 
      oprot.writeI64(self.transactionId)
19750 
      oprot.writeFieldEnd()
19751 
    if self.category is not None:
19752 
      oprot.writeFieldBegin('category', TType.I32, 2)
19753 
      oprot.writeI32(self.category)
19754 
      oprot.writeFieldEnd()
19755 
    oprot.writeFieldStop()
19756 
    oprot.writeStructEnd()
19757 
 
19758 
  def validate(self):
19759 
    return
19760 
 
19761 
 
19762 
  def __repr__(self):
19763 
    L = ['%s=%r' % (key, value)
19764 
      for key, value in self.__dict__.iteritems()]
19765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19766 
 
19767 
  def __eq__(self, other):
19768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19769 
 
19770 
  def __ne__(self, other):
19771 
    return not (self == other)
19772 
 
19773 
class markTransactionAsProcessed_result:
19774 
 
19775 
  thrift_spec = (
19776 
  )
19777 
 
19778 
  def read(self, iprot):
19779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19781 
      return
19782 
    iprot.readStructBegin()
19783 
    while True:
19784 
      (fname, ftype, fid) = iprot.readFieldBegin()
19785 
      if ftype == TType.STOP:
19786 
        break
19787 
      else:
19788 
        iprot.skip(ftype)
19789 
      iprot.readFieldEnd()
19790 
    iprot.readStructEnd()
19791 
 
19792 
  def write(self, oprot):
19793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19795 
      return
19796 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19797 
    oprot.writeFieldStop()
19798 
    oprot.writeStructEnd()
19799 
 
19800 
  def validate(self):
19801 
    return
19802 
 
19803 
 
19804 
  def __repr__(self):
19805 
    L = ['%s=%r' % (key, value)
19806 
      for key, value in self.__dict__.iteritems()]
19807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19808 
 
19809 
  def __eq__(self, other):
19810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19811 
 
19812 
  def __ne__(self, other):
19813 
    return not (self == other)
4018 chandransh 19814 
 
19815 
class getItemWiseRiskyOrdersCount_args:
19816 
 
19817 
  thrift_spec = (
19818 
  )
19819 
 
19820 
  def read(self, iprot):
19821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19823 
      return
19824 
    iprot.readStructBegin()
19825 
    while True:
19826 
      (fname, ftype, fid) = iprot.readFieldBegin()
19827 
      if ftype == TType.STOP:
19828 
        break
19829 
      else:
19830 
        iprot.skip(ftype)
19831 
      iprot.readFieldEnd()
19832 
    iprot.readStructEnd()
19833 
 
19834 
  def write(self, oprot):
19835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19837 
      return
19838 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19839 
    oprot.writeFieldStop()
19840 
    oprot.writeStructEnd()
19841 
 
19842 
  def validate(self):
19843 
    return
19844 
 
19845 
 
19846 
  def __repr__(self):
19847 
    L = ['%s=%r' % (key, value)
19848 
      for key, value in self.__dict__.iteritems()]
19849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19850 
 
19851 
  def __eq__(self, other):
19852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19853 
 
19854 
  def __ne__(self, other):
19855 
    return not (self == other)
19856 
 
19857 
class getItemWiseRiskyOrdersCount_result:
19858 
  """
19859 
  Attributes:
19860 
   - success
19861 
  """
19862 
 
19863 
  thrift_spec = (
19864 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19865 
  )
19866 
 
19867 
  def __init__(self, success=None,):
19868 
    self.success = success
19869 
 
19870 
  def read(self, iprot):
19871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19873 
      return
19874 
    iprot.readStructBegin()
19875 
    while True:
19876 
      (fname, ftype, fid) = iprot.readFieldBegin()
19877 
      if ftype == TType.STOP:
19878 
        break
19879 
      if fid == 0:
19880 
        if ftype == TType.MAP:
19881 
          self.success = {}
6188 rajveer 19882 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
19883 
          for _i482 in xrange(_size478):
19884 
            _key483 = iprot.readI64();
19885 
            _val484 = iprot.readI64();
19886 
            self.success[_key483] = _val484
4018 chandransh 19887 
          iprot.readMapEnd()
19888 
        else:
19889 
          iprot.skip(ftype)
19890 
      else:
19891 
        iprot.skip(ftype)
19892 
      iprot.readFieldEnd()
19893 
    iprot.readStructEnd()
19894 
 
19895 
  def write(self, oprot):
19896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19898 
      return
19899 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19900 
    if self.success is not None:
19901 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19902 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 19903 
      for kiter485,viter486 in self.success.items():
19904 
        oprot.writeI64(kiter485)
19905 
        oprot.writeI64(viter486)
4018 chandransh 19906 
      oprot.writeMapEnd()
19907 
      oprot.writeFieldEnd()
19908 
    oprot.writeFieldStop()
19909 
    oprot.writeStructEnd()
19910 
 
19911 
  def validate(self):
19912 
    return
19913 
 
19914 
 
19915 
  def __repr__(self):
19916 
    L = ['%s=%r' % (key, value)
19917 
      for key, value in self.__dict__.iteritems()]
19918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19919 
 
19920 
  def __eq__(self, other):
19921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19922 
 
19923 
  def __ne__(self, other):
19924 
    return not (self == other)
4247 rajveer 19925 
 
4295 varun.gupt 19926 
class getOrdersForItemIds_args:
19927 
  """
19928 
  Attributes:
19929 
   - itemIds
19930 
  """
19931 
 
19932 
  thrift_spec = (
19933 
    None, # 0
19934 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19935 
  )
19936 
 
19937 
  def __init__(self, itemIds=None,):
19938 
    self.itemIds = itemIds
19939 
 
19940 
  def read(self, iprot):
19941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19943 
      return
19944 
    iprot.readStructBegin()
19945 
    while True:
19946 
      (fname, ftype, fid) = iprot.readFieldBegin()
19947 
      if ftype == TType.STOP:
19948 
        break
19949 
      if fid == 1:
19950 
        if ftype == TType.LIST:
19951 
          self.itemIds = []
6188 rajveer 19952 
          (_etype490, _size487) = iprot.readListBegin()
19953 
          for _i491 in xrange(_size487):
19954 
            _elem492 = iprot.readI64();
19955 
            self.itemIds.append(_elem492)
4295 varun.gupt 19956 
          iprot.readListEnd()
19957 
        else:
19958 
          iprot.skip(ftype)
19959 
      else:
19960 
        iprot.skip(ftype)
19961 
      iprot.readFieldEnd()
19962 
    iprot.readStructEnd()
19963 
 
19964 
  def write(self, oprot):
19965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19967 
      return
19968 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19969 
    if self.itemIds is not None:
19970 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19971 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 19972 
      for iter493 in self.itemIds:
19973 
        oprot.writeI64(iter493)
4295 varun.gupt 19974 
      oprot.writeListEnd()
19975 
      oprot.writeFieldEnd()
19976 
    oprot.writeFieldStop()
19977 
    oprot.writeStructEnd()
19978 
 
19979 
  def validate(self):
19980 
    return
19981 
 
19982 
 
19983 
  def __repr__(self):
19984 
    L = ['%s=%r' % (key, value)
19985 
      for key, value in self.__dict__.iteritems()]
19986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19987 
 
19988 
  def __eq__(self, other):
19989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19990 
 
19991 
  def __ne__(self, other):
19992 
    return not (self == other)
19993 
 
19994 
class getOrdersForItemIds_result:
19995 
  """
19996 
  Attributes:
19997 
   - success
19998 
  """
19999 
 
20000 
  thrift_spec = (
20001 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20002 
  )
20003 
 
20004 
  def __init__(self, success=None,):
20005 
    self.success = success
20006 
 
20007 
  def read(self, iprot):
20008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20010 
      return
20011 
    iprot.readStructBegin()
20012 
    while True:
20013 
      (fname, ftype, fid) = iprot.readFieldBegin()
20014 
      if ftype == TType.STOP:
20015 
        break
20016 
      if fid == 0:
20017 
        if ftype == TType.LIST:
20018 
          self.success = []
6188 rajveer 20019 
          (_etype497, _size494) = iprot.readListBegin()
20020 
          for _i498 in xrange(_size494):
20021 
            _elem499 = Order()
20022 
            _elem499.read(iprot)
20023 
            self.success.append(_elem499)
4295 varun.gupt 20024 
          iprot.readListEnd()
20025 
        else:
20026 
          iprot.skip(ftype)
20027 
      else:
20028 
        iprot.skip(ftype)
20029 
      iprot.readFieldEnd()
20030 
    iprot.readStructEnd()
20031 
 
20032 
  def write(self, oprot):
20033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20035 
      return
20036 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20037 
    if self.success is not None:
20038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20040 
      for iter500 in self.success:
20041 
        iter500.write(oprot)
4295 varun.gupt 20042 
      oprot.writeListEnd()
20043 
      oprot.writeFieldEnd()
20044 
    oprot.writeFieldStop()
20045 
    oprot.writeStructEnd()
20046 
 
20047 
  def validate(self):
20048 
    return
20049 
 
20050 
 
20051 
  def __repr__(self):
20052 
    L = ['%s=%r' % (key, value)
20053 
      for key, value in self.__dict__.iteritems()]
20054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20055 
 
20056 
  def __eq__(self, other):
20057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20058 
 
20059 
  def __ne__(self, other):
20060 
    return not (self == other)
20061 
 
4247 rajveer 20062 
class markOrderCancellationRequestReceived_args:
20063 
  """
20064 
  Attributes:
20065 
   - orderId
20066 
  """
20067 
 
20068 
  thrift_spec = (
20069 
    None, # 0
20070 
    (1, TType.I64, 'orderId', None, None, ), # 1
20071 
  )
20072 
 
20073 
  def __init__(self, orderId=None,):
20074 
    self.orderId = orderId
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      if fid == 1:
20086 
        if ftype == TType.I64:
20087 
          self.orderId = iprot.readI64();
20088 
        else:
20089 
          iprot.skip(ftype)
20090 
      else:
20091 
        iprot.skip(ftype)
20092 
      iprot.readFieldEnd()
20093 
    iprot.readStructEnd()
20094 
 
20095 
  def write(self, oprot):
20096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20098 
      return
20099 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20100 
    if self.orderId is not None:
20101 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20102 
      oprot.writeI64(self.orderId)
20103 
      oprot.writeFieldEnd()
20104 
    oprot.writeFieldStop()
20105 
    oprot.writeStructEnd()
20106 
 
20107 
  def validate(self):
20108 
    return
20109 
 
20110 
 
20111 
  def __repr__(self):
20112 
    L = ['%s=%r' % (key, value)
20113 
      for key, value in self.__dict__.iteritems()]
20114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20115 
 
20116 
  def __eq__(self, other):
20117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20118 
 
20119 
  def __ne__(self, other):
20120 
    return not (self == other)
20121 
 
20122 
class markOrderCancellationRequestReceived_result:
20123 
  """
20124 
  Attributes:
20125 
   - ex
20126 
  """
20127 
 
20128 
  thrift_spec = (
20129 
    None, # 0
20130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20131 
  )
20132 
 
20133 
  def __init__(self, ex=None,):
20134 
    self.ex = ex
20135 
 
20136 
  def read(self, iprot):
20137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20139 
      return
20140 
    iprot.readStructBegin()
20141 
    while True:
20142 
      (fname, ftype, fid) = iprot.readFieldBegin()
20143 
      if ftype == TType.STOP:
20144 
        break
20145 
      if fid == 1:
20146 
        if ftype == TType.STRUCT:
20147 
          self.ex = TransactionServiceException()
20148 
          self.ex.read(iprot)
20149 
        else:
20150 
          iprot.skip(ftype)
20151 
      else:
20152 
        iprot.skip(ftype)
20153 
      iprot.readFieldEnd()
20154 
    iprot.readStructEnd()
20155 
 
20156 
  def write(self, oprot):
20157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20159 
      return
20160 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20161 
    if self.ex is not None:
20162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20163 
      self.ex.write(oprot)
20164 
      oprot.writeFieldEnd()
20165 
    oprot.writeFieldStop()
20166 
    oprot.writeStructEnd()
20167 
 
20168 
  def validate(self):
20169 
    return
20170 
 
20171 
 
20172 
  def __repr__(self):
20173 
    L = ['%s=%r' % (key, value)
20174 
      for key, value in self.__dict__.iteritems()]
20175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20176 
 
20177 
  def __eq__(self, other):
20178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20179 
 
20180 
  def __ne__(self, other):
20181 
    return not (self == other)
20182 
 
20183 
class markOrderCancellationRequestConfirmed_args:
20184 
  """
20185 
  Attributes:
20186 
   - orderId
20187 
  """
20188 
 
20189 
  thrift_spec = (
20190 
    None, # 0
20191 
    (1, TType.I64, 'orderId', None, None, ), # 1
20192 
  )
20193 
 
20194 
  def __init__(self, orderId=None,):
20195 
    self.orderId = orderId
20196 
 
20197 
  def read(self, iprot):
20198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20200 
      return
20201 
    iprot.readStructBegin()
20202 
    while True:
20203 
      (fname, ftype, fid) = iprot.readFieldBegin()
20204 
      if ftype == TType.STOP:
20205 
        break
20206 
      if fid == 1:
20207 
        if ftype == TType.I64:
20208 
          self.orderId = iprot.readI64();
20209 
        else:
20210 
          iprot.skip(ftype)
20211 
      else:
20212 
        iprot.skip(ftype)
20213 
      iprot.readFieldEnd()
20214 
    iprot.readStructEnd()
20215 
 
20216 
  def write(self, oprot):
20217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20219 
      return
20220 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20221 
    if self.orderId is not None:
20222 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20223 
      oprot.writeI64(self.orderId)
20224 
      oprot.writeFieldEnd()
20225 
    oprot.writeFieldStop()
20226 
    oprot.writeStructEnd()
20227 
 
20228 
  def validate(self):
20229 
    return
20230 
 
20231 
 
20232 
  def __repr__(self):
20233 
    L = ['%s=%r' % (key, value)
20234 
      for key, value in self.__dict__.iteritems()]
20235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20236 
 
20237 
  def __eq__(self, other):
20238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20239 
 
20240 
  def __ne__(self, other):
20241 
    return not (self == other)
20242 
 
20243 
class markOrderCancellationRequestConfirmed_result:
20244 
  """
20245 
  Attributes:
20246 
   - ex
20247 
  """
20248 
 
20249 
  thrift_spec = (
20250 
    None, # 0
20251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20252 
  )
20253 
 
20254 
  def __init__(self, ex=None,):
20255 
    self.ex = ex
20256 
 
20257 
  def read(self, iprot):
20258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20260 
      return
20261 
    iprot.readStructBegin()
20262 
    while True:
20263 
      (fname, ftype, fid) = iprot.readFieldBegin()
20264 
      if ftype == TType.STOP:
20265 
        break
20266 
      if fid == 1:
20267 
        if ftype == TType.STRUCT:
20268 
          self.ex = TransactionServiceException()
20269 
          self.ex.read(iprot)
20270 
        else:
20271 
          iprot.skip(ftype)
20272 
      else:
20273 
        iprot.skip(ftype)
20274 
      iprot.readFieldEnd()
20275 
    iprot.readStructEnd()
20276 
 
20277 
  def write(self, oprot):
20278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20280 
      return
20281 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20282 
    if self.ex is not None:
20283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20284 
      self.ex.write(oprot)
20285 
      oprot.writeFieldEnd()
20286 
    oprot.writeFieldStop()
20287 
    oprot.writeStructEnd()
20288 
 
20289 
  def validate(self):
20290 
    return
20291 
 
20292 
 
20293 
  def __repr__(self):
20294 
    L = ['%s=%r' % (key, value)
20295 
      for key, value in self.__dict__.iteritems()]
20296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20297 
 
20298 
  def __eq__(self, other):
20299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20300 
 
20301 
  def __ne__(self, other):
20302 
    return not (self == other)
20303 
 
20304 
class markOrderCancellationRequestDenied_args:
20305 
  """
20306 
  Attributes:
20307 
   - orderId
20308 
  """
20309 
 
20310 
  thrift_spec = (
20311 
    None, # 0
20312 
    (1, TType.I64, 'orderId', None, None, ), # 1
20313 
  )
20314 
 
20315 
  def __init__(self, orderId=None,):
20316 
    self.orderId = orderId
20317 
 
20318 
  def read(self, iprot):
20319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20321 
      return
20322 
    iprot.readStructBegin()
20323 
    while True:
20324 
      (fname, ftype, fid) = iprot.readFieldBegin()
20325 
      if ftype == TType.STOP:
20326 
        break
20327 
      if fid == 1:
20328 
        if ftype == TType.I64:
20329 
          self.orderId = iprot.readI64();
20330 
        else:
20331 
          iprot.skip(ftype)
20332 
      else:
20333 
        iprot.skip(ftype)
20334 
      iprot.readFieldEnd()
20335 
    iprot.readStructEnd()
20336 
 
20337 
  def write(self, oprot):
20338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20340 
      return
20341 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20342 
    if self.orderId is not None:
20343 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20344 
      oprot.writeI64(self.orderId)
20345 
      oprot.writeFieldEnd()
20346 
    oprot.writeFieldStop()
20347 
    oprot.writeStructEnd()
20348 
 
20349 
  def validate(self):
20350 
    return
20351 
 
20352 
 
20353 
  def __repr__(self):
20354 
    L = ['%s=%r' % (key, value)
20355 
      for key, value in self.__dict__.iteritems()]
20356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20357 
 
20358 
  def __eq__(self, other):
20359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20360 
 
20361 
  def __ne__(self, other):
20362 
    return not (self == other)
20363 
 
20364 
class markOrderCancellationRequestDenied_result:
20365 
  """
20366 
  Attributes:
20367 
   - ex
20368 
  """
20369 
 
20370 
  thrift_spec = (
20371 
    None, # 0
20372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20373 
  )
20374 
 
20375 
  def __init__(self, ex=None,):
20376 
    self.ex = ex
20377 
 
20378 
  def read(self, iprot):
20379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20381 
      return
20382 
    iprot.readStructBegin()
20383 
    while True:
20384 
      (fname, ftype, fid) = iprot.readFieldBegin()
20385 
      if ftype == TType.STOP:
20386 
        break
20387 
      if fid == 1:
20388 
        if ftype == TType.STRUCT:
20389 
          self.ex = TransactionServiceException()
20390 
          self.ex.read(iprot)
20391 
        else:
20392 
          iprot.skip(ftype)
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20403 
    if self.ex is not None:
20404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20405 
      self.ex.write(oprot)
20406 
      oprot.writeFieldEnd()
20407 
    oprot.writeFieldStop()
20408 
    oprot.writeStructEnd()
20409 
 
20410 
  def validate(self):
20411 
    return
20412 
 
20413 
 
20414 
  def __repr__(self):
20415 
    L = ['%s=%r' % (key, value)
20416 
      for key, value in self.__dict__.iteritems()]
20417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20418 
 
20419 
  def __eq__(self, other):
20420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20421 
 
20422 
  def __ne__(self, other):
20423 
    return not (self == other)
20424 
 
4258 rajveer 20425 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20426 
  """
20427 
  Attributes:
4258 rajveer 20428 
   - transactionId
4247 rajveer 20429 
  """
20430 
 
20431 
  thrift_spec = (
20432 
    None, # 0
4258 rajveer 20433 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20434 
  )
20435 
 
4258 rajveer 20436 
  def __init__(self, transactionId=None,):
20437 
    self.transactionId = transactionId
4247 rajveer 20438 
 
20439 
  def read(self, iprot):
20440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20442 
      return
20443 
    iprot.readStructBegin()
20444 
    while True:
20445 
      (fname, ftype, fid) = iprot.readFieldBegin()
20446 
      if ftype == TType.STOP:
20447 
        break
20448 
      if fid == 1:
20449 
        if ftype == TType.I64:
4258 rajveer 20450 
          self.transactionId = iprot.readI64();
4247 rajveer 20451 
        else:
20452 
          iprot.skip(ftype)
20453 
      else:
20454 
        iprot.skip(ftype)
20455 
      iprot.readFieldEnd()
20456 
    iprot.readStructEnd()
20457 
 
20458 
  def write(self, oprot):
20459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20461 
      return
4258 rajveer 20462 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20463 
    if self.transactionId is not None:
20464 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20465 
      oprot.writeI64(self.transactionId)
4247 rajveer 20466 
      oprot.writeFieldEnd()
20467 
    oprot.writeFieldStop()
20468 
    oprot.writeStructEnd()
20469 
 
20470 
  def validate(self):
20471 
    return
20472 
 
20473 
 
20474 
  def __repr__(self):
20475 
    L = ['%s=%r' % (key, value)
20476 
      for key, value in self.__dict__.iteritems()]
20477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20478 
 
20479 
  def __eq__(self, other):
20480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20481 
 
20482 
  def __ne__(self, other):
20483 
    return not (self == other)
20484 
 
4258 rajveer 20485 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20486 
  """
20487 
  Attributes:
20488 
   - ex
20489 
  """
20490 
 
20491 
  thrift_spec = (
20492 
    None, # 0
20493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20494 
  )
20495 
 
20496 
  def __init__(self, ex=None,):
20497 
    self.ex = ex
20498 
 
20499 
  def read(self, iprot):
20500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20502 
      return
20503 
    iprot.readStructBegin()
20504 
    while True:
20505 
      (fname, ftype, fid) = iprot.readFieldBegin()
20506 
      if ftype == TType.STOP:
20507 
        break
20508 
      if fid == 1:
20509 
        if ftype == TType.STRUCT:
20510 
          self.ex = TransactionServiceException()
20511 
          self.ex.read(iprot)
20512 
        else:
20513 
          iprot.skip(ftype)
20514 
      else:
20515 
        iprot.skip(ftype)
20516 
      iprot.readFieldEnd()
20517 
    iprot.readStructEnd()
20518 
 
20519 
  def write(self, oprot):
20520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20522 
      return
4258 rajveer 20523 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20524 
    if self.ex is not None:
20525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20526 
      self.ex.write(oprot)
20527 
      oprot.writeFieldEnd()
20528 
    oprot.writeFieldStop()
20529 
    oprot.writeStructEnd()
20530 
 
20531 
  def validate(self):
20532 
    return
20533 
 
20534 
 
20535 
  def __repr__(self):
20536 
    L = ['%s=%r' % (key, value)
20537 
      for key, value in self.__dict__.iteritems()]
20538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20539 
 
20540 
  def __eq__(self, other):
20541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20542 
 
20543 
  def __ne__(self, other):
20544 
    return not (self == other)
4259 anupam.sin 20545 
 
20546 
class refundTransaction_args:
20547 
  """
20548 
  Attributes:
20549 
   - transactionId
20550 
   - refundedBy
20551 
   - reason
20552 
  """
20553 
 
20554 
  thrift_spec = (
20555 
    None, # 0
20556 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20557 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20558 
    (3, TType.STRING, 'reason', None, None, ), # 3
20559 
  )
20560 
 
20561 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20562 
    self.transactionId = transactionId
20563 
    self.refundedBy = refundedBy
20564 
    self.reason = reason
20565 
 
20566 
  def read(self, iprot):
20567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20569 
      return
20570 
    iprot.readStructBegin()
20571 
    while True:
20572 
      (fname, ftype, fid) = iprot.readFieldBegin()
20573 
      if ftype == TType.STOP:
20574 
        break
20575 
      if fid == 1:
20576 
        if ftype == TType.I64:
20577 
          self.transactionId = iprot.readI64();
20578 
        else:
20579 
          iprot.skip(ftype)
20580 
      elif fid == 2:
20581 
        if ftype == TType.STRING:
20582 
          self.refundedBy = iprot.readString();
20583 
        else:
20584 
          iprot.skip(ftype)
20585 
      elif fid == 3:
20586 
        if ftype == TType.STRING:
20587 
          self.reason = iprot.readString();
20588 
        else:
20589 
          iprot.skip(ftype)
20590 
      else:
20591 
        iprot.skip(ftype)
20592 
      iprot.readFieldEnd()
20593 
    iprot.readStructEnd()
20594 
 
20595 
  def write(self, oprot):
20596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20598 
      return
20599 
    oprot.writeStructBegin('refundTransaction_args')
20600 
    if self.transactionId is not None:
20601 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20602 
      oprot.writeI64(self.transactionId)
20603 
      oprot.writeFieldEnd()
20604 
    if self.refundedBy is not None:
20605 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20606 
      oprot.writeString(self.refundedBy)
20607 
      oprot.writeFieldEnd()
20608 
    if self.reason is not None:
20609 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20610 
      oprot.writeString(self.reason)
20611 
      oprot.writeFieldEnd()
20612 
    oprot.writeFieldStop()
20613 
    oprot.writeStructEnd()
20614 
 
20615 
  def validate(self):
20616 
    return
20617 
 
20618 
 
20619 
  def __repr__(self):
20620 
    L = ['%s=%r' % (key, value)
20621 
      for key, value in self.__dict__.iteritems()]
20622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20623 
 
20624 
  def __eq__(self, other):
20625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20626 
 
20627 
  def __ne__(self, other):
20628 
    return not (self == other)
20629 
 
20630 
class refundTransaction_result:
20631 
  """
20632 
  Attributes:
20633 
   - ex
20634 
  """
20635 
 
20636 
  thrift_spec = (
20637 
    None, # 0
20638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20639 
  )
20640 
 
20641 
  def __init__(self, ex=None,):
20642 
    self.ex = ex
20643 
 
20644 
  def read(self, iprot):
20645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20647 
      return
20648 
    iprot.readStructBegin()
20649 
    while True:
20650 
      (fname, ftype, fid) = iprot.readFieldBegin()
20651 
      if ftype == TType.STOP:
20652 
        break
20653 
      if fid == 1:
20654 
        if ftype == TType.STRUCT:
20655 
          self.ex = TransactionServiceException()
20656 
          self.ex.read(iprot)
20657 
        else:
20658 
          iprot.skip(ftype)
20659 
      else:
20660 
        iprot.skip(ftype)
20661 
      iprot.readFieldEnd()
20662 
    iprot.readStructEnd()
20663 
 
20664 
  def write(self, oprot):
20665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20667 
      return
20668 
    oprot.writeStructBegin('refundTransaction_result')
20669 
    if self.ex is not None:
20670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20671 
      self.ex.write(oprot)
20672 
      oprot.writeFieldEnd()
20673 
    oprot.writeFieldStop()
20674 
    oprot.writeStructEnd()
20675 
 
20676 
  def validate(self):
20677 
    return
20678 
 
20679 
 
20680 
  def __repr__(self):
20681 
    L = ['%s=%r' % (key, value)
20682 
      for key, value in self.__dict__.iteritems()]
20683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20684 
 
20685 
  def __eq__(self, other):
20686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20687 
 
20688 
  def __ne__(self, other):
20689 
    return not (self == other)
4285 rajveer 20690 
 
4324 mandeep.dh 20691 
class updateShipmentAddress_args:
20692 
  """
20693 
  Attributes:
20694 
   - orderId
20695 
   - addressId
20696 
  """
20697 
 
20698 
  thrift_spec = (
20699 
    None, # 0
20700 
    (1, TType.I64, 'orderId', None, None, ), # 1
20701 
    (2, TType.I64, 'addressId', None, None, ), # 2
20702 
  )
20703 
 
20704 
  def __init__(self, orderId=None, addressId=None,):
20705 
    self.orderId = orderId
20706 
    self.addressId = addressId
20707 
 
20708 
  def read(self, iprot):
20709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20711 
      return
20712 
    iprot.readStructBegin()
20713 
    while True:
20714 
      (fname, ftype, fid) = iprot.readFieldBegin()
20715 
      if ftype == TType.STOP:
20716 
        break
20717 
      if fid == 1:
20718 
        if ftype == TType.I64:
20719 
          self.orderId = iprot.readI64();
20720 
        else:
20721 
          iprot.skip(ftype)
20722 
      elif fid == 2:
20723 
        if ftype == TType.I64:
20724 
          self.addressId = iprot.readI64();
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('updateShipmentAddress_args')
20737 
    if self.orderId is not None:
20738 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20739 
      oprot.writeI64(self.orderId)
20740 
      oprot.writeFieldEnd()
20741 
    if self.addressId is not None:
20742 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20743 
      oprot.writeI64(self.addressId)
20744 
      oprot.writeFieldEnd()
20745 
    oprot.writeFieldStop()
20746 
    oprot.writeStructEnd()
20747 
 
20748 
  def validate(self):
20749 
    return
20750 
 
20751 
 
20752 
  def __repr__(self):
20753 
    L = ['%s=%r' % (key, value)
20754 
      for key, value in self.__dict__.iteritems()]
20755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20756 
 
20757 
  def __eq__(self, other):
20758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20759 
 
20760 
  def __ne__(self, other):
20761 
    return not (self == other)
20762 
 
20763 
class updateShipmentAddress_result:
20764 
  """
20765 
  Attributes:
20766 
   - ex
20767 
  """
20768 
 
20769 
  thrift_spec = (
20770 
    None, # 0
20771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20772 
  )
20773 
 
20774 
  def __init__(self, ex=None,):
20775 
    self.ex = ex
20776 
 
20777 
  def read(self, iprot):
20778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20780 
      return
20781 
    iprot.readStructBegin()
20782 
    while True:
20783 
      (fname, ftype, fid) = iprot.readFieldBegin()
20784 
      if ftype == TType.STOP:
20785 
        break
20786 
      if fid == 1:
20787 
        if ftype == TType.STRUCT:
20788 
          self.ex = TransactionServiceException()
20789 
          self.ex.read(iprot)
20790 
        else:
20791 
          iprot.skip(ftype)
20792 
      else:
20793 
        iprot.skip(ftype)
20794 
      iprot.readFieldEnd()
20795 
    iprot.readStructEnd()
20796 
 
20797 
  def write(self, oprot):
20798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20800 
      return
20801 
    oprot.writeStructBegin('updateShipmentAddress_result')
20802 
    if self.ex is not None:
20803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20804 
      self.ex.write(oprot)
20805 
      oprot.writeFieldEnd()
20806 
    oprot.writeFieldStop()
20807 
    oprot.writeStructEnd()
20808 
 
20809 
  def validate(self):
20810 
    return
20811 
 
20812 
 
20813 
  def __repr__(self):
20814 
    L = ['%s=%r' % (key, value)
20815 
      for key, value in self.__dict__.iteritems()]
20816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20817 
 
20818 
  def __eq__(self, other):
20819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20820 
 
20821 
  def __ne__(self, other):
20822 
    return not (self == other)
20823 
 
4285 rajveer 20824 
class acceptOrdersForItemId_args:
20825 
  """
20826 
  Attributes:
20827 
   - itemId
20828 
   - inventory
20829 
  """
20830 
 
20831 
  thrift_spec = (
20832 
    None, # 0
20833 
    (1, TType.I64, 'itemId', None, None, ), # 1
20834 
    (2, TType.I64, 'inventory', None, None, ), # 2
20835 
  )
20836 
 
20837 
  def __init__(self, itemId=None, inventory=None,):
20838 
    self.itemId = itemId
20839 
    self.inventory = inventory
20840 
 
20841 
  def read(self, iprot):
20842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20844 
      return
20845 
    iprot.readStructBegin()
20846 
    while True:
20847 
      (fname, ftype, fid) = iprot.readFieldBegin()
20848 
      if ftype == TType.STOP:
20849 
        break
20850 
      if fid == 1:
20851 
        if ftype == TType.I64:
20852 
          self.itemId = iprot.readI64();
20853 
        else:
20854 
          iprot.skip(ftype)
20855 
      elif fid == 2:
20856 
        if ftype == TType.I64:
20857 
          self.inventory = iprot.readI64();
20858 
        else:
20859 
          iprot.skip(ftype)
20860 
      else:
20861 
        iprot.skip(ftype)
20862 
      iprot.readFieldEnd()
20863 
    iprot.readStructEnd()
20864 
 
20865 
  def write(self, oprot):
20866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20868 
      return
20869 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20870 
    if self.itemId is not None:
20871 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20872 
      oprot.writeI64(self.itemId)
20873 
      oprot.writeFieldEnd()
20874 
    if self.inventory is not None:
20875 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20876 
      oprot.writeI64(self.inventory)
20877 
      oprot.writeFieldEnd()
20878 
    oprot.writeFieldStop()
20879 
    oprot.writeStructEnd()
20880 
 
20881 
  def validate(self):
20882 
    return
20883 
 
20884 
 
20885 
  def __repr__(self):
20886 
    L = ['%s=%r' % (key, value)
20887 
      for key, value in self.__dict__.iteritems()]
20888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20889 
 
20890 
  def __eq__(self, other):
20891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20892 
 
20893 
  def __ne__(self, other):
20894 
    return not (self == other)
20895 
 
20896 
class acceptOrdersForItemId_result:
20897 
  """
20898 
  Attributes:
20899 
   - success
20900 
   - ex
20901 
  """
20902 
 
20903 
  thrift_spec = (
20904 
    (0, TType.BOOL, 'success', None, None, ), # 0
20905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20906 
  )
20907 
 
20908 
  def __init__(self, success=None, ex=None,):
20909 
    self.success = success
20910 
    self.ex = ex
20911 
 
20912 
  def read(self, iprot):
20913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20915 
      return
20916 
    iprot.readStructBegin()
20917 
    while True:
20918 
      (fname, ftype, fid) = iprot.readFieldBegin()
20919 
      if ftype == TType.STOP:
20920 
        break
20921 
      if fid == 0:
20922 
        if ftype == TType.BOOL:
20923 
          self.success = iprot.readBool();
20924 
        else:
20925 
          iprot.skip(ftype)
20926 
      elif fid == 1:
20927 
        if ftype == TType.STRUCT:
20928 
          self.ex = TransactionServiceException()
20929 
          self.ex.read(iprot)
20930 
        else:
20931 
          iprot.skip(ftype)
20932 
      else:
20933 
        iprot.skip(ftype)
20934 
      iprot.readFieldEnd()
20935 
    iprot.readStructEnd()
20936 
 
20937 
  def write(self, oprot):
20938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20940 
      return
20941 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20942 
    if self.success is not None:
20943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20944 
      oprot.writeBool(self.success)
20945 
      oprot.writeFieldEnd()
20946 
    if self.ex is not None:
20947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20948 
      self.ex.write(oprot)
20949 
      oprot.writeFieldEnd()
20950 
    oprot.writeFieldStop()
20951 
    oprot.writeStructEnd()
20952 
 
20953 
  def validate(self):
20954 
    return
20955 
 
20956 
 
20957 
  def __repr__(self):
20958 
    L = ['%s=%r' % (key, value)
20959 
      for key, value in self.__dict__.iteritems()]
20960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20961 
 
20962 
  def __eq__(self, other):
20963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20964 
 
20965 
  def __ne__(self, other):
20966 
    return not (self == other)
4303 rajveer 20967 
 
20968 
class markOrdersAsPORaised_args:
20969 
  """
20970 
  Attributes:
20971 
   - vendorId
20972 
   - itemId
20973 
   - quantity
20974 
   - estimate
4369 rajveer 20975 
   - isReminder
4303 rajveer 20976 
  """
20977 
 
20978 
  thrift_spec = (
20979 
    None, # 0
20980 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20981 
    (2, TType.I64, 'itemId', None, None, ), # 2
20982 
    (3, TType.I64, 'quantity', None, None, ), # 3
20983 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20984 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20985 
  )
20986 
 
4369 rajveer 20987 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20988 
    self.vendorId = vendorId
20989 
    self.itemId = itemId
20990 
    self.quantity = quantity
20991 
    self.estimate = estimate
4369 rajveer 20992 
    self.isReminder = isReminder
4303 rajveer 20993 
 
20994 
  def read(self, iprot):
20995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20997 
      return
20998 
    iprot.readStructBegin()
20999 
    while True:
21000 
      (fname, ftype, fid) = iprot.readFieldBegin()
21001 
      if ftype == TType.STOP:
21002 
        break
21003 
      if fid == 1:
21004 
        if ftype == TType.I64:
21005 
          self.vendorId = iprot.readI64();
21006 
        else:
21007 
          iprot.skip(ftype)
21008 
      elif fid == 2:
21009 
        if ftype == TType.I64:
21010 
          self.itemId = iprot.readI64();
21011 
        else:
21012 
          iprot.skip(ftype)
21013 
      elif fid == 3:
21014 
        if ftype == TType.I64:
21015 
          self.quantity = iprot.readI64();
21016 
        else:
21017 
          iprot.skip(ftype)
21018 
      elif fid == 4:
21019 
        if ftype == TType.I64:
21020 
          self.estimate = iprot.readI64();
21021 
        else:
21022 
          iprot.skip(ftype)
4369 rajveer 21023 
      elif fid == 5:
21024 
        if ftype == TType.BOOL:
21025 
          self.isReminder = iprot.readBool();
21026 
        else:
21027 
          iprot.skip(ftype)
4303 rajveer 21028 
      else:
21029 
        iprot.skip(ftype)
21030 
      iprot.readFieldEnd()
21031 
    iprot.readStructEnd()
21032 
 
21033 
  def write(self, oprot):
21034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21036 
      return
21037 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21038 
    if self.vendorId is not None:
21039 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21040 
      oprot.writeI64(self.vendorId)
21041 
      oprot.writeFieldEnd()
21042 
    if self.itemId is not None:
21043 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21044 
      oprot.writeI64(self.itemId)
21045 
      oprot.writeFieldEnd()
21046 
    if self.quantity is not None:
21047 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21048 
      oprot.writeI64(self.quantity)
21049 
      oprot.writeFieldEnd()
21050 
    if self.estimate is not None:
21051 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21052 
      oprot.writeI64(self.estimate)
21053 
      oprot.writeFieldEnd()
4369 rajveer 21054 
    if self.isReminder is not None:
21055 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21056 
      oprot.writeBool(self.isReminder)
21057 
      oprot.writeFieldEnd()
4303 rajveer 21058 
    oprot.writeFieldStop()
21059 
    oprot.writeStructEnd()
21060 
 
21061 
  def validate(self):
21062 
    return
21063 
 
21064 
 
21065 
  def __repr__(self):
21066 
    L = ['%s=%r' % (key, value)
21067 
      for key, value in self.__dict__.iteritems()]
21068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21069 
 
21070 
  def __eq__(self, other):
21071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21072 
 
21073 
  def __ne__(self, other):
21074 
    return not (self == other)
21075 
 
21076 
class markOrdersAsPORaised_result:
21077 
  """
21078 
  Attributes:
21079 
   - ex
21080 
  """
21081 
 
21082 
  thrift_spec = (
21083 
    None, # 0
21084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21085 
  )
21086 
 
21087 
  def __init__(self, ex=None,):
21088 
    self.ex = ex
21089 
 
21090 
  def read(self, iprot):
21091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21093 
      return
21094 
    iprot.readStructBegin()
21095 
    while True:
21096 
      (fname, ftype, fid) = iprot.readFieldBegin()
21097 
      if ftype == TType.STOP:
21098 
        break
21099 
      if fid == 1:
21100 
        if ftype == TType.STRUCT:
21101 
          self.ex = TransactionServiceException()
21102 
          self.ex.read(iprot)
21103 
        else:
21104 
          iprot.skip(ftype)
21105 
      else:
21106 
        iprot.skip(ftype)
21107 
      iprot.readFieldEnd()
21108 
    iprot.readStructEnd()
21109 
 
21110 
  def write(self, oprot):
21111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21113 
      return
21114 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21115 
    if self.ex is not None:
21116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21117 
      self.ex.write(oprot)
21118 
      oprot.writeFieldEnd()
21119 
    oprot.writeFieldStop()
21120 
    oprot.writeStructEnd()
21121 
 
21122 
  def validate(self):
21123 
    return
21124 
 
21125 
 
21126 
  def __repr__(self):
21127 
    L = ['%s=%r' % (key, value)
21128 
      for key, value in self.__dict__.iteritems()]
21129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21130 
 
21131 
  def __eq__(self, other):
21132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21133 
 
21134 
  def __ne__(self, other):
21135 
    return not (self == other)
21136 
 
21137 
class markOrdersAsReversalInitiated_args:
21138 
  """
21139 
  Attributes:
21140 
   - vendorId
21141 
   - itemId
21142 
   - quantity
21143 
   - estimate
4369 rajveer 21144 
   - isReminder
4303 rajveer 21145 
  """
21146 
 
21147 
  thrift_spec = (
21148 
    None, # 0
21149 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21150 
    (2, TType.I64, 'itemId', None, None, ), # 2
21151 
    (3, TType.I64, 'quantity', None, None, ), # 3
21152 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21153 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21154 
  )
21155 
 
4369 rajveer 21156 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21157 
    self.vendorId = vendorId
21158 
    self.itemId = itemId
21159 
    self.quantity = quantity
21160 
    self.estimate = estimate
4369 rajveer 21161 
    self.isReminder = isReminder
4303 rajveer 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.vendorId = iprot.readI64();
21175 
        else:
21176 
          iprot.skip(ftype)
21177 
      elif fid == 2:
21178 
        if ftype == TType.I64:
21179 
          self.itemId = iprot.readI64();
21180 
        else:
21181 
          iprot.skip(ftype)
21182 
      elif fid == 3:
21183 
        if ftype == TType.I64:
21184 
          self.quantity = iprot.readI64();
21185 
        else:
21186 
          iprot.skip(ftype)
21187 
      elif fid == 4:
21188 
        if ftype == TType.I64:
21189 
          self.estimate = iprot.readI64();
21190 
        else:
21191 
          iprot.skip(ftype)
4369 rajveer 21192 
      elif fid == 5:
21193 
        if ftype == TType.BOOL:
21194 
          self.isReminder = iprot.readBool();
21195 
        else:
21196 
          iprot.skip(ftype)
4303 rajveer 21197 
      else:
21198 
        iprot.skip(ftype)
21199 
      iprot.readFieldEnd()
21200 
    iprot.readStructEnd()
21201 
 
21202 
  def write(self, oprot):
21203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21205 
      return
21206 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21207 
    if self.vendorId is not None:
21208 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21209 
      oprot.writeI64(self.vendorId)
21210 
      oprot.writeFieldEnd()
21211 
    if self.itemId is not None:
21212 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21213 
      oprot.writeI64(self.itemId)
21214 
      oprot.writeFieldEnd()
21215 
    if self.quantity is not None:
21216 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21217 
      oprot.writeI64(self.quantity)
21218 
      oprot.writeFieldEnd()
21219 
    if self.estimate is not None:
21220 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21221 
      oprot.writeI64(self.estimate)
21222 
      oprot.writeFieldEnd()
4369 rajveer 21223 
    if self.isReminder is not None:
21224 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21225 
      oprot.writeBool(self.isReminder)
21226 
      oprot.writeFieldEnd()
4303 rajveer 21227 
    oprot.writeFieldStop()
21228 
    oprot.writeStructEnd()
21229 
 
21230 
  def validate(self):
21231 
    return
21232 
 
21233 
 
21234 
  def __repr__(self):
21235 
    L = ['%s=%r' % (key, value)
21236 
      for key, value in self.__dict__.iteritems()]
21237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21238 
 
21239 
  def __eq__(self, other):
21240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21241 
 
21242 
  def __ne__(self, other):
21243 
    return not (self == other)
21244 
 
21245 
class markOrdersAsReversalInitiated_result:
21246 
  """
21247 
  Attributes:
21248 
   - ex
21249 
  """
21250 
 
21251 
  thrift_spec = (
21252 
    None, # 0
21253 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21254 
  )
21255 
 
21256 
  def __init__(self, ex=None,):
21257 
    self.ex = ex
21258 
 
21259 
  def read(self, iprot):
21260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21262 
      return
21263 
    iprot.readStructBegin()
21264 
    while True:
21265 
      (fname, ftype, fid) = iprot.readFieldBegin()
21266 
      if ftype == TType.STOP:
21267 
        break
21268 
      if fid == 1:
21269 
        if ftype == TType.STRUCT:
21270 
          self.ex = TransactionServiceException()
21271 
          self.ex.read(iprot)
21272 
        else:
21273 
          iprot.skip(ftype)
21274 
      else:
21275 
        iprot.skip(ftype)
21276 
      iprot.readFieldEnd()
21277 
    iprot.readStructEnd()
21278 
 
21279 
  def write(self, oprot):
21280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21282 
      return
21283 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21284 
    if self.ex is not None:
21285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21286 
      self.ex.write(oprot)
21287 
      oprot.writeFieldEnd()
21288 
    oprot.writeFieldStop()
21289 
    oprot.writeStructEnd()
21290 
 
21291 
  def validate(self):
21292 
    return
21293 
 
21294 
 
21295 
  def __repr__(self):
21296 
    L = ['%s=%r' % (key, value)
21297 
      for key, value in self.__dict__.iteritems()]
21298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21299 
 
21300 
  def __eq__(self, other):
21301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21302 
 
21303 
  def __ne__(self, other):
21304 
    return not (self == other)
21305 
 
21306 
class markOrdersAsNotAvailabke_args:
21307 
  """
21308 
  Attributes:
21309 
   - vendorId
21310 
   - itemId
21311 
   - quantity
21312 
   - estimate
4369 rajveer 21313 
   - isReminder
4303 rajveer 21314 
  """
21315 
 
21316 
  thrift_spec = (
21317 
    None, # 0
21318 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21319 
    (2, TType.I64, 'itemId', None, None, ), # 2
21320 
    (3, TType.I64, 'quantity', None, None, ), # 3
21321 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21322 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21323 
  )
21324 
 
4369 rajveer 21325 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21326 
    self.vendorId = vendorId
21327 
    self.itemId = itemId
21328 
    self.quantity = quantity
21329 
    self.estimate = estimate
4369 rajveer 21330 
    self.isReminder = isReminder
4303 rajveer 21331 
 
21332 
  def read(self, iprot):
21333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21335 
      return
21336 
    iprot.readStructBegin()
21337 
    while True:
21338 
      (fname, ftype, fid) = iprot.readFieldBegin()
21339 
      if ftype == TType.STOP:
21340 
        break
21341 
      if fid == 1:
21342 
        if ftype == TType.I64:
21343 
          self.vendorId = iprot.readI64();
21344 
        else:
21345 
          iprot.skip(ftype)
21346 
      elif fid == 2:
21347 
        if ftype == TType.I64:
21348 
          self.itemId = iprot.readI64();
21349 
        else:
21350 
          iprot.skip(ftype)
21351 
      elif fid == 3:
21352 
        if ftype == TType.I64:
21353 
          self.quantity = iprot.readI64();
21354 
        else:
21355 
          iprot.skip(ftype)
21356 
      elif fid == 4:
21357 
        if ftype == TType.I64:
21358 
          self.estimate = iprot.readI64();
21359 
        else:
21360 
          iprot.skip(ftype)
4369 rajveer 21361 
      elif fid == 5:
21362 
        if ftype == TType.BOOL:
21363 
          self.isReminder = iprot.readBool();
21364 
        else:
21365 
          iprot.skip(ftype)
4303 rajveer 21366 
      else:
21367 
        iprot.skip(ftype)
21368 
      iprot.readFieldEnd()
21369 
    iprot.readStructEnd()
21370 
 
21371 
  def write(self, oprot):
21372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21374 
      return
21375 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21376 
    if self.vendorId is not None:
21377 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21378 
      oprot.writeI64(self.vendorId)
21379 
      oprot.writeFieldEnd()
21380 
    if self.itemId is not None:
21381 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21382 
      oprot.writeI64(self.itemId)
21383 
      oprot.writeFieldEnd()
21384 
    if self.quantity is not None:
21385 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21386 
      oprot.writeI64(self.quantity)
21387 
      oprot.writeFieldEnd()
21388 
    if self.estimate is not None:
21389 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21390 
      oprot.writeI64(self.estimate)
21391 
      oprot.writeFieldEnd()
4369 rajveer 21392 
    if self.isReminder is not None:
21393 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21394 
      oprot.writeBool(self.isReminder)
21395 
      oprot.writeFieldEnd()
4303 rajveer 21396 
    oprot.writeFieldStop()
21397 
    oprot.writeStructEnd()
21398 
 
21399 
  def validate(self):
21400 
    return
21401 
 
21402 
 
21403 
  def __repr__(self):
21404 
    L = ['%s=%r' % (key, value)
21405 
      for key, value in self.__dict__.iteritems()]
21406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21407 
 
21408 
  def __eq__(self, other):
21409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21410 
 
21411 
  def __ne__(self, other):
21412 
    return not (self == other)
21413 
 
21414 
class markOrdersAsNotAvailabke_result:
21415 
  """
21416 
  Attributes:
21417 
   - ex
21418 
  """
21419 
 
21420 
  thrift_spec = (
21421 
    None, # 0
21422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21423 
  )
21424 
 
21425 
  def __init__(self, ex=None,):
21426 
    self.ex = ex
21427 
 
21428 
  def read(self, iprot):
21429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21431 
      return
21432 
    iprot.readStructBegin()
21433 
    while True:
21434 
      (fname, ftype, fid) = iprot.readFieldBegin()
21435 
      if ftype == TType.STOP:
21436 
        break
21437 
      if fid == 1:
21438 
        if ftype == TType.STRUCT:
21439 
          self.ex = TransactionServiceException()
21440 
          self.ex.read(iprot)
21441 
        else:
21442 
          iprot.skip(ftype)
21443 
      else:
21444 
        iprot.skip(ftype)
21445 
      iprot.readFieldEnd()
21446 
    iprot.readStructEnd()
21447 
 
21448 
  def write(self, oprot):
21449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21451 
      return
21452 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21453 
    if self.ex is not None:
21454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21455 
      self.ex.write(oprot)
21456 
      oprot.writeFieldEnd()
21457 
    oprot.writeFieldStop()
21458 
    oprot.writeStructEnd()
21459 
 
21460 
  def validate(self):
21461 
    return
21462 
 
21463 
 
21464 
  def __repr__(self):
21465 
    L = ['%s=%r' % (key, value)
21466 
      for key, value in self.__dict__.iteritems()]
21467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21468 
 
21469 
  def __eq__(self, other):
21470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21471 
 
21472 
  def __ne__(self, other):
21473 
    return not (self == other)
4369 rajveer 21474 
 
21475 
class markOrdersAsTimeout_args:
21476 
  """
21477 
  Attributes:
21478 
   - vendorId
21479 
  """
21480 
 
21481 
  thrift_spec = (
21482 
    None, # 0
21483 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21484 
  )
21485 
 
21486 
  def __init__(self, vendorId=None,):
21487 
    self.vendorId = vendorId
21488 
 
21489 
  def read(self, iprot):
21490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21492 
      return
21493 
    iprot.readStructBegin()
21494 
    while True:
21495 
      (fname, ftype, fid) = iprot.readFieldBegin()
21496 
      if ftype == TType.STOP:
21497 
        break
21498 
      if fid == 1:
21499 
        if ftype == TType.I64:
21500 
          self.vendorId = iprot.readI64();
21501 
        else:
21502 
          iprot.skip(ftype)
21503 
      else:
21504 
        iprot.skip(ftype)
21505 
      iprot.readFieldEnd()
21506 
    iprot.readStructEnd()
21507 
 
21508 
  def write(self, oprot):
21509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21511 
      return
21512 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21513 
    if self.vendorId is not None:
21514 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21515 
      oprot.writeI64(self.vendorId)
21516 
      oprot.writeFieldEnd()
21517 
    oprot.writeFieldStop()
21518 
    oprot.writeStructEnd()
21519 
 
21520 
  def validate(self):
21521 
    return
21522 
 
21523 
 
21524 
  def __repr__(self):
21525 
    L = ['%s=%r' % (key, value)
21526 
      for key, value in self.__dict__.iteritems()]
21527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21528 
 
21529 
  def __eq__(self, other):
21530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21531 
 
21532 
  def __ne__(self, other):
21533 
    return not (self == other)
21534 
 
21535 
class markOrdersAsTimeout_result:
21536 
  """
21537 
  Attributes:
21538 
   - success
21539 
   - ex
21540 
  """
21541 
 
21542 
  thrift_spec = (
21543 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21545 
  )
21546 
 
21547 
  def __init__(self, success=None, ex=None,):
21548 
    self.success = success
21549 
    self.ex = ex
21550 
 
21551 
  def read(self, iprot):
21552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21554 
      return
21555 
    iprot.readStructBegin()
21556 
    while True:
21557 
      (fname, ftype, fid) = iprot.readFieldBegin()
21558 
      if ftype == TType.STOP:
21559 
        break
21560 
      if fid == 0:
21561 
        if ftype == TType.MAP:
21562 
          self.success = {}
6188 rajveer 21563 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21564 
          for _i505 in xrange(_size501):
21565 
            _key506 = iprot.readI32();
21566 
            _val507 = TimeoutSummary()
21567 
            _val507.read(iprot)
21568 
            self.success[_key506] = _val507
4369 rajveer 21569 
          iprot.readMapEnd()
21570 
        else:
21571 
          iprot.skip(ftype)
21572 
      elif fid == 1:
21573 
        if ftype == TType.STRUCT:
21574 
          self.ex = TransactionServiceException()
21575 
          self.ex.read(iprot)
21576 
        else:
21577 
          iprot.skip(ftype)
21578 
      else:
21579 
        iprot.skip(ftype)
21580 
      iprot.readFieldEnd()
21581 
    iprot.readStructEnd()
21582 
 
21583 
  def write(self, oprot):
21584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21586 
      return
21587 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21588 
    if self.success is not None:
21589 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21590 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21591 
      for kiter508,viter509 in self.success.items():
21592 
        oprot.writeI32(kiter508)
21593 
        viter509.write(oprot)
4369 rajveer 21594 
      oprot.writeMapEnd()
21595 
      oprot.writeFieldEnd()
21596 
    if self.ex is not None:
21597 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21598 
      self.ex.write(oprot)
21599 
      oprot.writeFieldEnd()
21600 
    oprot.writeFieldStop()
21601 
    oprot.writeStructEnd()
21602 
 
21603 
  def validate(self):
21604 
    return
21605 
 
21606 
 
21607 
  def __repr__(self):
21608 
    L = ['%s=%r' % (key, value)
21609 
      for key, value in self.__dict__.iteritems()]
21610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21611 
 
21612 
  def __eq__(self, other):
21613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21614 
 
21615 
  def __ne__(self, other):
21616 
    return not (self == other)
4386 anupam.sin 21617 
 
4662 rajveer 21618 
class markOrderAsLostInTransit_args:
21619 
  """
21620 
  Attributes:
21621 
   - orderId
21622 
  """
21623 
 
21624 
  thrift_spec = (
21625 
    None, # 0
21626 
    (1, TType.I64, 'orderId', None, None, ), # 1
21627 
  )
21628 
 
21629 
  def __init__(self, orderId=None,):
21630 
    self.orderId = orderId
21631 
 
21632 
  def read(self, iprot):
21633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21635 
      return
21636 
    iprot.readStructBegin()
21637 
    while True:
21638 
      (fname, ftype, fid) = iprot.readFieldBegin()
21639 
      if ftype == TType.STOP:
21640 
        break
21641 
      if fid == 1:
21642 
        if ftype == TType.I64:
21643 
          self.orderId = iprot.readI64();
21644 
        else:
21645 
          iprot.skip(ftype)
21646 
      else:
21647 
        iprot.skip(ftype)
21648 
      iprot.readFieldEnd()
21649 
    iprot.readStructEnd()
21650 
 
21651 
  def write(self, oprot):
21652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21654 
      return
21655 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21656 
    if self.orderId is not None:
21657 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21658 
      oprot.writeI64(self.orderId)
21659 
      oprot.writeFieldEnd()
21660 
    oprot.writeFieldStop()
21661 
    oprot.writeStructEnd()
21662 
 
21663 
  def validate(self):
21664 
    return
21665 
 
21666 
 
21667 
  def __repr__(self):
21668 
    L = ['%s=%r' % (key, value)
21669 
      for key, value in self.__dict__.iteritems()]
21670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21671 
 
21672 
  def __eq__(self, other):
21673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21674 
 
21675 
  def __ne__(self, other):
21676 
    return not (self == other)
21677 
 
21678 
class markOrderAsLostInTransit_result:
21679 
  """
21680 
  Attributes:
21681 
   - success
21682 
   - ex
21683 
  """
21684 
 
21685 
  thrift_spec = (
21686 
    (0, TType.BOOL, 'success', None, None, ), # 0
21687 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21688 
  )
21689 
 
21690 
  def __init__(self, success=None, ex=None,):
21691 
    self.success = success
21692 
    self.ex = ex
21693 
 
21694 
  def read(self, iprot):
21695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21697 
      return
21698 
    iprot.readStructBegin()
21699 
    while True:
21700 
      (fname, ftype, fid) = iprot.readFieldBegin()
21701 
      if ftype == TType.STOP:
21702 
        break
21703 
      if fid == 0:
21704 
        if ftype == TType.BOOL:
21705 
          self.success = iprot.readBool();
21706 
        else:
21707 
          iprot.skip(ftype)
21708 
      elif fid == 1:
21709 
        if ftype == TType.STRUCT:
21710 
          self.ex = TransactionServiceException()
21711 
          self.ex.read(iprot)
21712 
        else:
21713 
          iprot.skip(ftype)
21714 
      else:
21715 
        iprot.skip(ftype)
21716 
      iprot.readFieldEnd()
21717 
    iprot.readStructEnd()
21718 
 
21719 
  def write(self, oprot):
21720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21722 
      return
21723 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21724 
    if self.success is not None:
21725 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21726 
      oprot.writeBool(self.success)
21727 
      oprot.writeFieldEnd()
21728 
    if self.ex is not None:
21729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21730 
      self.ex.write(oprot)
21731 
      oprot.writeFieldEnd()
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
21749 
 
4386 anupam.sin 21750 
class getOrderForAwb_args:
21751 
  """
21752 
  Attributes:
21753 
   - awb
21754 
  """
21755 
 
21756 
  thrift_spec = (
21757 
    None, # 0
21758 
    (1, TType.STRING, 'awb', None, None, ), # 1
21759 
  )
21760 
 
21761 
  def __init__(self, awb=None,):
21762 
    self.awb = awb
21763 
 
21764 
  def read(self, iprot):
21765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21767 
      return
21768 
    iprot.readStructBegin()
21769 
    while True:
21770 
      (fname, ftype, fid) = iprot.readFieldBegin()
21771 
      if ftype == TType.STOP:
21772 
        break
21773 
      if fid == 1:
21774 
        if ftype == TType.STRING:
21775 
          self.awb = iprot.readString();
21776 
        else:
21777 
          iprot.skip(ftype)
21778 
      else:
21779 
        iprot.skip(ftype)
21780 
      iprot.readFieldEnd()
21781 
    iprot.readStructEnd()
21782 
 
21783 
  def write(self, oprot):
21784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21786 
      return
21787 
    oprot.writeStructBegin('getOrderForAwb_args')
21788 
    if self.awb is not None:
21789 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21790 
      oprot.writeString(self.awb)
21791 
      oprot.writeFieldEnd()
21792 
    oprot.writeFieldStop()
21793 
    oprot.writeStructEnd()
21794 
 
21795 
  def validate(self):
21796 
    return
21797 
 
21798 
 
21799 
  def __repr__(self):
21800 
    L = ['%s=%r' % (key, value)
21801 
      for key, value in self.__dict__.iteritems()]
21802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21803 
 
21804 
  def __eq__(self, other):
21805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21806 
 
21807 
  def __ne__(self, other):
21808 
    return not (self == other)
21809 
 
21810 
class getOrderForAwb_result:
21811 
  """
21812 
  Attributes:
21813 
   - success
21814 
   - ex
21815 
  """
21816 
 
21817 
  thrift_spec = (
21818 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21820 
  )
21821 
 
21822 
  def __init__(self, success=None, ex=None,):
21823 
    self.success = success
21824 
    self.ex = ex
21825 
 
21826 
  def read(self, iprot):
21827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21829 
      return
21830 
    iprot.readStructBegin()
21831 
    while True:
21832 
      (fname, ftype, fid) = iprot.readFieldBegin()
21833 
      if ftype == TType.STOP:
21834 
        break
21835 
      if fid == 0:
21836 
        if ftype == TType.STRUCT:
21837 
          self.success = Order()
21838 
          self.success.read(iprot)
21839 
        else:
21840 
          iprot.skip(ftype)
21841 
      elif fid == 1:
21842 
        if ftype == TType.STRUCT:
21843 
          self.ex = TransactionServiceException()
21844 
          self.ex.read(iprot)
21845 
        else:
21846 
          iprot.skip(ftype)
21847 
      else:
21848 
        iprot.skip(ftype)
21849 
      iprot.readFieldEnd()
21850 
    iprot.readStructEnd()
21851 
 
21852 
  def write(self, oprot):
21853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21855 
      return
21856 
    oprot.writeStructBegin('getOrderForAwb_result')
21857 
    if self.success is not None:
21858 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21859 
      self.success.write(oprot)
21860 
      oprot.writeFieldEnd()
21861 
    if self.ex is not None:
21862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21863 
      self.ex.write(oprot)
21864 
      oprot.writeFieldEnd()
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
4506 phani.kuma 21882 
 
21883 
class getOrdersForProviderForStatus_args:
21884 
  """
21885 
  Attributes:
21886 
   - logistics_provider_id
4910 phani.kuma 21887 
   - order_status_list
4506 phani.kuma 21888 
  """
21889 
 
21890 
  thrift_spec = (
21891 
    None, # 0
21892 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21893 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21894 
  )
21895 
 
4910 phani.kuma 21896 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21897 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21898 
    self.order_status_list = order_status_list
4506 phani.kuma 21899 
 
21900 
  def read(self, iprot):
21901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21903 
      return
21904 
    iprot.readStructBegin()
21905 
    while True:
21906 
      (fname, ftype, fid) = iprot.readFieldBegin()
21907 
      if ftype == TType.STOP:
21908 
        break
21909 
      if fid == 1:
21910 
        if ftype == TType.I64:
21911 
          self.logistics_provider_id = iprot.readI64();
21912 
        else:
21913 
          iprot.skip(ftype)
21914 
      elif fid == 2:
4910 phani.kuma 21915 
        if ftype == TType.LIST:
21916 
          self.order_status_list = []
6188 rajveer 21917 
          (_etype513, _size510) = iprot.readListBegin()
21918 
          for _i514 in xrange(_size510):
21919 
            _elem515 = iprot.readI32();
21920 
            self.order_status_list.append(_elem515)
4910 phani.kuma 21921 
          iprot.readListEnd()
4506 phani.kuma 21922 
        else:
21923 
          iprot.skip(ftype)
21924 
      else:
21925 
        iprot.skip(ftype)
21926 
      iprot.readFieldEnd()
21927 
    iprot.readStructEnd()
21928 
 
21929 
  def write(self, oprot):
21930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21932 
      return
21933 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21934 
    if self.logistics_provider_id is not None:
21935 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21936 
      oprot.writeI64(self.logistics_provider_id)
21937 
      oprot.writeFieldEnd()
4910 phani.kuma 21938 
    if self.order_status_list is not None:
21939 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21940 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 21941 
      for iter516 in self.order_status_list:
21942 
        oprot.writeI32(iter516)
4910 phani.kuma 21943 
      oprot.writeListEnd()
4506 phani.kuma 21944 
      oprot.writeFieldEnd()
21945 
    oprot.writeFieldStop()
21946 
    oprot.writeStructEnd()
21947 
 
21948 
  def validate(self):
21949 
    return
21950 
 
21951 
 
21952 
  def __repr__(self):
21953 
    L = ['%s=%r' % (key, value)
21954 
      for key, value in self.__dict__.iteritems()]
21955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21956 
 
21957 
  def __eq__(self, other):
21958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21959 
 
21960 
  def __ne__(self, other):
21961 
    return not (self == other)
21962 
 
21963 
class getOrdersForProviderForStatus_result:
21964 
  """
21965 
  Attributes:
21966 
   - success
21967 
   - ex
21968 
  """
21969 
 
21970 
  thrift_spec = (
21971 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21972 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21973 
  )
21974 
 
21975 
  def __init__(self, success=None, ex=None,):
21976 
    self.success = success
21977 
    self.ex = ex
21978 
 
21979 
  def read(self, iprot):
21980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21982 
      return
21983 
    iprot.readStructBegin()
21984 
    while True:
21985 
      (fname, ftype, fid) = iprot.readFieldBegin()
21986 
      if ftype == TType.STOP:
21987 
        break
21988 
      if fid == 0:
21989 
        if ftype == TType.LIST:
21990 
          self.success = []
6188 rajveer 21991 
          (_etype520, _size517) = iprot.readListBegin()
21992 
          for _i521 in xrange(_size517):
21993 
            _elem522 = Order()
21994 
            _elem522.read(iprot)
21995 
            self.success.append(_elem522)
4506 phani.kuma 21996 
          iprot.readListEnd()
21997 
        else:
21998 
          iprot.skip(ftype)
21999 
      elif fid == 1:
22000 
        if ftype == TType.STRUCT:
22001 
          self.ex = TransactionServiceException()
22002 
          self.ex.read(iprot)
22003 
        else:
22004 
          iprot.skip(ftype)
22005 
      else:
22006 
        iprot.skip(ftype)
22007 
      iprot.readFieldEnd()
22008 
    iprot.readStructEnd()
22009 
 
22010 
  def write(self, oprot):
22011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22013 
      return
22014 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22015 
    if self.success is not None:
22016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22018 
      for iter523 in self.success:
22019 
        iter523.write(oprot)
4506 phani.kuma 22020 
      oprot.writeListEnd()
22021 
      oprot.writeFieldEnd()
22022 
    if self.ex is not None:
22023 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22024 
      self.ex.write(oprot)
22025 
      oprot.writeFieldEnd()
22026 
    oprot.writeFieldStop()
22027 
    oprot.writeStructEnd()
22028 
 
22029 
  def validate(self):
22030 
    return
22031 
 
22032 
 
22033 
  def __repr__(self):
22034 
    L = ['%s=%r' % (key, value)
22035 
      for key, value in self.__dict__.iteritems()]
22036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22037 
 
22038 
  def __eq__(self, other):
22039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22040 
 
22041 
  def __ne__(self, other):
22042 
    return not (self == other)
4600 varun.gupt 22043 
 
22044 
class getBilledOrdersForVendor_args:
22045 
  """
22046 
  Attributes:
22047 
   - vendorId
22048 
   - billingDateFrom
22049 
   - billingDateTo
22050 
  """
22051 
 
22052 
  thrift_spec = (
22053 
    None, # 0
22054 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22055 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22056 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22057 
  )
22058 
 
22059 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22060 
    self.vendorId = vendorId
22061 
    self.billingDateFrom = billingDateFrom
22062 
    self.billingDateTo = billingDateTo
22063 
 
22064 
  def read(self, iprot):
22065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22067 
      return
22068 
    iprot.readStructBegin()
22069 
    while True:
22070 
      (fname, ftype, fid) = iprot.readFieldBegin()
22071 
      if ftype == TType.STOP:
22072 
        break
22073 
      if fid == 1:
22074 
        if ftype == TType.I64:
22075 
          self.vendorId = iprot.readI64();
22076 
        else:
22077 
          iprot.skip(ftype)
22078 
      elif fid == 2:
22079 
        if ftype == TType.I64:
22080 
          self.billingDateFrom = iprot.readI64();
22081 
        else:
22082 
          iprot.skip(ftype)
22083 
      elif fid == 3:
22084 
        if ftype == TType.I64:
22085 
          self.billingDateTo = iprot.readI64();
22086 
        else:
22087 
          iprot.skip(ftype)
22088 
      else:
22089 
        iprot.skip(ftype)
22090 
      iprot.readFieldEnd()
22091 
    iprot.readStructEnd()
22092 
 
22093 
  def write(self, oprot):
22094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22096 
      return
22097 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22098 
    if self.vendorId is not None:
22099 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22100 
      oprot.writeI64(self.vendorId)
22101 
      oprot.writeFieldEnd()
22102 
    if self.billingDateFrom is not None:
22103 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22104 
      oprot.writeI64(self.billingDateFrom)
22105 
      oprot.writeFieldEnd()
22106 
    if self.billingDateTo is not None:
22107 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22108 
      oprot.writeI64(self.billingDateTo)
22109 
      oprot.writeFieldEnd()
22110 
    oprot.writeFieldStop()
22111 
    oprot.writeStructEnd()
22112 
 
22113 
  def validate(self):
22114 
    return
22115 
 
22116 
 
22117 
  def __repr__(self):
22118 
    L = ['%s=%r' % (key, value)
22119 
      for key, value in self.__dict__.iteritems()]
22120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22121 
 
22122 
  def __eq__(self, other):
22123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22124 
 
22125 
  def __ne__(self, other):
22126 
    return not (self == other)
22127 
 
22128 
class getBilledOrdersForVendor_result:
22129 
  """
22130 
  Attributes:
22131 
   - success
22132 
   - ex
22133 
  """
22134 
 
22135 
  thrift_spec = (
22136 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22138 
  )
22139 
 
22140 
  def __init__(self, success=None, ex=None,):
22141 
    self.success = success
22142 
    self.ex = ex
22143 
 
22144 
  def read(self, iprot):
22145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22147 
      return
22148 
    iprot.readStructBegin()
22149 
    while True:
22150 
      (fname, ftype, fid) = iprot.readFieldBegin()
22151 
      if ftype == TType.STOP:
22152 
        break
22153 
      if fid == 0:
22154 
        if ftype == TType.LIST:
22155 
          self.success = []
6188 rajveer 22156 
          (_etype527, _size524) = iprot.readListBegin()
22157 
          for _i528 in xrange(_size524):
22158 
            _elem529 = Order()
22159 
            _elem529.read(iprot)
22160 
            self.success.append(_elem529)
4600 varun.gupt 22161 
          iprot.readListEnd()
22162 
        else:
22163 
          iprot.skip(ftype)
22164 
      elif fid == 1:
22165 
        if ftype == TType.STRUCT:
22166 
          self.ex = TransactionServiceException()
22167 
          self.ex.read(iprot)
22168 
        else:
22169 
          iprot.skip(ftype)
22170 
      else:
22171 
        iprot.skip(ftype)
22172 
      iprot.readFieldEnd()
22173 
    iprot.readStructEnd()
22174 
 
22175 
  def write(self, oprot):
22176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22178 
      return
22179 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22180 
    if self.success is not None:
22181 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22182 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22183 
      for iter530 in self.success:
22184 
        iter530.write(oprot)
4600 varun.gupt 22185 
      oprot.writeListEnd()
22186 
      oprot.writeFieldEnd()
22187 
    if self.ex is not None:
22188 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22189 
      self.ex.write(oprot)
22190 
      oprot.writeFieldEnd()
22191 
    oprot.writeFieldStop()
22192 
    oprot.writeStructEnd()
22193 
 
22194 
  def validate(self):
22195 
    return
22196 
 
22197 
 
22198 
  def __repr__(self):
22199 
    L = ['%s=%r' % (key, value)
22200 
      for key, value in self.__dict__.iteritems()]
22201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22202 
 
22203 
  def __eq__(self, other):
22204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22205 
 
22206 
  def __ne__(self, other):
22207 
    return not (self == other)
22208 
 
4607 rajveer 22209 
class getSlippedSippingDateOrders_args:
22210 
 
22211 
  thrift_spec = (
22212 
  )
22213 
 
22214 
  def read(self, iprot):
22215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22217 
      return
22218 
    iprot.readStructBegin()
22219 
    while True:
22220 
      (fname, ftype, fid) = iprot.readFieldBegin()
22221 
      if ftype == TType.STOP:
22222 
        break
22223 
      else:
22224 
        iprot.skip(ftype)
22225 
      iprot.readFieldEnd()
22226 
    iprot.readStructEnd()
22227 
 
22228 
  def write(self, oprot):
22229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22231 
      return
22232 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22233 
    oprot.writeFieldStop()
22234 
    oprot.writeStructEnd()
22235 
 
22236 
  def validate(self):
22237 
    return
22238 
 
22239 
 
22240 
  def __repr__(self):
22241 
    L = ['%s=%r' % (key, value)
22242 
      for key, value in self.__dict__.iteritems()]
22243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22244 
 
22245 
  def __eq__(self, other):
22246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22247 
 
22248 
  def __ne__(self, other):
22249 
    return not (self == other)
22250 
 
22251 
class getSlippedSippingDateOrders_result:
22252 
  """
22253 
  Attributes:
22254 
   - success
22255 
   - ex
22256 
  """
22257 
 
22258 
  thrift_spec = (
22259 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22260 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22261 
  )
22262 
 
22263 
  def __init__(self, success=None, ex=None,):
22264 
    self.success = success
22265 
    self.ex = ex
22266 
 
22267 
  def read(self, iprot):
22268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22270 
      return
22271 
    iprot.readStructBegin()
22272 
    while True:
22273 
      (fname, ftype, fid) = iprot.readFieldBegin()
22274 
      if ftype == TType.STOP:
22275 
        break
22276 
      if fid == 0:
22277 
        if ftype == TType.LIST:
22278 
          self.success = []
6188 rajveer 22279 
          (_etype534, _size531) = iprot.readListBegin()
22280 
          for _i535 in xrange(_size531):
22281 
            _elem536 = Order()
22282 
            _elem536.read(iprot)
22283 
            self.success.append(_elem536)
4607 rajveer 22284 
          iprot.readListEnd()
22285 
        else:
22286 
          iprot.skip(ftype)
22287 
      elif fid == 1:
22288 
        if ftype == TType.STRUCT:
22289 
          self.ex = TransactionServiceException()
22290 
          self.ex.read(iprot)
22291 
        else:
22292 
          iprot.skip(ftype)
22293 
      else:
22294 
        iprot.skip(ftype)
22295 
      iprot.readFieldEnd()
22296 
    iprot.readStructEnd()
22297 
 
22298 
  def write(self, oprot):
22299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22301 
      return
22302 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22303 
    if self.success is not None:
22304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22306 
      for iter537 in self.success:
22307 
        iter537.write(oprot)
4607 rajveer 22308 
      oprot.writeListEnd()
22309 
      oprot.writeFieldEnd()
22310 
    if self.ex is not None:
22311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22312 
      self.ex.write(oprot)
22313 
      oprot.writeFieldEnd()
22314 
    oprot.writeFieldStop()
22315 
    oprot.writeStructEnd()
22316 
 
22317 
  def validate(self):
22318 
    return
22319 
 
22320 
 
22321 
  def __repr__(self):
22322 
    L = ['%s=%r' % (key, value)
22323 
      for key, value in self.__dict__.iteritems()]
22324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22325 
 
22326 
  def __eq__(self, other):
22327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22328 
 
22329 
  def __ne__(self, other):
22330 
    return not (self == other)
22331 
 
4709 rajveer 22332 
class getCancelledOrders_args:
22333 
  """
22334 
  Attributes:
22335 
   - cancelDateFrom
22336 
   - cancelDateTo
22337 
  """
22338 
 
22339 
  thrift_spec = (
22340 
    None, # 0
22341 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22342 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22343 
  )
22344 
 
22345 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22346 
    self.cancelDateFrom = cancelDateFrom
22347 
    self.cancelDateTo = cancelDateTo
22348 
 
22349 
  def read(self, iprot):
22350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22352 
      return
22353 
    iprot.readStructBegin()
22354 
    while True:
22355 
      (fname, ftype, fid) = iprot.readFieldBegin()
22356 
      if ftype == TType.STOP:
22357 
        break
22358 
      if fid == 1:
22359 
        if ftype == TType.I64:
22360 
          self.cancelDateFrom = iprot.readI64();
22361 
        else:
22362 
          iprot.skip(ftype)
22363 
      elif fid == 2:
22364 
        if ftype == TType.I64:
22365 
          self.cancelDateTo = iprot.readI64();
22366 
        else:
22367 
          iprot.skip(ftype)
22368 
      else:
22369 
        iprot.skip(ftype)
22370 
      iprot.readFieldEnd()
22371 
    iprot.readStructEnd()
22372 
 
22373 
  def write(self, oprot):
22374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22376 
      return
22377 
    oprot.writeStructBegin('getCancelledOrders_args')
22378 
    if self.cancelDateFrom is not None:
22379 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22380 
      oprot.writeI64(self.cancelDateFrom)
22381 
      oprot.writeFieldEnd()
22382 
    if self.cancelDateTo is not None:
22383 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22384 
      oprot.writeI64(self.cancelDateTo)
22385 
      oprot.writeFieldEnd()
22386 
    oprot.writeFieldStop()
22387 
    oprot.writeStructEnd()
22388 
 
22389 
  def validate(self):
22390 
    return
22391 
 
22392 
 
22393 
  def __repr__(self):
22394 
    L = ['%s=%r' % (key, value)
22395 
      for key, value in self.__dict__.iteritems()]
22396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22397 
 
22398 
  def __eq__(self, other):
22399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22400 
 
22401 
  def __ne__(self, other):
22402 
    return not (self == other)
22403 
 
22404 
class getCancelledOrders_result:
22405 
  """
22406 
  Attributes:
22407 
   - success
22408 
   - ex
22409 
  """
22410 
 
22411 
  thrift_spec = (
22412 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22414 
  )
22415 
 
22416 
  def __init__(self, success=None, ex=None,):
22417 
    self.success = success
22418 
    self.ex = ex
22419 
 
22420 
  def read(self, iprot):
22421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22423 
      return
22424 
    iprot.readStructBegin()
22425 
    while True:
22426 
      (fname, ftype, fid) = iprot.readFieldBegin()
22427 
      if ftype == TType.STOP:
22428 
        break
22429 
      if fid == 0:
22430 
        if ftype == TType.LIST:
22431 
          self.success = []
6188 rajveer 22432 
          (_etype541, _size538) = iprot.readListBegin()
22433 
          for _i542 in xrange(_size538):
22434 
            _elem543 = Order()
22435 
            _elem543.read(iprot)
22436 
            self.success.append(_elem543)
4709 rajveer 22437 
          iprot.readListEnd()
22438 
        else:
22439 
          iprot.skip(ftype)
22440 
      elif fid == 1:
22441 
        if ftype == TType.STRUCT:
22442 
          self.ex = TransactionServiceException()
22443 
          self.ex.read(iprot)
22444 
        else:
22445 
          iprot.skip(ftype)
22446 
      else:
22447 
        iprot.skip(ftype)
22448 
      iprot.readFieldEnd()
22449 
    iprot.readStructEnd()
22450 
 
22451 
  def write(self, oprot):
22452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22454 
      return
22455 
    oprot.writeStructBegin('getCancelledOrders_result')
22456 
    if self.success is not None:
22457 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22458 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22459 
      for iter544 in self.success:
22460 
        iter544.write(oprot)
4709 rajveer 22461 
      oprot.writeListEnd()
22462 
      oprot.writeFieldEnd()
22463 
    if self.ex is not None:
22464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22465 
      self.ex.write(oprot)
22466 
      oprot.writeFieldEnd()
22467 
    oprot.writeFieldStop()
22468 
    oprot.writeStructEnd()
22469 
 
22470 
  def validate(self):
22471 
    return
22472 
 
22473 
 
22474 
  def __repr__(self):
22475 
    L = ['%s=%r' % (key, value)
22476 
      for key, value in self.__dict__.iteritems()]
22477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22478 
 
22479 
  def __eq__(self, other):
22480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22481 
 
22482 
  def __ne__(self, other):
22483 
    return not (self == other)
22484 
 
4600 varun.gupt 22485 
class saveBluedartSettlements_args:
22486 
  """
22487 
  Attributes:
22488 
   - mapAWBAndAmount
22489 
  """
22490 
 
22491 
  thrift_spec = (
22492 
    None, # 0
22493 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22494 
  )
22495 
 
22496 
  def __init__(self, mapAWBAndAmount=None,):
22497 
    self.mapAWBAndAmount = mapAWBAndAmount
22498 
 
22499 
  def read(self, iprot):
22500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22502 
      return
22503 
    iprot.readStructBegin()
22504 
    while True:
22505 
      (fname, ftype, fid) = iprot.readFieldBegin()
22506 
      if ftype == TType.STOP:
22507 
        break
22508 
      if fid == 1:
22509 
        if ftype == TType.MAP:
22510 
          self.mapAWBAndAmount = {}
6188 rajveer 22511 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22512 
          for _i549 in xrange(_size545):
22513 
            _key550 = iprot.readI64();
22514 
            _val551 = iprot.readDouble();
22515 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22516 
          iprot.readMapEnd()
22517 
        else:
22518 
          iprot.skip(ftype)
22519 
      else:
22520 
        iprot.skip(ftype)
22521 
      iprot.readFieldEnd()
22522 
    iprot.readStructEnd()
22523 
 
22524 
  def write(self, oprot):
22525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22527 
      return
22528 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22529 
    if self.mapAWBAndAmount is not None:
22530 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22531 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22532 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22533 
        oprot.writeI64(kiter552)
22534 
        oprot.writeDouble(viter553)
4600 varun.gupt 22535 
      oprot.writeMapEnd()
22536 
      oprot.writeFieldEnd()
22537 
    oprot.writeFieldStop()
22538 
    oprot.writeStructEnd()
22539 
 
22540 
  def validate(self):
22541 
    return
22542 
 
22543 
 
22544 
  def __repr__(self):
22545 
    L = ['%s=%r' % (key, value)
22546 
      for key, value in self.__dict__.iteritems()]
22547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22548 
 
22549 
  def __eq__(self, other):
22550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22551 
 
22552 
  def __ne__(self, other):
22553 
    return not (self == other)
22554 
 
22555 
class saveBluedartSettlements_result:
22556 
  """
22557 
  Attributes:
22558 
   - ex
22559 
  """
22560 
 
22561 
  thrift_spec = (
22562 
    None, # 0
22563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22564 
  )
22565 
 
22566 
  def __init__(self, ex=None,):
22567 
    self.ex = ex
22568 
 
22569 
  def read(self, iprot):
22570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22572 
      return
22573 
    iprot.readStructBegin()
22574 
    while True:
22575 
      (fname, ftype, fid) = iprot.readFieldBegin()
22576 
      if ftype == TType.STOP:
22577 
        break
22578 
      if fid == 1:
22579 
        if ftype == TType.STRUCT:
22580 
          self.ex = TransactionServiceException()
22581 
          self.ex.read(iprot)
22582 
        else:
22583 
          iprot.skip(ftype)
22584 
      else:
22585 
        iprot.skip(ftype)
22586 
      iprot.readFieldEnd()
22587 
    iprot.readStructEnd()
22588 
 
22589 
  def write(self, oprot):
22590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22592 
      return
22593 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22594 
    if self.ex is not None:
22595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22596 
      self.ex.write(oprot)
22597 
      oprot.writeFieldEnd()
22598 
    oprot.writeFieldStop()
22599 
    oprot.writeStructEnd()
22600 
 
22601 
  def validate(self):
22602 
    return
22603 
 
22604 
 
22605 
  def __repr__(self):
22606 
    L = ['%s=%r' % (key, value)
22607 
      for key, value in self.__dict__.iteritems()]
22608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22609 
 
22610 
  def __eq__(self, other):
22611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22612 
 
22613 
  def __ne__(self, other):
22614 
    return not (self == other)
22615 
 
22616 
class savePaymentSettlements_args:
22617 
  """
22618 
  Attributes:
22619 
   - settlementDate
22620 
   - paymentGatewayId
4905 varun.gupt 22621 
   - referenceId
4600 varun.gupt 22622 
   - serviceTax
22623 
   - otherCharges
22624 
   - netCollection
22625 
  """
22626 
 
22627 
  thrift_spec = (
22628 
    None, # 0
22629 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22630 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22631 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22632 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22633 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22634 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22635 
  )
22636 
 
4905 varun.gupt 22637 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22638 
    self.settlementDate = settlementDate
22639 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22640 
    self.referenceId = referenceId
4600 varun.gupt 22641 
    self.serviceTax = serviceTax
22642 
    self.otherCharges = otherCharges
22643 
    self.netCollection = netCollection
22644 
 
22645 
  def read(self, iprot):
22646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22648 
      return
22649 
    iprot.readStructBegin()
22650 
    while True:
22651 
      (fname, ftype, fid) = iprot.readFieldBegin()
22652 
      if ftype == TType.STOP:
22653 
        break
22654 
      if fid == 1:
22655 
        if ftype == TType.I64:
22656 
          self.settlementDate = iprot.readI64();
22657 
        else:
22658 
          iprot.skip(ftype)
22659 
      elif fid == 2:
22660 
        if ftype == TType.I64:
22661 
          self.paymentGatewayId = iprot.readI64();
22662 
        else:
22663 
          iprot.skip(ftype)
22664 
      elif fid == 3:
22665 
        if ftype == TType.I64:
4905 varun.gupt 22666 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22667 
        else:
22668 
          iprot.skip(ftype)
22669 
      elif fid == 4:
22670 
        if ftype == TType.DOUBLE:
22671 
          self.serviceTax = iprot.readDouble();
22672 
        else:
22673 
          iprot.skip(ftype)
22674 
      elif fid == 5:
22675 
        if ftype == TType.DOUBLE:
22676 
          self.otherCharges = iprot.readDouble();
22677 
        else:
22678 
          iprot.skip(ftype)
22679 
      elif fid == 6:
22680 
        if ftype == TType.DOUBLE:
22681 
          self.netCollection = iprot.readDouble();
22682 
        else:
22683 
          iprot.skip(ftype)
22684 
      else:
22685 
        iprot.skip(ftype)
22686 
      iprot.readFieldEnd()
22687 
    iprot.readStructEnd()
22688 
 
22689 
  def write(self, oprot):
22690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22692 
      return
22693 
    oprot.writeStructBegin('savePaymentSettlements_args')
22694 
    if self.settlementDate is not None:
22695 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22696 
      oprot.writeI64(self.settlementDate)
22697 
      oprot.writeFieldEnd()
22698 
    if self.paymentGatewayId is not None:
22699 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22700 
      oprot.writeI64(self.paymentGatewayId)
22701 
      oprot.writeFieldEnd()
4905 varun.gupt 22702 
    if self.referenceId is not None:
22703 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22704 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22705 
      oprot.writeFieldEnd()
22706 
    if self.serviceTax is not None:
22707 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22708 
      oprot.writeDouble(self.serviceTax)
22709 
      oprot.writeFieldEnd()
22710 
    if self.otherCharges is not None:
22711 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22712 
      oprot.writeDouble(self.otherCharges)
22713 
      oprot.writeFieldEnd()
22714 
    if self.netCollection is not None:
22715 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22716 
      oprot.writeDouble(self.netCollection)
22717 
      oprot.writeFieldEnd()
22718 
    oprot.writeFieldStop()
22719 
    oprot.writeStructEnd()
22720 
 
22721 
  def validate(self):
22722 
    return
22723 
 
22724 
 
22725 
  def __repr__(self):
22726 
    L = ['%s=%r' % (key, value)
22727 
      for key, value in self.__dict__.iteritems()]
22728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22729 
 
22730 
  def __eq__(self, other):
22731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22732 
 
22733 
  def __ne__(self, other):
22734 
    return not (self == other)
22735 
 
22736 
class savePaymentSettlements_result:
22737 
  """
22738 
  Attributes:
22739 
   - ex
22740 
  """
22741 
 
22742 
  thrift_spec = (
22743 
    None, # 0
22744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22745 
  )
22746 
 
22747 
  def __init__(self, ex=None,):
22748 
    self.ex = ex
22749 
 
22750 
  def read(self, iprot):
22751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22753 
      return
22754 
    iprot.readStructBegin()
22755 
    while True:
22756 
      (fname, ftype, fid) = iprot.readFieldBegin()
22757 
      if ftype == TType.STOP:
22758 
        break
22759 
      if fid == 1:
22760 
        if ftype == TType.STRUCT:
22761 
          self.ex = TransactionServiceException()
22762 
          self.ex.read(iprot)
22763 
        else:
22764 
          iprot.skip(ftype)
22765 
      else:
22766 
        iprot.skip(ftype)
22767 
      iprot.readFieldEnd()
22768 
    iprot.readStructEnd()
22769 
 
22770 
  def write(self, oprot):
22771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22773 
      return
22774 
    oprot.writeStructBegin('savePaymentSettlements_result')
22775 
    if self.ex is not None:
22776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22777 
      self.ex.write(oprot)
22778 
      oprot.writeFieldEnd()
22779 
    oprot.writeFieldStop()
22780 
    oprot.writeStructEnd()
22781 
 
22782 
  def validate(self):
22783 
    return
22784 
 
22785 
 
22786 
  def __repr__(self):
22787 
    L = ['%s=%r' % (key, value)
22788 
      for key, value in self.__dict__.iteritems()]
22789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22790 
 
22791 
  def __eq__(self, other):
22792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22793 
 
22794 
  def __ne__(self, other):
22795 
    return not (self == other)
22796 
 
22797 
class saveEBSSettlementSummary_args:
22798 
  """
22799 
  Attributes:
22800 
   - settlementId
22801 
   - settlementDate
22802 
   - transactionDateFrom
22803 
   - transactionDateTo
22804 
   - amount
22805 
  """
22806 
 
22807 
  thrift_spec = (
22808 
    None, # 0
22809 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22810 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22811 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22812 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22813 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22814 
  )
22815 
 
22816 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22817 
    self.settlementId = settlementId
22818 
    self.settlementDate = settlementDate
22819 
    self.transactionDateFrom = transactionDateFrom
22820 
    self.transactionDateTo = transactionDateTo
22821 
    self.amount = amount
22822 
 
22823 
  def read(self, iprot):
22824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22826 
      return
22827 
    iprot.readStructBegin()
22828 
    while True:
22829 
      (fname, ftype, fid) = iprot.readFieldBegin()
22830 
      if ftype == TType.STOP:
22831 
        break
22832 
      if fid == 1:
22833 
        if ftype == TType.I64:
22834 
          self.settlementId = iprot.readI64();
22835 
        else:
22836 
          iprot.skip(ftype)
22837 
      elif fid == 2:
22838 
        if ftype == TType.I64:
22839 
          self.settlementDate = iprot.readI64();
22840 
        else:
22841 
          iprot.skip(ftype)
22842 
      elif fid == 3:
22843 
        if ftype == TType.I64:
22844 
          self.transactionDateFrom = iprot.readI64();
22845 
        else:
22846 
          iprot.skip(ftype)
22847 
      elif fid == 4:
22848 
        if ftype == TType.I64:
22849 
          self.transactionDateTo = iprot.readI64();
22850 
        else:
22851 
          iprot.skip(ftype)
22852 
      elif fid == 5:
22853 
        if ftype == TType.DOUBLE:
22854 
          self.amount = iprot.readDouble();
22855 
        else:
22856 
          iprot.skip(ftype)
22857 
      else:
22858 
        iprot.skip(ftype)
22859 
      iprot.readFieldEnd()
22860 
    iprot.readStructEnd()
22861 
 
22862 
  def write(self, oprot):
22863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22865 
      return
22866 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22867 
    if self.settlementId is not None:
22868 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22869 
      oprot.writeI64(self.settlementId)
22870 
      oprot.writeFieldEnd()
22871 
    if self.settlementDate is not None:
22872 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22873 
      oprot.writeI64(self.settlementDate)
22874 
      oprot.writeFieldEnd()
22875 
    if self.transactionDateFrom is not None:
22876 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22877 
      oprot.writeI64(self.transactionDateFrom)
22878 
      oprot.writeFieldEnd()
22879 
    if self.transactionDateTo is not None:
22880 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22881 
      oprot.writeI64(self.transactionDateTo)
22882 
      oprot.writeFieldEnd()
22883 
    if self.amount is not None:
22884 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22885 
      oprot.writeDouble(self.amount)
22886 
      oprot.writeFieldEnd()
22887 
    oprot.writeFieldStop()
22888 
    oprot.writeStructEnd()
22889 
 
22890 
  def validate(self):
22891 
    return
22892 
 
22893 
 
22894 
  def __repr__(self):
22895 
    L = ['%s=%r' % (key, value)
22896 
      for key, value in self.__dict__.iteritems()]
22897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22898 
 
22899 
  def __eq__(self, other):
22900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22901 
 
22902 
  def __ne__(self, other):
22903 
    return not (self == other)
22904 
 
22905 
class saveEBSSettlementSummary_result:
22906 
  """
22907 
  Attributes:
22908 
   - ex
22909 
  """
22910 
 
22911 
  thrift_spec = (
22912 
    None, # 0
22913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22914 
  )
22915 
 
22916 
  def __init__(self, ex=None,):
22917 
    self.ex = ex
22918 
 
22919 
  def read(self, iprot):
22920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22922 
      return
22923 
    iprot.readStructBegin()
22924 
    while True:
22925 
      (fname, ftype, fid) = iprot.readFieldBegin()
22926 
      if ftype == TType.STOP:
22927 
        break
22928 
      if fid == 1:
22929 
        if ftype == TType.STRUCT:
22930 
          self.ex = TransactionServiceException()
22931 
          self.ex.read(iprot)
22932 
        else:
22933 
          iprot.skip(ftype)
22934 
      else:
22935 
        iprot.skip(ftype)
22936 
      iprot.readFieldEnd()
22937 
    iprot.readStructEnd()
22938 
 
22939 
  def write(self, oprot):
22940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22942 
      return
22943 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22944 
    if self.ex is not None:
22945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22946 
      self.ex.write(oprot)
22947 
      oprot.writeFieldEnd()
22948 
    oprot.writeFieldStop()
22949 
    oprot.writeStructEnd()
22950 
 
22951 
  def validate(self):
22952 
    return
22953 
 
22954 
 
22955 
  def __repr__(self):
22956 
    L = ['%s=%r' % (key, value)
22957 
      for key, value in self.__dict__.iteritems()]
22958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22959 
 
22960 
  def __eq__(self, other):
22961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22962 
 
22963 
  def __ne__(self, other):
22964 
    return not (self == other)
22965 
 
5386 phani.kuma 22966 
class getSettlementForPrepaid_args:
4600 varun.gupt 22967 
  """
22968 
  Attributes:
5189 varun.gupt 22969 
   - referenceId
22970 
   - isRefund
4600 varun.gupt 22971 
  """
22972 
 
22973 
  thrift_spec = (
22974 
    None, # 0
5189 varun.gupt 22975 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22976 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22977 
  )
22978 
 
5386 phani.kuma 22979 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22980 
    self.referenceId = referenceId
22981 
    self.isRefund = isRefund
4600 varun.gupt 22982 
 
22983 
  def read(self, iprot):
22984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22986 
      return
22987 
    iprot.readStructBegin()
22988 
    while True:
22989 
      (fname, ftype, fid) = iprot.readFieldBegin()
22990 
      if ftype == TType.STOP:
22991 
        break
22992 
      if fid == 1:
22993 
        if ftype == TType.I64:
5189 varun.gupt 22994 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22995 
        else:
22996 
          iprot.skip(ftype)
5189 varun.gupt 22997 
      elif fid == 2:
22998 
        if ftype == TType.BOOL:
22999 
          self.isRefund = iprot.readBool();
23000 
        else:
23001 
          iprot.skip(ftype)
4600 varun.gupt 23002 
      else:
23003 
        iprot.skip(ftype)
23004 
      iprot.readFieldEnd()
23005 
    iprot.readStructEnd()
23006 
 
23007 
  def write(self, oprot):
23008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23010 
      return
5386 phani.kuma 23011 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23012 
    if self.referenceId is not None:
23013 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23014 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23015 
      oprot.writeFieldEnd()
5386 phani.kuma 23016 
    if self.isRefund is not None:
23017 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23018 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23019 
      oprot.writeFieldEnd()
5386 phani.kuma 23020 
    oprot.writeFieldStop()
23021 
    oprot.writeStructEnd()
23022 
 
23023 
  def validate(self):
23024 
    return
23025 
 
23026 
 
23027 
  def __repr__(self):
23028 
    L = ['%s=%r' % (key, value)
23029 
      for key, value in self.__dict__.iteritems()]
23030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23031 
 
23032 
  def __eq__(self, other):
23033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23034 
 
23035 
  def __ne__(self, other):
23036 
    return not (self == other)
23037 
 
23038 
class getSettlementForPrepaid_result:
23039 
  """
23040 
  Attributes:
23041 
   - success
23042 
   - ex
23043 
  """
23044 
 
23045 
  thrift_spec = (
23046 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23048 
  )
23049 
 
23050 
  def __init__(self, success=None, ex=None,):
23051 
    self.success = success
23052 
    self.ex = ex
23053 
 
23054 
  def read(self, iprot):
23055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23057 
      return
23058 
    iprot.readStructBegin()
23059 
    while True:
23060 
      (fname, ftype, fid) = iprot.readFieldBegin()
23061 
      if ftype == TType.STOP:
23062 
        break
23063 
      if fid == 0:
23064 
        if ftype == TType.STRUCT:
23065 
          self.success = PaymentSettlement()
23066 
          self.success.read(iprot)
23067 
        else:
23068 
          iprot.skip(ftype)
23069 
      elif fid == 1:
23070 
        if ftype == TType.STRUCT:
23071 
          self.ex = TransactionServiceException()
23072 
          self.ex.read(iprot)
23073 
        else:
23074 
          iprot.skip(ftype)
23075 
      else:
23076 
        iprot.skip(ftype)
23077 
      iprot.readFieldEnd()
23078 
    iprot.readStructEnd()
23079 
 
23080 
  def write(self, oprot):
23081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23083 
      return
23084 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23085 
    if self.success is not None:
23086 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23087 
      self.success.write(oprot)
23088 
      oprot.writeFieldEnd()
23089 
    if self.ex is not None:
23090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23091 
      self.ex.write(oprot)
23092 
      oprot.writeFieldEnd()
23093 
    oprot.writeFieldStop()
23094 
    oprot.writeStructEnd()
23095 
 
23096 
  def validate(self):
23097 
    return
23098 
 
23099 
 
23100 
  def __repr__(self):
23101 
    L = ['%s=%r' % (key, value)
23102 
      for key, value in self.__dict__.iteritems()]
23103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23104 
 
23105 
  def __eq__(self, other):
23106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23107 
 
23108 
  def __ne__(self, other):
23109 
    return not (self == other)
23110 
 
23111 
class getSettlementForCod_args:
23112 
  """
23113 
  Attributes:
23114 
   - orderId
23115 
   - isRefund
23116 
  """
23117 
 
23118 
  thrift_spec = (
23119 
    None, # 0
23120 
    (1, TType.I64, 'orderId', None, None, ), # 1
23121 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23122 
  )
23123 
 
23124 
  def __init__(self, orderId=None, isRefund=None,):
23125 
    self.orderId = orderId
23126 
    self.isRefund = isRefund
23127 
 
23128 
  def read(self, iprot):
23129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23131 
      return
23132 
    iprot.readStructBegin()
23133 
    while True:
23134 
      (fname, ftype, fid) = iprot.readFieldBegin()
23135 
      if ftype == TType.STOP:
23136 
        break
23137 
      if fid == 1:
23138 
        if ftype == TType.I64:
23139 
          self.orderId = iprot.readI64();
23140 
        else:
23141 
          iprot.skip(ftype)
23142 
      elif fid == 2:
23143 
        if ftype == TType.BOOL:
23144 
          self.isRefund = iprot.readBool();
23145 
        else:
23146 
          iprot.skip(ftype)
23147 
      else:
23148 
        iprot.skip(ftype)
23149 
      iprot.readFieldEnd()
23150 
    iprot.readStructEnd()
23151 
 
23152 
  def write(self, oprot):
23153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23155 
      return
23156 
    oprot.writeStructBegin('getSettlementForCod_args')
23157 
    if self.orderId is not None:
23158 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23159 
      oprot.writeI64(self.orderId)
23160 
      oprot.writeFieldEnd()
5189 varun.gupt 23161 
    if self.isRefund is not None:
5386 phani.kuma 23162 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23163 
      oprot.writeBool(self.isRefund)
23164 
      oprot.writeFieldEnd()
4600 varun.gupt 23165 
    oprot.writeFieldStop()
23166 
    oprot.writeStructEnd()
23167 
 
23168 
  def validate(self):
23169 
    return
23170 
 
23171 
 
23172 
  def __repr__(self):
23173 
    L = ['%s=%r' % (key, value)
23174 
      for key, value in self.__dict__.iteritems()]
23175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23176 
 
23177 
  def __eq__(self, other):
23178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23179 
 
23180 
  def __ne__(self, other):
23181 
    return not (self == other)
23182 
 
5386 phani.kuma 23183 
class getSettlementForCod_result:
4600 varun.gupt 23184 
  """
23185 
  Attributes:
23186 
   - success
23187 
   - ex
23188 
  """
23189 
 
23190 
  thrift_spec = (
23191 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23193 
  )
23194 
 
23195 
  def __init__(self, success=None, ex=None,):
23196 
    self.success = success
23197 
    self.ex = ex
23198 
 
23199 
  def read(self, iprot):
23200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23202 
      return
23203 
    iprot.readStructBegin()
23204 
    while True:
23205 
      (fname, ftype, fid) = iprot.readFieldBegin()
23206 
      if ftype == TType.STOP:
23207 
        break
23208 
      if fid == 0:
23209 
        if ftype == TType.STRUCT:
23210 
          self.success = PaymentSettlement()
23211 
          self.success.read(iprot)
23212 
        else:
23213 
          iprot.skip(ftype)
23214 
      elif 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
5386 phani.kuma 23229 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23230 
    if self.success is not None:
23231 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23232 
      self.success.write(oprot)
23233 
      oprot.writeFieldEnd()
23234 
    if self.ex is not None:
23235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23236 
      self.ex.write(oprot)
23237 
      oprot.writeFieldEnd()
23238 
    oprot.writeFieldStop()
23239 
    oprot.writeStructEnd()
23240 
 
23241 
  def validate(self):
23242 
    return
23243 
 
23244 
 
23245 
  def __repr__(self):
23246 
    L = ['%s=%r' % (key, value)
23247 
      for key, value in self.__dict__.iteritems()]
23248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23249 
 
23250 
  def __eq__(self, other):
23251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23252 
 
23253 
  def __ne__(self, other):
23254 
    return not (self == other)
23255 
 
23256 
class getEBSSettlementSummaries_args:
23257 
 
23258 
  thrift_spec = (
23259 
  )
23260 
 
23261 
  def read(self, iprot):
23262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23264 
      return
23265 
    iprot.readStructBegin()
23266 
    while True:
23267 
      (fname, ftype, fid) = iprot.readFieldBegin()
23268 
      if ftype == TType.STOP:
23269 
        break
23270 
      else:
23271 
        iprot.skip(ftype)
23272 
      iprot.readFieldEnd()
23273 
    iprot.readStructEnd()
23274 
 
23275 
  def write(self, oprot):
23276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23278 
      return
23279 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23280 
    oprot.writeFieldStop()
23281 
    oprot.writeStructEnd()
23282 
 
23283 
  def validate(self):
23284 
    return
23285 
 
23286 
 
23287 
  def __repr__(self):
23288 
    L = ['%s=%r' % (key, value)
23289 
      for key, value in self.__dict__.iteritems()]
23290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23291 
 
23292 
  def __eq__(self, other):
23293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23294 
 
23295 
  def __ne__(self, other):
23296 
    return not (self == other)
23297 
 
23298 
class getEBSSettlementSummaries_result:
23299 
  """
23300 
  Attributes:
23301 
   - success
23302 
   - ex
23303 
  """
23304 
 
23305 
  thrift_spec = (
23306 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23308 
  )
23309 
 
23310 
  def __init__(self, success=None, ex=None,):
23311 
    self.success = success
23312 
    self.ex = ex
23313 
 
23314 
  def read(self, iprot):
23315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23317 
      return
23318 
    iprot.readStructBegin()
23319 
    while True:
23320 
      (fname, ftype, fid) = iprot.readFieldBegin()
23321 
      if ftype == TType.STOP:
23322 
        break
23323 
      if fid == 0:
23324 
        if ftype == TType.MAP:
23325 
          self.success = {}
6188 rajveer 23326 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23327 
          for _i558 in xrange(_size554):
23328 
            _key559 = iprot.readI64();
23329 
            _val560 = iprot.readString();
23330 
            self.success[_key559] = _val560
4600 varun.gupt 23331 
          iprot.readMapEnd()
23332 
        else:
23333 
          iprot.skip(ftype)
23334 
      elif fid == 1:
23335 
        if ftype == TType.STRUCT:
23336 
          self.ex = TransactionServiceException()
23337 
          self.ex.read(iprot)
23338 
        else:
23339 
          iprot.skip(ftype)
23340 
      else:
23341 
        iprot.skip(ftype)
23342 
      iprot.readFieldEnd()
23343 
    iprot.readStructEnd()
23344 
 
23345 
  def write(self, oprot):
23346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23348 
      return
23349 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23350 
    if self.success is not None:
23351 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23352 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23353 
      for kiter561,viter562 in self.success.items():
23354 
        oprot.writeI64(kiter561)
23355 
        oprot.writeString(viter562)
4600 varun.gupt 23356 
      oprot.writeMapEnd()
23357 
      oprot.writeFieldEnd()
23358 
    if self.ex is not None:
23359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23360 
      self.ex.write(oprot)
23361 
      oprot.writeFieldEnd()
23362 
    oprot.writeFieldStop()
23363 
    oprot.writeStructEnd()
23364 
 
23365 
  def validate(self):
23366 
    return
23367 
 
23368 
 
23369 
  def __repr__(self):
23370 
    L = ['%s=%r' % (key, value)
23371 
      for key, value in self.__dict__.iteritems()]
23372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23373 
 
23374 
  def __eq__(self, other):
23375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23376 
 
23377 
  def __ne__(self, other):
23378 
    return not (self == other)
23379 
 
23380 
class markEBSSettlementUploaded_args:
23381 
  """
23382 
  Attributes:
23383 
   - settlementId
23384 
  """
23385 
 
23386 
  thrift_spec = (
23387 
    None, # 0
23388 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23389 
  )
23390 
 
23391 
  def __init__(self, settlementId=None,):
23392 
    self.settlementId = settlementId
23393 
 
23394 
  def read(self, iprot):
23395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23397 
      return
23398 
    iprot.readStructBegin()
23399 
    while True:
23400 
      (fname, ftype, fid) = iprot.readFieldBegin()
23401 
      if ftype == TType.STOP:
23402 
        break
23403 
      if fid == 1:
23404 
        if ftype == TType.I64:
23405 
          self.settlementId = iprot.readI64();
23406 
        else:
23407 
          iprot.skip(ftype)
23408 
      else:
23409 
        iprot.skip(ftype)
23410 
      iprot.readFieldEnd()
23411 
    iprot.readStructEnd()
23412 
 
23413 
  def write(self, oprot):
23414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23416 
      return
23417 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23418 
    if self.settlementId is not None:
23419 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23420 
      oprot.writeI64(self.settlementId)
23421 
      oprot.writeFieldEnd()
23422 
    oprot.writeFieldStop()
23423 
    oprot.writeStructEnd()
23424 
 
23425 
  def validate(self):
23426 
    return
23427 
 
23428 
 
23429 
  def __repr__(self):
23430 
    L = ['%s=%r' % (key, value)
23431 
      for key, value in self.__dict__.iteritems()]
23432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23433 
 
23434 
  def __eq__(self, other):
23435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23436 
 
23437 
  def __ne__(self, other):
23438 
    return not (self == other)
23439 
 
23440 
class markEBSSettlementUploaded_result:
23441 
  """
23442 
  Attributes:
23443 
   - ex
23444 
  """
23445 
 
23446 
  thrift_spec = (
23447 
    None, # 0
23448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23449 
  )
23450 
 
23451 
  def __init__(self, ex=None,):
23452 
    self.ex = ex
23453 
 
23454 
  def read(self, iprot):
23455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23457 
      return
23458 
    iprot.readStructBegin()
23459 
    while True:
23460 
      (fname, ftype, fid) = iprot.readFieldBegin()
23461 
      if ftype == TType.STOP:
23462 
        break
23463 
      if fid == 1:
23464 
        if ftype == TType.STRUCT:
23465 
          self.ex = TransactionServiceException()
23466 
          self.ex.read(iprot)
23467 
        else:
23468 
          iprot.skip(ftype)
23469 
      else:
23470 
        iprot.skip(ftype)
23471 
      iprot.readFieldEnd()
23472 
    iprot.readStructEnd()
23473 
 
23474 
  def write(self, oprot):
23475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23477 
      return
23478 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23479 
    if self.ex is not None:
23480 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23481 
      self.ex.write(oprot)
23482 
      oprot.writeFieldEnd()
23483 
    oprot.writeFieldStop()
23484 
    oprot.writeStructEnd()
23485 
 
23486 
  def validate(self):
23487 
    return
23488 
 
23489 
 
23490 
  def __repr__(self):
23491 
    L = ['%s=%r' % (key, value)
23492 
      for key, value in self.__dict__.iteritems()]
23493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23494 
 
23495 
  def __eq__(self, other):
23496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23497 
 
23498 
  def __ne__(self, other):
23499 
    return not (self == other)
23500 
 
23501 
class getEBSSettlementDate_args:
23502 
  """
23503 
  Attributes:
23504 
   - settlementId
23505 
  """
23506 
 
23507 
  thrift_spec = (
23508 
    None, # 0
23509 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23510 
  )
23511 
 
23512 
  def __init__(self, settlementId=None,):
23513 
    self.settlementId = settlementId
23514 
 
23515 
  def read(self, iprot):
23516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23518 
      return
23519 
    iprot.readStructBegin()
23520 
    while True:
23521 
      (fname, ftype, fid) = iprot.readFieldBegin()
23522 
      if ftype == TType.STOP:
23523 
        break
23524 
      if fid == 1:
23525 
        if ftype == TType.I64:
23526 
          self.settlementId = iprot.readI64();
23527 
        else:
23528 
          iprot.skip(ftype)
23529 
      else:
23530 
        iprot.skip(ftype)
23531 
      iprot.readFieldEnd()
23532 
    iprot.readStructEnd()
23533 
 
23534 
  def write(self, oprot):
23535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23537 
      return
23538 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23539 
    if self.settlementId is not None:
23540 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23541 
      oprot.writeI64(self.settlementId)
23542 
      oprot.writeFieldEnd()
23543 
    oprot.writeFieldStop()
23544 
    oprot.writeStructEnd()
23545 
 
23546 
  def validate(self):
23547 
    return
23548 
 
23549 
 
23550 
  def __repr__(self):
23551 
    L = ['%s=%r' % (key, value)
23552 
      for key, value in self.__dict__.iteritems()]
23553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23554 
 
23555 
  def __eq__(self, other):
23556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23557 
 
23558 
  def __ne__(self, other):
23559 
    return not (self == other)
23560 
 
23561 
class getEBSSettlementDate_result:
23562 
  """
23563 
  Attributes:
23564 
   - success
23565 
   - ex
23566 
  """
23567 
 
23568 
  thrift_spec = (
23569 
    (0, TType.I64, 'success', None, None, ), # 0
23570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23571 
  )
23572 
 
23573 
  def __init__(self, success=None, ex=None,):
23574 
    self.success = success
23575 
    self.ex = ex
23576 
 
23577 
  def read(self, iprot):
23578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23580 
      return
23581 
    iprot.readStructBegin()
23582 
    while True:
23583 
      (fname, ftype, fid) = iprot.readFieldBegin()
23584 
      if ftype == TType.STOP:
23585 
        break
23586 
      if fid == 0:
23587 
        if ftype == TType.I64:
23588 
          self.success = iprot.readI64();
23589 
        else:
23590 
          iprot.skip(ftype)
23591 
      elif fid == 1:
23592 
        if ftype == TType.STRUCT:
23593 
          self.ex = TransactionServiceException()
23594 
          self.ex.read(iprot)
23595 
        else:
23596 
          iprot.skip(ftype)
23597 
      else:
23598 
        iprot.skip(ftype)
23599 
      iprot.readFieldEnd()
23600 
    iprot.readStructEnd()
23601 
 
23602 
  def write(self, oprot):
23603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23605 
      return
23606 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23607 
    if self.success is not None:
23608 
      oprot.writeFieldBegin('success', TType.I64, 0)
23609 
      oprot.writeI64(self.success)
23610 
      oprot.writeFieldEnd()
23611 
    if self.ex is not None:
23612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23613 
      self.ex.write(oprot)
23614 
      oprot.writeFieldEnd()
23615 
    oprot.writeFieldStop()
23616 
    oprot.writeStructEnd()
23617 
 
23618 
  def validate(self):
23619 
    return
23620 
 
23621 
 
23622 
  def __repr__(self):
23623 
    L = ['%s=%r' % (key, value)
23624 
      for key, value in self.__dict__.iteritems()]
23625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23626 
 
23627 
  def __eq__(self, other):
23628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23629 
 
23630 
  def __ne__(self, other):
23631 
    return not (self == other)
4715 varun.gupt 23632 
 
23633 
class getSettlementsByDate_args:
23634 
  """
23635 
  Attributes:
23636 
   - settlementDateFrom
23637 
   - settlementDateTo
23638 
   - isRefund
23639 
  """
23640 
 
23641 
  thrift_spec = (
23642 
    None, # 0
23643 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23644 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23645 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23646 
  )
23647 
 
23648 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23649 
    self.settlementDateFrom = settlementDateFrom
23650 
    self.settlementDateTo = settlementDateTo
23651 
    self.isRefund = isRefund
23652 
 
23653 
  def read(self, iprot):
23654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23656 
      return
23657 
    iprot.readStructBegin()
23658 
    while True:
23659 
      (fname, ftype, fid) = iprot.readFieldBegin()
23660 
      if ftype == TType.STOP:
23661 
        break
23662 
      if fid == 1:
23663 
        if ftype == TType.I64:
23664 
          self.settlementDateFrom = iprot.readI64();
23665 
        else:
23666 
          iprot.skip(ftype)
23667 
      elif fid == 2:
23668 
        if ftype == TType.I64:
23669 
          self.settlementDateTo = iprot.readI64();
23670 
        else:
23671 
          iprot.skip(ftype)
23672 
      elif fid == 3:
23673 
        if ftype == TType.BOOL:
23674 
          self.isRefund = iprot.readBool();
23675 
        else:
23676 
          iprot.skip(ftype)
23677 
      else:
23678 
        iprot.skip(ftype)
23679 
      iprot.readFieldEnd()
23680 
    iprot.readStructEnd()
23681 
 
23682 
  def write(self, oprot):
23683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23685 
      return
23686 
    oprot.writeStructBegin('getSettlementsByDate_args')
23687 
    if self.settlementDateFrom is not None:
23688 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23689 
      oprot.writeI64(self.settlementDateFrom)
23690 
      oprot.writeFieldEnd()
23691 
    if self.settlementDateTo is not None:
23692 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23693 
      oprot.writeI64(self.settlementDateTo)
23694 
      oprot.writeFieldEnd()
23695 
    if self.isRefund is not None:
23696 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23697 
      oprot.writeBool(self.isRefund)
23698 
      oprot.writeFieldEnd()
23699 
    oprot.writeFieldStop()
23700 
    oprot.writeStructEnd()
23701 
 
23702 
  def validate(self):
23703 
    return
23704 
 
23705 
 
23706 
  def __repr__(self):
23707 
    L = ['%s=%r' % (key, value)
23708 
      for key, value in self.__dict__.iteritems()]
23709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23710 
 
23711 
  def __eq__(self, other):
23712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23713 
 
23714 
  def __ne__(self, other):
23715 
    return not (self == other)
23716 
 
23717 
class getSettlementsByDate_result:
23718 
  """
23719 
  Attributes:
23720 
   - success
23721 
   - ex
23722 
  """
23723 
 
23724 
  thrift_spec = (
23725 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23727 
  )
23728 
 
23729 
  def __init__(self, success=None, ex=None,):
23730 
    self.success = success
23731 
    self.ex = ex
23732 
 
23733 
  def read(self, iprot):
23734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23736 
      return
23737 
    iprot.readStructBegin()
23738 
    while True:
23739 
      (fname, ftype, fid) = iprot.readFieldBegin()
23740 
      if ftype == TType.STOP:
23741 
        break
23742 
      if fid == 0:
23743 
        if ftype == TType.LIST:
23744 
          self.success = []
6188 rajveer 23745 
          (_etype566, _size563) = iprot.readListBegin()
23746 
          for _i567 in xrange(_size563):
23747 
            _elem568 = PaymentSettlement()
23748 
            _elem568.read(iprot)
23749 
            self.success.append(_elem568)
4715 varun.gupt 23750 
          iprot.readListEnd()
23751 
        else:
23752 
          iprot.skip(ftype)
23753 
      elif fid == 1:
23754 
        if ftype == TType.STRUCT:
23755 
          self.ex = TransactionServiceException()
23756 
          self.ex.read(iprot)
23757 
        else:
23758 
          iprot.skip(ftype)
23759 
      else:
23760 
        iprot.skip(ftype)
23761 
      iprot.readFieldEnd()
23762 
    iprot.readStructEnd()
23763 
 
23764 
  def write(self, oprot):
23765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23767 
      return
23768 
    oprot.writeStructBegin('getSettlementsByDate_result')
23769 
    if self.success is not None:
23770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23772 
      for iter569 in self.success:
23773 
        iter569.write(oprot)
4715 varun.gupt 23774 
      oprot.writeListEnd()
23775 
      oprot.writeFieldEnd()
23776 
    if self.ex is not None:
23777 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23778 
      self.ex.write(oprot)
23779 
      oprot.writeFieldEnd()
23780 
    oprot.writeFieldStop()
23781 
    oprot.writeStructEnd()
23782 
 
23783 
  def validate(self):
23784 
    return
23785 
 
23786 
 
23787 
  def __repr__(self):
23788 
    L = ['%s=%r' % (key, value)
23789 
      for key, value in self.__dict__.iteritems()]
23790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23791 
 
23792 
  def __eq__(self, other):
23793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23794 
 
23795 
  def __ne__(self, other):
23796 
    return not (self == other)
23797 
 
23798 
class getReshippedOrderIds_args:
23799 
  """
23800 
  Attributes:
23801 
   - orderIds
23802 
  """
23803 
 
23804 
  thrift_spec = (
23805 
    None, # 0
23806 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23807 
  )
23808 
 
23809 
  def __init__(self, orderIds=None,):
23810 
    self.orderIds = orderIds
23811 
 
23812 
  def read(self, iprot):
23813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23815 
      return
23816 
    iprot.readStructBegin()
23817 
    while True:
23818 
      (fname, ftype, fid) = iprot.readFieldBegin()
23819 
      if ftype == TType.STOP:
23820 
        break
23821 
      if fid == 1:
23822 
        if ftype == TType.LIST:
23823 
          self.orderIds = []
6188 rajveer 23824 
          (_etype573, _size570) = iprot.readListBegin()
23825 
          for _i574 in xrange(_size570):
23826 
            _elem575 = iprot.readI64();
23827 
            self.orderIds.append(_elem575)
4715 varun.gupt 23828 
          iprot.readListEnd()
23829 
        else:
23830 
          iprot.skip(ftype)
23831 
      else:
23832 
        iprot.skip(ftype)
23833 
      iprot.readFieldEnd()
23834 
    iprot.readStructEnd()
23835 
 
23836 
  def write(self, oprot):
23837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23839 
      return
23840 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23841 
    if self.orderIds is not None:
23842 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23843 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23844 
      for iter576 in self.orderIds:
23845 
        oprot.writeI64(iter576)
4715 varun.gupt 23846 
      oprot.writeListEnd()
23847 
      oprot.writeFieldEnd()
23848 
    oprot.writeFieldStop()
23849 
    oprot.writeStructEnd()
23850 
 
23851 
  def validate(self):
23852 
    return
23853 
 
23854 
 
23855 
  def __repr__(self):
23856 
    L = ['%s=%r' % (key, value)
23857 
      for key, value in self.__dict__.iteritems()]
23858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23859 
 
23860 
  def __eq__(self, other):
23861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23862 
 
23863 
  def __ne__(self, other):
23864 
    return not (self == other)
23865 
 
23866 
class getReshippedOrderIds_result:
23867 
  """
23868 
  Attributes:
23869 
   - success
23870 
   - ex
23871 
  """
23872 
 
23873 
  thrift_spec = (
23874 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23876 
  )
23877 
 
23878 
  def __init__(self, success=None, ex=None,):
23879 
    self.success = success
23880 
    self.ex = ex
23881 
 
23882 
  def read(self, iprot):
23883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23885 
      return
23886 
    iprot.readStructBegin()
23887 
    while True:
23888 
      (fname, ftype, fid) = iprot.readFieldBegin()
23889 
      if ftype == TType.STOP:
23890 
        break
23891 
      if fid == 0:
23892 
        if ftype == TType.LIST:
23893 
          self.success = []
6188 rajveer 23894 
          (_etype580, _size577) = iprot.readListBegin()
23895 
          for _i581 in xrange(_size577):
23896 
            _elem582 = iprot.readI64();
23897 
            self.success.append(_elem582)
4715 varun.gupt 23898 
          iprot.readListEnd()
23899 
        else:
23900 
          iprot.skip(ftype)
23901 
      elif fid == 1:
23902 
        if ftype == TType.STRUCT:
23903 
          self.ex = TransactionServiceException()
23904 
          self.ex.read(iprot)
23905 
        else:
23906 
          iprot.skip(ftype)
23907 
      else:
23908 
        iprot.skip(ftype)
23909 
      iprot.readFieldEnd()
23910 
    iprot.readStructEnd()
23911 
 
23912 
  def write(self, oprot):
23913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23915 
      return
23916 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23917 
    if self.success is not None:
23918 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23919 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 23920 
      for iter583 in self.success:
23921 
        oprot.writeI64(iter583)
4715 varun.gupt 23922 
      oprot.writeListEnd()
23923 
      oprot.writeFieldEnd()
23924 
    if self.ex is not None:
23925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23926 
      self.ex.write(oprot)
23927 
      oprot.writeFieldEnd()
23928 
    oprot.writeFieldStop()
23929 
    oprot.writeStructEnd()
23930 
 
23931 
  def validate(self):
23932 
    return
23933 
 
23934 
 
23935 
  def __repr__(self):
23936 
    L = ['%s=%r' % (key, value)
23937 
      for key, value in self.__dict__.iteritems()]
23938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23939 
 
23940 
  def __eq__(self, other):
23941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23942 
 
23943 
  def __ne__(self, other):
23944 
    return not (self == other)
4757 mandeep.dh 23945 
 
5481 phani.kuma 23946 
class getBilledOrders_args:
4875 varun.gupt 23947 
  """
23948 
  Attributes:
23949 
   - vendorId
5481 phani.kuma 23950 
   - onlyVendorNotPaid
23951 
   - billingDateFrom
23952 
   - billingDateTo
4875 varun.gupt 23953 
  """
23954 
 
23955 
  thrift_spec = (
23956 
    None, # 0
23957 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23958 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23959 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23960 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23961 
  )
23962 
 
5481 phani.kuma 23963 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23964 
    self.vendorId = vendorId
5481 phani.kuma 23965 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23966 
    self.billingDateFrom = billingDateFrom
23967 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23968 
 
23969 
  def read(self, iprot):
23970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23972 
      return
23973 
    iprot.readStructBegin()
23974 
    while True:
23975 
      (fname, ftype, fid) = iprot.readFieldBegin()
23976 
      if ftype == TType.STOP:
23977 
        break
23978 
      if fid == 1:
23979 
        if ftype == TType.I64:
23980 
          self.vendorId = iprot.readI64();
23981 
        else:
23982 
          iprot.skip(ftype)
5481 phani.kuma 23983 
      elif fid == 2:
23984 
        if ftype == TType.BOOL:
23985 
          self.onlyVendorNotPaid = iprot.readBool();
23986 
        else:
23987 
          iprot.skip(ftype)
23988 
      elif fid == 3:
23989 
        if ftype == TType.I64:
23990 
          self.billingDateFrom = iprot.readI64();
23991 
        else:
23992 
          iprot.skip(ftype)
23993 
      elif fid == 4:
23994 
        if ftype == TType.I64:
23995 
          self.billingDateTo = iprot.readI64();
23996 
        else:
23997 
          iprot.skip(ftype)
4875 varun.gupt 23998 
      else:
23999 
        iprot.skip(ftype)
24000 
      iprot.readFieldEnd()
24001 
    iprot.readStructEnd()
24002 
 
24003 
  def write(self, oprot):
24004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24006 
      return
5481 phani.kuma 24007 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24008 
    if self.vendorId is not None:
24009 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24010 
      oprot.writeI64(self.vendorId)
24011 
      oprot.writeFieldEnd()
5481 phani.kuma 24012 
    if self.onlyVendorNotPaid is not None:
24013 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24014 
      oprot.writeBool(self.onlyVendorNotPaid)
24015 
      oprot.writeFieldEnd()
24016 
    if self.billingDateFrom is not None:
24017 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24018 
      oprot.writeI64(self.billingDateFrom)
24019 
      oprot.writeFieldEnd()
24020 
    if self.billingDateTo is not None:
24021 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24022 
      oprot.writeI64(self.billingDateTo)
24023 
      oprot.writeFieldEnd()
4875 varun.gupt 24024 
    oprot.writeFieldStop()
24025 
    oprot.writeStructEnd()
24026 
 
24027 
  def validate(self):
24028 
    return
24029 
 
24030 
 
24031 
  def __repr__(self):
24032 
    L = ['%s=%r' % (key, value)
24033 
      for key, value in self.__dict__.iteritems()]
24034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24035 
 
24036 
  def __eq__(self, other):
24037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24038 
 
24039 
  def __ne__(self, other):
24040 
    return not (self == other)
24041 
 
5481 phani.kuma 24042 
class getBilledOrders_result:
4875 varun.gupt 24043 
  """
24044 
  Attributes:
24045 
   - success
24046 
   - ex
24047 
  """
24048 
 
24049 
  thrift_spec = (
24050 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24051 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24052 
  )
24053 
 
24054 
  def __init__(self, success=None, ex=None,):
24055 
    self.success = success
24056 
    self.ex = ex
24057 
 
24058 
  def read(self, iprot):
24059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24061 
      return
24062 
    iprot.readStructBegin()
24063 
    while True:
24064 
      (fname, ftype, fid) = iprot.readFieldBegin()
24065 
      if ftype == TType.STOP:
24066 
        break
24067 
      if fid == 0:
24068 
        if ftype == TType.LIST:
24069 
          self.success = []
6188 rajveer 24070 
          (_etype587, _size584) = iprot.readListBegin()
24071 
          for _i588 in xrange(_size584):
24072 
            _elem589 = Order()
24073 
            _elem589.read(iprot)
24074 
            self.success.append(_elem589)
4875 varun.gupt 24075 
          iprot.readListEnd()
24076 
        else:
24077 
          iprot.skip(ftype)
24078 
      elif fid == 1:
24079 
        if ftype == TType.STRUCT:
24080 
          self.ex = TransactionServiceException()
24081 
          self.ex.read(iprot)
24082 
        else:
24083 
          iprot.skip(ftype)
24084 
      else:
24085 
        iprot.skip(ftype)
24086 
      iprot.readFieldEnd()
24087 
    iprot.readStructEnd()
24088 
 
24089 
  def write(self, oprot):
24090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24092 
      return
5481 phani.kuma 24093 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24094 
    if self.success is not None:
24095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24097 
      for iter590 in self.success:
24098 
        iter590.write(oprot)
4875 varun.gupt 24099 
      oprot.writeListEnd()
24100 
      oprot.writeFieldEnd()
24101 
    if self.ex is not None:
24102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24103 
      self.ex.write(oprot)
24104 
      oprot.writeFieldEnd()
24105 
    oprot.writeFieldStop()
24106 
    oprot.writeStructEnd()
24107 
 
24108 
  def validate(self):
24109 
    return
24110 
 
24111 
 
24112 
  def __repr__(self):
24113 
    L = ['%s=%r' % (key, value)
24114 
      for key, value in self.__dict__.iteritems()]
24115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24116 
 
24117 
  def __eq__(self, other):
24118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24119 
 
24120 
  def __ne__(self, other):
24121 
    return not (self == other)
5031 varun.gupt 24122 
 
24123 
class getStatusDistributionOfOrders_args:
24124 
  """
24125 
  Attributes:
24126 
   - startDate
24127 
   - endDate
24128 
  """
24129 
 
24130 
  thrift_spec = (
24131 
    None, # 0
24132 
    (1, TType.I64, 'startDate', None, None, ), # 1
24133 
    (2, TType.I64, 'endDate', None, None, ), # 2
24134 
  )
24135 
 
24136 
  def __init__(self, startDate=None, endDate=None,):
24137 
    self.startDate = startDate
24138 
    self.endDate = endDate
24139 
 
24140 
  def read(self, iprot):
24141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24143 
      return
24144 
    iprot.readStructBegin()
24145 
    while True:
24146 
      (fname, ftype, fid) = iprot.readFieldBegin()
24147 
      if ftype == TType.STOP:
24148 
        break
24149 
      if fid == 1:
24150 
        if ftype == TType.I64:
24151 
          self.startDate = iprot.readI64();
24152 
        else:
24153 
          iprot.skip(ftype)
24154 
      elif fid == 2:
24155 
        if ftype == TType.I64:
24156 
          self.endDate = iprot.readI64();
24157 
        else:
24158 
          iprot.skip(ftype)
24159 
      else:
24160 
        iprot.skip(ftype)
24161 
      iprot.readFieldEnd()
24162 
    iprot.readStructEnd()
24163 
 
24164 
  def write(self, oprot):
24165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24167 
      return
24168 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24169 
    if self.startDate is not None:
24170 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24171 
      oprot.writeI64(self.startDate)
24172 
      oprot.writeFieldEnd()
24173 
    if self.endDate is not None:
24174 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24175 
      oprot.writeI64(self.endDate)
24176 
      oprot.writeFieldEnd()
24177 
    oprot.writeFieldStop()
24178 
    oprot.writeStructEnd()
24179 
 
24180 
  def validate(self):
24181 
    return
24182 
 
24183 
 
24184 
  def __repr__(self):
24185 
    L = ['%s=%r' % (key, value)
24186 
      for key, value in self.__dict__.iteritems()]
24187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24188 
 
24189 
  def __eq__(self, other):
24190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24191 
 
24192 
  def __ne__(self, other):
24193 
    return not (self == other)
24194 
 
24195 
class getStatusDistributionOfOrders_result:
24196 
  """
24197 
  Attributes:
24198 
   - success
24199 
   - ex
24200 
  """
24201 
 
24202 
  thrift_spec = (
24203 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24205 
  )
24206 
 
24207 
  def __init__(self, success=None, ex=None,):
24208 
    self.success = success
24209 
    self.ex = ex
24210 
 
24211 
  def read(self, iprot):
24212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24214 
      return
24215 
    iprot.readStructBegin()
24216 
    while True:
24217 
      (fname, ftype, fid) = iprot.readFieldBegin()
24218 
      if ftype == TType.STOP:
24219 
        break
24220 
      if fid == 0:
24221 
        if ftype == TType.MAP:
24222 
          self.success = {}
6188 rajveer 24223 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24224 
          for _i595 in xrange(_size591):
24225 
            _key596 = iprot.readI64();
24226 
            _val597 = iprot.readI64();
24227 
            self.success[_key596] = _val597
5031 varun.gupt 24228 
          iprot.readMapEnd()
24229 
        else:
24230 
          iprot.skip(ftype)
24231 
      elif fid == 1:
24232 
        if ftype == TType.STRUCT:
24233 
          self.ex = TransactionServiceException()
24234 
          self.ex.read(iprot)
24235 
        else:
24236 
          iprot.skip(ftype)
24237 
      else:
24238 
        iprot.skip(ftype)
24239 
      iprot.readFieldEnd()
24240 
    iprot.readStructEnd()
24241 
 
24242 
  def write(self, oprot):
24243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24245 
      return
24246 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24247 
    if self.success is not None:
24248 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24249 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24250 
      for kiter598,viter599 in self.success.items():
24251 
        oprot.writeI64(kiter598)
24252 
        oprot.writeI64(viter599)
5031 varun.gupt 24253 
      oprot.writeMapEnd()
24254 
      oprot.writeFieldEnd()
24255 
    if self.ex is not None:
24256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24257 
      self.ex.write(oprot)
24258 
      oprot.writeFieldEnd()
24259 
    oprot.writeFieldStop()
24260 
    oprot.writeStructEnd()
24261 
 
24262 
  def validate(self):
24263 
    return
24264 
 
24265 
 
24266 
  def __repr__(self):
24267 
    L = ['%s=%r' % (key, value)
24268 
      for key, value in self.__dict__.iteritems()]
24269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24270 
 
24271 
  def __eq__(self, other):
24272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24273 
 
24274 
  def __ne__(self, other):
24275 
    return not (self == other)
5067 varun.gupt 24276 
 
24277 
class getOrderIdsForStatus_args:
24278 
  """
24279 
  Attributes:
24280 
   - status
24281 
   - startDatetime
24282 
   - endDatetime
24283 
  """
24284 
 
24285 
  thrift_spec = (
24286 
    None, # 0
24287 
    (1, TType.I64, 'status', None, None, ), # 1
24288 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24289 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24290 
  )
24291 
 
24292 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24293 
    self.status = status
24294 
    self.startDatetime = startDatetime
24295 
    self.endDatetime = endDatetime
24296 
 
24297 
  def read(self, iprot):
24298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24300 
      return
24301 
    iprot.readStructBegin()
24302 
    while True:
24303 
      (fname, ftype, fid) = iprot.readFieldBegin()
24304 
      if ftype == TType.STOP:
24305 
        break
24306 
      if fid == 1:
24307 
        if ftype == TType.I64:
24308 
          self.status = iprot.readI64();
24309 
        else:
24310 
          iprot.skip(ftype)
24311 
      elif fid == 2:
24312 
        if ftype == TType.I64:
24313 
          self.startDatetime = iprot.readI64();
24314 
        else:
24315 
          iprot.skip(ftype)
24316 
      elif fid == 3:
24317 
        if ftype == TType.I64:
24318 
          self.endDatetime = iprot.readI64();
24319 
        else:
24320 
          iprot.skip(ftype)
24321 
      else:
24322 
        iprot.skip(ftype)
24323 
      iprot.readFieldEnd()
24324 
    iprot.readStructEnd()
24325 
 
24326 
  def write(self, oprot):
24327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24329 
      return
24330 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24331 
    if self.status is not None:
24332 
      oprot.writeFieldBegin('status', TType.I64, 1)
24333 
      oprot.writeI64(self.status)
24334 
      oprot.writeFieldEnd()
24335 
    if self.startDatetime is not None:
24336 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24337 
      oprot.writeI64(self.startDatetime)
24338 
      oprot.writeFieldEnd()
24339 
    if self.endDatetime is not None:
24340 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24341 
      oprot.writeI64(self.endDatetime)
24342 
      oprot.writeFieldEnd()
24343 
    oprot.writeFieldStop()
24344 
    oprot.writeStructEnd()
24345 
 
24346 
  def validate(self):
24347 
    return
24348 
 
24349 
 
24350 
  def __repr__(self):
24351 
    L = ['%s=%r' % (key, value)
24352 
      for key, value in self.__dict__.iteritems()]
24353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24354 
 
24355 
  def __eq__(self, other):
24356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24357 
 
24358 
  def __ne__(self, other):
24359 
    return not (self == other)
24360 
 
24361 
class getOrderIdsForStatus_result:
24362 
  """
24363 
  Attributes:
24364 
   - success
24365 
   - ex
24366 
  """
24367 
 
24368 
  thrift_spec = (
24369 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24371 
  )
24372 
 
24373 
  def __init__(self, success=None, ex=None,):
24374 
    self.success = success
24375 
    self.ex = ex
24376 
 
24377 
  def read(self, iprot):
24378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24380 
      return
24381 
    iprot.readStructBegin()
24382 
    while True:
24383 
      (fname, ftype, fid) = iprot.readFieldBegin()
24384 
      if ftype == TType.STOP:
24385 
        break
24386 
      if fid == 0:
24387 
        if ftype == TType.LIST:
24388 
          self.success = []
6188 rajveer 24389 
          (_etype603, _size600) = iprot.readListBegin()
24390 
          for _i604 in xrange(_size600):
24391 
            _elem605 = iprot.readI64();
24392 
            self.success.append(_elem605)
5067 varun.gupt 24393 
          iprot.readListEnd()
24394 
        else:
24395 
          iprot.skip(ftype)
24396 
      elif fid == 1:
24397 
        if ftype == TType.STRUCT:
24398 
          self.ex = TransactionServiceException()
24399 
          self.ex.read(iprot)
24400 
        else:
24401 
          iprot.skip(ftype)
24402 
      else:
24403 
        iprot.skip(ftype)
24404 
      iprot.readFieldEnd()
24405 
    iprot.readStructEnd()
24406 
 
24407 
  def write(self, oprot):
24408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24410 
      return
24411 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24412 
    if self.success is not None:
24413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24414 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24415 
      for iter606 in self.success:
24416 
        oprot.writeI64(iter606)
5067 varun.gupt 24417 
      oprot.writeListEnd()
24418 
      oprot.writeFieldEnd()
24419 
    if self.ex is not None:
24420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24421 
      self.ex.write(oprot)
24422 
      oprot.writeFieldEnd()
24423 
    oprot.writeFieldStop()
24424 
    oprot.writeStructEnd()
24425 
 
24426 
  def validate(self):
24427 
    return
24428 
 
24429 
 
24430 
  def __repr__(self):
24431 
    L = ['%s=%r' % (key, value)
24432 
      for key, value in self.__dict__.iteritems()]
24433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24434 
 
24435 
  def __eq__(self, other):
24436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24437 
 
24438 
  def __ne__(self, other):
24439 
    return not (self == other)
5099 varun.gupt 24440 
 
5348 anupam.sin 24441 
class updateCODAgent_args:
24442 
  """
24443 
  Attributes:
24444 
   - agent
24445 
   - orderId
24446 
  """
24447 
 
24448 
  thrift_spec = (
24449 
    None, # 0
24450 
    (1, TType.STRING, 'agent', None, None, ), # 1
24451 
    (2, TType.I64, 'orderId', None, None, ), # 2
24452 
  )
24453 
 
24454 
  def __init__(self, agent=None, orderId=None,):
24455 
    self.agent = agent
24456 
    self.orderId = orderId
24457 
 
24458 
  def read(self, iprot):
24459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24461 
      return
24462 
    iprot.readStructBegin()
24463 
    while True:
24464 
      (fname, ftype, fid) = iprot.readFieldBegin()
24465 
      if ftype == TType.STOP:
24466 
        break
24467 
      if fid == 1:
24468 
        if ftype == TType.STRING:
24469 
          self.agent = iprot.readString();
24470 
        else:
24471 
          iprot.skip(ftype)
24472 
      elif fid == 2:
24473 
        if ftype == TType.I64:
24474 
          self.orderId = iprot.readI64();
24475 
        else:
24476 
          iprot.skip(ftype)
24477 
      else:
24478 
        iprot.skip(ftype)
24479 
      iprot.readFieldEnd()
24480 
    iprot.readStructEnd()
24481 
 
24482 
  def write(self, oprot):
24483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24485 
      return
24486 
    oprot.writeStructBegin('updateCODAgent_args')
24487 
    if self.agent is not None:
24488 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24489 
      oprot.writeString(self.agent)
24490 
      oprot.writeFieldEnd()
24491 
    if self.orderId is not None:
24492 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24493 
      oprot.writeI64(self.orderId)
24494 
      oprot.writeFieldEnd()
24495 
    oprot.writeFieldStop()
24496 
    oprot.writeStructEnd()
24497 
 
24498 
  def validate(self):
24499 
    return
24500 
 
24501 
 
24502 
  def __repr__(self):
24503 
    L = ['%s=%r' % (key, value)
24504 
      for key, value in self.__dict__.iteritems()]
24505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24506 
 
24507 
  def __eq__(self, other):
24508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24509 
 
24510 
  def __ne__(self, other):
24511 
    return not (self == other)
24512 
 
24513 
class updateCODAgent_result:
24514 
  """
24515 
  Attributes:
24516 
   - ex
24517 
  """
24518 
 
24519 
  thrift_spec = (
24520 
    None, # 0
24521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24522 
  )
24523 
 
24524 
  def __init__(self, ex=None,):
24525 
    self.ex = ex
24526 
 
24527 
  def read(self, iprot):
24528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24530 
      return
24531 
    iprot.readStructBegin()
24532 
    while True:
24533 
      (fname, ftype, fid) = iprot.readFieldBegin()
24534 
      if ftype == TType.STOP:
24535 
        break
24536 
      if fid == 1:
24537 
        if ftype == TType.STRUCT:
24538 
          self.ex = TransactionServiceException()
24539 
          self.ex.read(iprot)
24540 
        else:
24541 
          iprot.skip(ftype)
24542 
      else:
24543 
        iprot.skip(ftype)
24544 
      iprot.readFieldEnd()
24545 
    iprot.readStructEnd()
24546 
 
24547 
  def write(self, oprot):
24548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24550 
      return
24551 
    oprot.writeStructBegin('updateCODAgent_result')
24552 
    if self.ex is not None:
24553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24554 
      self.ex.write(oprot)
24555 
      oprot.writeFieldEnd()
24556 
    oprot.writeFieldStop()
24557 
    oprot.writeStructEnd()
24558 
 
24559 
  def validate(self):
24560 
    return
24561 
 
24562 
 
24563 
  def __repr__(self):
24564 
    L = ['%s=%r' % (key, value)
24565 
      for key, value in self.__dict__.iteritems()]
24566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24567 
 
24568 
  def __eq__(self, other):
24569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24570 
 
24571 
  def __ne__(self, other):
24572 
    return not (self == other)
24573 
 
5099 varun.gupt 24574 
class updateOrderAsPaidToVendor_args:
24575 
  """
24576 
  Attributes:
24577 
   - orderId
24578 
  """
24579 
 
24580 
  thrift_spec = (
24581 
    None, # 0
24582 
    (1, TType.I64, 'orderId', None, None, ), # 1
24583 
  )
24584 
 
24585 
  def __init__(self, orderId=None,):
24586 
    self.orderId = orderId
24587 
 
24588 
  def read(self, iprot):
24589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24591 
      return
24592 
    iprot.readStructBegin()
24593 
    while True:
24594 
      (fname, ftype, fid) = iprot.readFieldBegin()
24595 
      if ftype == TType.STOP:
24596 
        break
24597 
      if fid == 1:
24598 
        if ftype == TType.I64:
24599 
          self.orderId = iprot.readI64();
24600 
        else:
24601 
          iprot.skip(ftype)
24602 
      else:
24603 
        iprot.skip(ftype)
24604 
      iprot.readFieldEnd()
24605 
    iprot.readStructEnd()
24606 
 
24607 
  def write(self, oprot):
24608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24610 
      return
24611 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24612 
    if self.orderId is not None:
24613 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24614 
      oprot.writeI64(self.orderId)
24615 
      oprot.writeFieldEnd()
24616 
    oprot.writeFieldStop()
24617 
    oprot.writeStructEnd()
24618 
 
24619 
  def validate(self):
24620 
    return
24621 
 
24622 
 
24623 
  def __repr__(self):
24624 
    L = ['%s=%r' % (key, value)
24625 
      for key, value in self.__dict__.iteritems()]
24626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24627 
 
24628 
  def __eq__(self, other):
24629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24630 
 
24631 
  def __ne__(self, other):
24632 
    return not (self == other)
24633 
 
24634 
class updateOrderAsPaidToVendor_result:
24635 
  """
24636 
  Attributes:
24637 
   - ex
24638 
  """
24639 
 
24640 
  thrift_spec = (
24641 
    None, # 0
24642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24643 
  )
24644 
 
24645 
  def __init__(self, ex=None,):
24646 
    self.ex = ex
24647 
 
24648 
  def read(self, iprot):
24649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24651 
      return
24652 
    iprot.readStructBegin()
24653 
    while True:
24654 
      (fname, ftype, fid) = iprot.readFieldBegin()
24655 
      if ftype == TType.STOP:
24656 
        break
24657 
      if fid == 1:
24658 
        if ftype == TType.STRUCT:
24659 
          self.ex = TransactionServiceException()
24660 
          self.ex.read(iprot)
24661 
        else:
24662 
          iprot.skip(ftype)
24663 
      else:
24664 
        iprot.skip(ftype)
24665 
      iprot.readFieldEnd()
24666 
    iprot.readStructEnd()
24667 
 
24668 
  def write(self, oprot):
24669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24671 
      return
24672 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24673 
    if self.ex is not None:
24674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24675 
      self.ex.write(oprot)
24676 
      oprot.writeFieldEnd()
24677 
    oprot.writeFieldStop()
24678 
    oprot.writeStructEnd()
24679 
 
24680 
  def validate(self):
24681 
    return
24682 
 
24683 
 
24684 
  def __repr__(self):
24685 
    L = ['%s=%r' % (key, value)
24686 
      for key, value in self.__dict__.iteritems()]
24687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24688 
 
24689 
  def __eq__(self, other):
24690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24691 
 
24692 
  def __ne__(self, other):
24693 
    return not (self == other)
5208 varun.gupt 24694 
 
5386 phani.kuma 24695 
class updateOrderOnlyAsPaidToVendor_args:
24696 
  """
24697 
  Attributes:
24698 
   - orderId
24699 
  """
24700 
 
24701 
  thrift_spec = (
24702 
    None, # 0
24703 
    (1, TType.I64, 'orderId', None, None, ), # 1
24704 
  )
24705 
 
24706 
  def __init__(self, orderId=None,):
24707 
    self.orderId = orderId
24708 
 
24709 
  def read(self, iprot):
24710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24712 
      return
24713 
    iprot.readStructBegin()
24714 
    while True:
24715 
      (fname, ftype, fid) = iprot.readFieldBegin()
24716 
      if ftype == TType.STOP:
24717 
        break
24718 
      if fid == 1:
24719 
        if ftype == TType.I64:
24720 
          self.orderId = iprot.readI64();
24721 
        else:
24722 
          iprot.skip(ftype)
24723 
      else:
24724 
        iprot.skip(ftype)
24725 
      iprot.readFieldEnd()
24726 
    iprot.readStructEnd()
24727 
 
24728 
  def write(self, oprot):
24729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24731 
      return
24732 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24733 
    if self.orderId is not None:
24734 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24735 
      oprot.writeI64(self.orderId)
24736 
      oprot.writeFieldEnd()
24737 
    oprot.writeFieldStop()
24738 
    oprot.writeStructEnd()
24739 
 
24740 
  def validate(self):
24741 
    return
24742 
 
24743 
 
24744 
  def __repr__(self):
24745 
    L = ['%s=%r' % (key, value)
24746 
      for key, value in self.__dict__.iteritems()]
24747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24748 
 
24749 
  def __eq__(self, other):
24750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24751 
 
24752 
  def __ne__(self, other):
24753 
    return not (self == other)
24754 
 
24755 
class updateOrderOnlyAsPaidToVendor_result:
24756 
  """
24757 
  Attributes:
24758 
   - ex
24759 
  """
24760 
 
24761 
  thrift_spec = (
24762 
    None, # 0
24763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24764 
  )
24765 
 
24766 
  def __init__(self, ex=None,):
24767 
    self.ex = ex
24768 
 
24769 
  def read(self, iprot):
24770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24772 
      return
24773 
    iprot.readStructBegin()
24774 
    while True:
24775 
      (fname, ftype, fid) = iprot.readFieldBegin()
24776 
      if ftype == TType.STOP:
24777 
        break
24778 
      if fid == 1:
24779 
        if ftype == TType.STRUCT:
24780 
          self.ex = TransactionServiceException()
24781 
          self.ex.read(iprot)
24782 
        else:
24783 
          iprot.skip(ftype)
24784 
      else:
24785 
        iprot.skip(ftype)
24786 
      iprot.readFieldEnd()
24787 
    iprot.readStructEnd()
24788 
 
24789 
  def write(self, oprot):
24790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24792 
      return
24793 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24794 
    if self.ex is not None:
24795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24796 
      self.ex.write(oprot)
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 
 
5208 varun.gupt 24816 
class getRefundedOrdersMarkedPaid_args:
24817 
 
24818 
  thrift_spec = (
24819 
  )
24820 
 
24821 
  def read(self, iprot):
24822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24824 
      return
24825 
    iprot.readStructBegin()
24826 
    while True:
24827 
      (fname, ftype, fid) = iprot.readFieldBegin()
24828 
      if ftype == TType.STOP:
24829 
        break
24830 
      else:
24831 
        iprot.skip(ftype)
24832 
      iprot.readFieldEnd()
24833 
    iprot.readStructEnd()
24834 
 
24835 
  def write(self, oprot):
24836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24838 
      return
24839 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24840 
    oprot.writeFieldStop()
24841 
    oprot.writeStructEnd()
24842 
 
24843 
  def validate(self):
24844 
    return
24845 
 
24846 
 
24847 
  def __repr__(self):
24848 
    L = ['%s=%r' % (key, value)
24849 
      for key, value in self.__dict__.iteritems()]
24850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24851 
 
24852 
  def __eq__(self, other):
24853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24854 
 
24855 
  def __ne__(self, other):
24856 
    return not (self == other)
24857 
 
24858 
class getRefundedOrdersMarkedPaid_result:
24859 
  """
24860 
  Attributes:
24861 
   - success
24862 
   - ex
24863 
  """
24864 
 
24865 
  thrift_spec = (
24866 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24867 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24868 
  )
24869 
 
24870 
  def __init__(self, success=None, ex=None,):
24871 
    self.success = success
24872 
    self.ex = ex
24873 
 
24874 
  def read(self, iprot):
24875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24877 
      return
24878 
    iprot.readStructBegin()
24879 
    while True:
24880 
      (fname, ftype, fid) = iprot.readFieldBegin()
24881 
      if ftype == TType.STOP:
24882 
        break
24883 
      if fid == 0:
24884 
        if ftype == TType.LIST:
24885 
          self.success = []
6188 rajveer 24886 
          (_etype610, _size607) = iprot.readListBegin()
24887 
          for _i611 in xrange(_size607):
24888 
            _elem612 = Order()
24889 
            _elem612.read(iprot)
24890 
            self.success.append(_elem612)
5208 varun.gupt 24891 
          iprot.readListEnd()
24892 
        else:
24893 
          iprot.skip(ftype)
24894 
      elif fid == 1:
24895 
        if ftype == TType.STRUCT:
24896 
          self.ex = TransactionServiceException()
24897 
          self.ex.read(iprot)
24898 
        else:
24899 
          iprot.skip(ftype)
24900 
      else:
24901 
        iprot.skip(ftype)
24902 
      iprot.readFieldEnd()
24903 
    iprot.readStructEnd()
24904 
 
24905 
  def write(self, oprot):
24906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24908 
      return
24909 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24910 
    if self.success is not None:
24911 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24912 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24913 
      for iter613 in self.success:
24914 
        iter613.write(oprot)
5208 varun.gupt 24915 
      oprot.writeListEnd()
24916 
      oprot.writeFieldEnd()
24917 
    if self.ex is not None:
24918 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24919 
      self.ex.write(oprot)
24920 
      oprot.writeFieldEnd()
24921 
    oprot.writeFieldStop()
24922 
    oprot.writeStructEnd()
24923 
 
24924 
  def validate(self):
24925 
    return
24926 
 
24927 
 
24928 
  def __repr__(self):
24929 
    L = ['%s=%r' % (key, value)
24930 
      for key, value in self.__dict__.iteritems()]
24931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24932 
 
24933 
  def __eq__(self, other):
24934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24935 
 
24936 
  def __ne__(self, other):
24937 
    return not (self == other)
5447 anupam.sin 24938 
 
24939 
class getAllVerificationAgents_args:
24940 
  """
24941 
  Attributes:
24942 
   - minOrderId
24943 
   - maxOrderId
24944 
  """
24945 
 
24946 
  thrift_spec = (
24947 
    None, # 0
24948 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24949 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24950 
  )
24951 
 
24952 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24953 
    self.minOrderId = minOrderId
24954 
    self.maxOrderId = maxOrderId
24955 
 
24956 
  def read(self, iprot):
24957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24959 
      return
24960 
    iprot.readStructBegin()
24961 
    while True:
24962 
      (fname, ftype, fid) = iprot.readFieldBegin()
24963 
      if ftype == TType.STOP:
24964 
        break
24965 
      if fid == 1:
24966 
        if ftype == TType.I64:
24967 
          self.minOrderId = iprot.readI64();
24968 
        else:
24969 
          iprot.skip(ftype)
24970 
      elif fid == 2:
24971 
        if ftype == TType.I64:
24972 
          self.maxOrderId = iprot.readI64();
24973 
        else:
24974 
          iprot.skip(ftype)
24975 
      else:
24976 
        iprot.skip(ftype)
24977 
      iprot.readFieldEnd()
24978 
    iprot.readStructEnd()
24979 
 
24980 
  def write(self, oprot):
24981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24983 
      return
24984 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24985 
    if self.minOrderId is not None:
24986 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24987 
      oprot.writeI64(self.minOrderId)
24988 
      oprot.writeFieldEnd()
24989 
    if self.maxOrderId is not None:
24990 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24991 
      oprot.writeI64(self.maxOrderId)
24992 
      oprot.writeFieldEnd()
24993 
    oprot.writeFieldStop()
24994 
    oprot.writeStructEnd()
24995 
 
24996 
  def validate(self):
24997 
    return
24998 
 
24999 
 
25000 
  def __repr__(self):
25001 
    L = ['%s=%r' % (key, value)
25002 
      for key, value in self.__dict__.iteritems()]
25003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25004 
 
25005 
  def __eq__(self, other):
25006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25007 
 
25008 
  def __ne__(self, other):
25009 
    return not (self == other)
25010 
 
25011 
class getAllVerificationAgents_result:
25012 
  """
25013 
  Attributes:
25014 
   - success
25015 
  """
25016 
 
25017 
  thrift_spec = (
25018 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25019 
  )
25020 
 
25021 
  def __init__(self, success=None,):
25022 
    self.success = success
25023 
 
25024 
  def read(self, iprot):
25025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25027 
      return
25028 
    iprot.readStructBegin()
25029 
    while True:
25030 
      (fname, ftype, fid) = iprot.readFieldBegin()
25031 
      if ftype == TType.STOP:
25032 
        break
25033 
      if fid == 0:
25034 
        if ftype == TType.LIST:
25035 
          self.success = []
6188 rajveer 25036 
          (_etype617, _size614) = iprot.readListBegin()
25037 
          for _i618 in xrange(_size614):
25038 
            _elem619 = CODVerificationAgent()
25039 
            _elem619.read(iprot)
25040 
            self.success.append(_elem619)
5447 anupam.sin 25041 
          iprot.readListEnd()
25042 
        else:
25043 
          iprot.skip(ftype)
25044 
      else:
25045 
        iprot.skip(ftype)
25046 
      iprot.readFieldEnd()
25047 
    iprot.readStructEnd()
25048 
 
25049 
  def write(self, oprot):
25050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25052 
      return
25053 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25054 
    if self.success is not None:
25055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25056 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25057 
      for iter620 in self.success:
25058 
        iter620.write(oprot)
5447 anupam.sin 25059 
      oprot.writeListEnd()
25060 
      oprot.writeFieldEnd()
25061 
    oprot.writeFieldStop()
25062 
    oprot.writeStructEnd()
25063 
 
25064 
  def validate(self):
25065 
    return
25066 
 
25067 
 
25068 
  def __repr__(self):
25069 
    L = ['%s=%r' % (key, value)
25070 
      for key, value in self.__dict__.iteritems()]
25071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25072 
 
25073 
  def __eq__(self, other):
25074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25075 
 
25076 
  def __ne__(self, other):
25077 
    return not (self == other)
5527 anupam.sin 25078 
 
25079 
class getAllAttributesForOrderId_args:
25080 
  """
25081 
  Attributes:
25082 
   - orderId
25083 
  """
25084 
 
25085 
  thrift_spec = (
25086 
    None, # 0
25087 
    (1, TType.I64, 'orderId', None, None, ), # 1
25088 
  )
25089 
 
25090 
  def __init__(self, orderId=None,):
25091 
    self.orderId = orderId
25092 
 
25093 
  def read(self, iprot):
25094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25096 
      return
25097 
    iprot.readStructBegin()
25098 
    while True:
25099 
      (fname, ftype, fid) = iprot.readFieldBegin()
25100 
      if ftype == TType.STOP:
25101 
        break
25102 
      if fid == 1:
25103 
        if ftype == TType.I64:
25104 
          self.orderId = iprot.readI64();
25105 
        else:
25106 
          iprot.skip(ftype)
25107 
      else:
25108 
        iprot.skip(ftype)
25109 
      iprot.readFieldEnd()
25110 
    iprot.readStructEnd()
25111 
 
25112 
  def write(self, oprot):
25113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25115 
      return
25116 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25117 
    if self.orderId is not None:
25118 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25119 
      oprot.writeI64(self.orderId)
25120 
      oprot.writeFieldEnd()
25121 
    oprot.writeFieldStop()
25122 
    oprot.writeStructEnd()
25123 
 
25124 
  def validate(self):
25125 
    return
25126 
 
25127 
 
25128 
  def __repr__(self):
25129 
    L = ['%s=%r' % (key, value)
25130 
      for key, value in self.__dict__.iteritems()]
25131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25132 
 
25133 
  def __eq__(self, other):
25134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25135 
 
25136 
  def __ne__(self, other):
25137 
    return not (self == other)
25138 
 
25139 
class getAllAttributesForOrderId_result:
25140 
  """
25141 
  Attributes:
25142 
   - success
25143 
  """
25144 
 
25145 
  thrift_spec = (
25146 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25147 
  )
25148 
 
25149 
  def __init__(self, success=None,):
25150 
    self.success = success
25151 
 
25152 
  def read(self, iprot):
25153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25155 
      return
25156 
    iprot.readStructBegin()
25157 
    while True:
25158 
      (fname, ftype, fid) = iprot.readFieldBegin()
25159 
      if ftype == TType.STOP:
25160 
        break
25161 
      if fid == 0:
25162 
        if ftype == TType.LIST:
25163 
          self.success = []
6188 rajveer 25164 
          (_etype624, _size621) = iprot.readListBegin()
25165 
          for _i625 in xrange(_size621):
25166 
            _elem626 = Attribute()
25167 
            _elem626.read(iprot)
25168 
            self.success.append(_elem626)
5527 anupam.sin 25169 
          iprot.readListEnd()
25170 
        else:
25171 
          iprot.skip(ftype)
25172 
      else:
25173 
        iprot.skip(ftype)
25174 
      iprot.readFieldEnd()
25175 
    iprot.readStructEnd()
25176 
 
25177 
  def write(self, oprot):
25178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25180 
      return
25181 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25182 
    if self.success is not None:
25183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25185 
      for iter627 in self.success:
25186 
        iter627.write(oprot)
5527 anupam.sin 25187 
      oprot.writeListEnd()
25188 
      oprot.writeFieldEnd()
25189 
    oprot.writeFieldStop()
25190 
    oprot.writeStructEnd()
25191 
 
25192 
  def validate(self):
25193 
    return
25194 
 
25195 
 
25196 
  def __repr__(self):
25197 
    L = ['%s=%r' % (key, value)
25198 
      for key, value in self.__dict__.iteritems()]
25199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25200 
 
25201 
  def __eq__(self, other):
25202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25203 
 
25204 
  def __ne__(self, other):
25205 
    return not (self == other)
25206 
 
5676 rajveer 25207 
class setOrderAttributes_args:
25208 
  """
25209 
  Attributes:
25210 
   - orderId
25211 
   - attributes
25212 
  """
25213 
 
25214 
  thrift_spec = None
25215 
  def __init__(self, orderId=None, attributes=None,):
25216 
    self.orderId = orderId
25217 
    self.attributes = attributes
25218 
 
25219 
  def read(self, iprot):
25220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25222 
      return
25223 
    iprot.readStructBegin()
25224 
    while True:
25225 
      (fname, ftype, fid) = iprot.readFieldBegin()
25226 
      if ftype == TType.STOP:
25227 
        break
25228 
      if fid == 1:
25229 
        if ftype == TType.I64:
25230 
          self.orderId = iprot.readI64();
25231 
        else:
25232 
          iprot.skip(ftype)
25233 
      elif fid == -1:
25234 
        if ftype == TType.LIST:
25235 
          self.attributes = []
6188 rajveer 25236 
          (_etype631, _size628) = iprot.readListBegin()
25237 
          for _i632 in xrange(_size628):
25238 
            _elem633 = Attribute()
25239 
            _elem633.read(iprot)
25240 
            self.attributes.append(_elem633)
5676 rajveer 25241 
          iprot.readListEnd()
25242 
        else:
25243 
          iprot.skip(ftype)
25244 
      else:
25245 
        iprot.skip(ftype)
25246 
      iprot.readFieldEnd()
25247 
    iprot.readStructEnd()
25248 
 
25249 
  def write(self, oprot):
25250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25252 
      return
25253 
    oprot.writeStructBegin('setOrderAttributes_args')
25254 
    if self.attributes is not None:
25255 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25256 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25257 
      for iter634 in self.attributes:
25258 
        iter634.write(oprot)
5676 rajveer 25259 
      oprot.writeListEnd()
25260 
      oprot.writeFieldEnd()
25261 
    if self.orderId is not None:
25262 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25263 
      oprot.writeI64(self.orderId)
25264 
      oprot.writeFieldEnd()
25265 
    oprot.writeFieldStop()
25266 
    oprot.writeStructEnd()
25267 
 
25268 
  def validate(self):
25269 
    return
25270 
 
25271 
 
25272 
  def __repr__(self):
25273 
    L = ['%s=%r' % (key, value)
25274 
      for key, value in self.__dict__.iteritems()]
25275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25276 
 
25277 
  def __eq__(self, other):
25278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25279 
 
25280 
  def __ne__(self, other):
25281 
    return not (self == other)
25282 
 
25283 
class setOrderAttributes_result:
25284 
 
25285 
  thrift_spec = (
25286 
  )
25287 
 
25288 
  def read(self, iprot):
25289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25291 
      return
25292 
    iprot.readStructBegin()
25293 
    while True:
25294 
      (fname, ftype, fid) = iprot.readFieldBegin()
25295 
      if ftype == TType.STOP:
25296 
        break
25297 
      else:
25298 
        iprot.skip(ftype)
25299 
      iprot.readFieldEnd()
25300 
    iprot.readStructEnd()
25301 
 
25302 
  def write(self, oprot):
25303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25305 
      return
25306 
    oprot.writeStructBegin('setOrderAttributes_result')
25307 
    oprot.writeFieldStop()
25308 
    oprot.writeStructEnd()
25309 
 
25310 
  def validate(self):
25311 
    return
25312 
 
25313 
 
25314 
  def __repr__(self):
25315 
    L = ['%s=%r' % (key, value)
25316 
      for key, value in self.__dict__.iteritems()]
25317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25318 
 
25319 
  def __eq__(self, other):
25320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25321 
 
25322 
  def __ne__(self, other):
25323 
    return not (self == other)
25324 
 
5527 anupam.sin 25325 
class setOrderAttributeForTransaction_args:
25326 
  """
25327 
  Attributes:
25328 
   - transactionId
25329 
   - attribute
25330 
  """
25331 
 
25332 
  thrift_spec = None
25333 
  def __init__(self, transactionId=None, attribute=None,):
25334 
    self.transactionId = transactionId
25335 
    self.attribute = attribute
25336 
 
25337 
  def read(self, iprot):
25338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25340 
      return
25341 
    iprot.readStructBegin()
25342 
    while True:
25343 
      (fname, ftype, fid) = iprot.readFieldBegin()
25344 
      if ftype == TType.STOP:
25345 
        break
25346 
      if fid == 1:
25347 
        if ftype == TType.I64:
25348 
          self.transactionId = iprot.readI64();
25349 
        else:
25350 
          iprot.skip(ftype)
25351 
      elif fid == -1:
25352 
        if ftype == TType.STRUCT:
25353 
          self.attribute = Attribute()
25354 
          self.attribute.read(iprot)
25355 
        else:
25356 
          iprot.skip(ftype)
25357 
      else:
25358 
        iprot.skip(ftype)
25359 
      iprot.readFieldEnd()
25360 
    iprot.readStructEnd()
25361 
 
25362 
  def write(self, oprot):
25363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25365 
      return
25366 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25367 
    if self.attribute is not None:
25368 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25369 
      self.attribute.write(oprot)
25370 
      oprot.writeFieldEnd()
25371 
    if self.transactionId is not None:
25372 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25373 
      oprot.writeI64(self.transactionId)
25374 
      oprot.writeFieldEnd()
25375 
    oprot.writeFieldStop()
25376 
    oprot.writeStructEnd()
25377 
 
25378 
  def validate(self):
25379 
    return
25380 
 
25381 
 
25382 
  def __repr__(self):
25383 
    L = ['%s=%r' % (key, value)
25384 
      for key, value in self.__dict__.iteritems()]
25385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25386 
 
25387 
  def __eq__(self, other):
25388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25389 
 
25390 
  def __ne__(self, other):
25391 
    return not (self == other)
25392 
 
25393 
class setOrderAttributeForTransaction_result:
25394 
 
25395 
  thrift_spec = (
25396 
  )
25397 
 
25398 
  def read(self, iprot):
25399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25401 
      return
25402 
    iprot.readStructBegin()
25403 
    while True:
25404 
      (fname, ftype, fid) = iprot.readFieldBegin()
25405 
      if ftype == TType.STOP:
25406 
        break
25407 
      else:
25408 
        iprot.skip(ftype)
25409 
      iprot.readFieldEnd()
25410 
    iprot.readStructEnd()
25411 
 
25412 
  def write(self, oprot):
25413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25415 
      return
25416 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25417 
    oprot.writeFieldStop()
25418 
    oprot.writeStructEnd()
25419 
 
25420 
  def validate(self):
25421 
    return
25422 
 
25423 
 
25424 
  def __repr__(self):
25425 
    L = ['%s=%r' % (key, value)
25426 
      for key, value in self.__dict__.iteritems()]
25427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25428 
 
25429 
  def __eq__(self, other):
25430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25431 
 
25432 
  def __ne__(self, other):
25433 
    return not (self == other)
5553 rajveer 25434 
 
25435 
class getReceivePendingOrders_args:
25436 
  """
25437 
  Attributes:
25438 
   - storeId
25439 
  """
25440 
 
25441 
  thrift_spec = (
25442 
    None, # 0
25443 
    (1, TType.I64, 'storeId', None, None, ), # 1
25444 
  )
25445 
 
25446 
  def __init__(self, storeId=None,):
25447 
    self.storeId = storeId
25448 
 
25449 
  def read(self, iprot):
25450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25452 
      return
25453 
    iprot.readStructBegin()
25454 
    while True:
25455 
      (fname, ftype, fid) = iprot.readFieldBegin()
25456 
      if ftype == TType.STOP:
25457 
        break
25458 
      if fid == 1:
25459 
        if ftype == TType.I64:
25460 
          self.storeId = iprot.readI64();
25461 
        else:
25462 
          iprot.skip(ftype)
25463 
      else:
25464 
        iprot.skip(ftype)
25465 
      iprot.readFieldEnd()
25466 
    iprot.readStructEnd()
25467 
 
25468 
  def write(self, oprot):
25469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25471 
      return
25472 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25473 
    if self.storeId is not None:
25474 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25475 
      oprot.writeI64(self.storeId)
25476 
      oprot.writeFieldEnd()
25477 
    oprot.writeFieldStop()
25478 
    oprot.writeStructEnd()
25479 
 
25480 
  def validate(self):
25481 
    return
25482 
 
25483 
 
25484 
  def __repr__(self):
25485 
    L = ['%s=%r' % (key, value)
25486 
      for key, value in self.__dict__.iteritems()]
25487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25488 
 
25489 
  def __eq__(self, other):
25490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25491 
 
25492 
  def __ne__(self, other):
25493 
    return not (self == other)
25494 
 
25495 
class getReceivePendingOrders_result:
25496 
  """
25497 
  Attributes:
25498 
   - success
25499 
  """
25500 
 
25501 
  thrift_spec = (
25502 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25503 
  )
25504 
 
25505 
  def __init__(self, success=None,):
25506 
    self.success = success
25507 
 
25508 
  def read(self, iprot):
25509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25511 
      return
25512 
    iprot.readStructBegin()
25513 
    while True:
25514 
      (fname, ftype, fid) = iprot.readFieldBegin()
25515 
      if ftype == TType.STOP:
25516 
        break
25517 
      if fid == 0:
25518 
        if ftype == TType.LIST:
25519 
          self.success = []
6188 rajveer 25520 
          (_etype638, _size635) = iprot.readListBegin()
25521 
          for _i639 in xrange(_size635):
25522 
            _elem640 = Order()
25523 
            _elem640.read(iprot)
25524 
            self.success.append(_elem640)
5553 rajveer 25525 
          iprot.readListEnd()
25526 
        else:
25527 
          iprot.skip(ftype)
25528 
      else:
25529 
        iprot.skip(ftype)
25530 
      iprot.readFieldEnd()
25531 
    iprot.readStructEnd()
25532 
 
25533 
  def write(self, oprot):
25534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25536 
      return
25537 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25538 
    if self.success is not None:
25539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25540 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25541 
      for iter641 in self.success:
25542 
        iter641.write(oprot)
5553 rajveer 25543 
      oprot.writeListEnd()
25544 
      oprot.writeFieldEnd()
25545 
    oprot.writeFieldStop()
25546 
    oprot.writeStructEnd()
25547 
 
25548 
  def validate(self):
25549 
    return
25550 
 
25551 
 
25552 
  def __repr__(self):
25553 
    L = ['%s=%r' % (key, value)
25554 
      for key, value in self.__dict__.iteritems()]
25555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25556 
 
25557 
  def __eq__(self, other):
25558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25559 
 
25560 
  def __ne__(self, other):
25561 
    return not (self == other)
25562 
 
25563 
class getReceivedAtStoreOrders_args:
25564 
  """
25565 
  Attributes:
25566 
   - storeId
25567 
  """
25568 
 
25569 
  thrift_spec = (
25570 
    None, # 0
25571 
    (1, TType.I64, 'storeId', None, None, ), # 1
25572 
  )
25573 
 
25574 
  def __init__(self, storeId=None,):
25575 
    self.storeId = storeId
25576 
 
25577 
  def read(self, iprot):
25578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25580 
      return
25581 
    iprot.readStructBegin()
25582 
    while True:
25583 
      (fname, ftype, fid) = iprot.readFieldBegin()
25584 
      if ftype == TType.STOP:
25585 
        break
25586 
      if fid == 1:
25587 
        if ftype == TType.I64:
25588 
          self.storeId = iprot.readI64();
25589 
        else:
25590 
          iprot.skip(ftype)
25591 
      else:
25592 
        iprot.skip(ftype)
25593 
      iprot.readFieldEnd()
25594 
    iprot.readStructEnd()
25595 
 
25596 
  def write(self, oprot):
25597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25599 
      return
25600 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25601 
    if self.storeId is not None:
25602 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25603 
      oprot.writeI64(self.storeId)
25604 
      oprot.writeFieldEnd()
25605 
    oprot.writeFieldStop()
25606 
    oprot.writeStructEnd()
25607 
 
25608 
  def validate(self):
25609 
    return
25610 
 
25611 
 
25612 
  def __repr__(self):
25613 
    L = ['%s=%r' % (key, value)
25614 
      for key, value in self.__dict__.iteritems()]
25615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25616 
 
25617 
  def __eq__(self, other):
25618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25619 
 
25620 
  def __ne__(self, other):
25621 
    return not (self == other)
25622 
 
25623 
class getReceivedAtStoreOrders_result:
25624 
  """
25625 
  Attributes:
25626 
   - success
25627 
  """
25628 
 
25629 
  thrift_spec = (
25630 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25631 
  )
25632 
 
25633 
  def __init__(self, success=None,):
25634 
    self.success = success
25635 
 
25636 
  def read(self, iprot):
25637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25639 
      return
25640 
    iprot.readStructBegin()
25641 
    while True:
25642 
      (fname, ftype, fid) = iprot.readFieldBegin()
25643 
      if ftype == TType.STOP:
25644 
        break
25645 
      if fid == 0:
25646 
        if ftype == TType.LIST:
25647 
          self.success = []
6188 rajveer 25648 
          (_etype645, _size642) = iprot.readListBegin()
25649 
          for _i646 in xrange(_size642):
25650 
            _elem647 = Order()
25651 
            _elem647.read(iprot)
25652 
            self.success.append(_elem647)
5553 rajveer 25653 
          iprot.readListEnd()
25654 
        else:
25655 
          iprot.skip(ftype)
25656 
      else:
25657 
        iprot.skip(ftype)
25658 
      iprot.readFieldEnd()
25659 
    iprot.readStructEnd()
25660 
 
25661 
  def write(self, oprot):
25662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25664 
      return
25665 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25666 
    if self.success is not None:
25667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25669 
      for iter648 in self.success:
25670 
        iter648.write(oprot)
5553 rajveer 25671 
      oprot.writeListEnd()
25672 
      oprot.writeFieldEnd()
25673 
    oprot.writeFieldStop()
25674 
    oprot.writeStructEnd()
25675 
 
25676 
  def validate(self):
25677 
    return
25678 
 
25679 
 
25680 
  def __repr__(self):
25681 
    L = ['%s=%r' % (key, value)
25682 
      for key, value in self.__dict__.iteritems()]
25683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25684 
 
25685 
  def __eq__(self, other):
25686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25687 
 
25688 
  def __ne__(self, other):
25689 
    return not (self == other)
5593 mandeep.dh 25690 
 
5713 rajveer 25691 
class getOrdersCollectionAtStore_args:
25692 
  """
25693 
  Attributes:
25694 
   - storeId
25695 
   - fromDate
25696 
   - toDate
25697 
   - onlyCod
25698 
  """
25699 
 
25700 
  thrift_spec = (
25701 
    None, # 0
25702 
    (1, TType.I64, 'storeId', None, None, ), # 1
25703 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25704 
    (3, TType.I64, 'toDate', None, None, ), # 3
25705 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25706 
  )
25707 
 
25708 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25709 
    self.storeId = storeId
25710 
    self.fromDate = fromDate
25711 
    self.toDate = toDate
25712 
    self.onlyCod = onlyCod
25713 
 
25714 
  def read(self, iprot):
25715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25717 
      return
25718 
    iprot.readStructBegin()
25719 
    while True:
25720 
      (fname, ftype, fid) = iprot.readFieldBegin()
25721 
      if ftype == TType.STOP:
25722 
        break
25723 
      if fid == 1:
25724 
        if ftype == TType.I64:
25725 
          self.storeId = iprot.readI64();
25726 
        else:
25727 
          iprot.skip(ftype)
25728 
      elif fid == 2:
25729 
        if ftype == TType.I64:
25730 
          self.fromDate = iprot.readI64();
25731 
        else:
25732 
          iprot.skip(ftype)
25733 
      elif fid == 3:
25734 
        if ftype == TType.I64:
25735 
          self.toDate = iprot.readI64();
25736 
        else:
25737 
          iprot.skip(ftype)
25738 
      elif fid == 4:
25739 
        if ftype == TType.BOOL:
25740 
          self.onlyCod = iprot.readBool();
25741 
        else:
25742 
          iprot.skip(ftype)
25743 
      else:
25744 
        iprot.skip(ftype)
25745 
      iprot.readFieldEnd()
25746 
    iprot.readStructEnd()
25747 
 
25748 
  def write(self, oprot):
25749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25751 
      return
25752 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25753 
    if self.storeId is not None:
25754 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25755 
      oprot.writeI64(self.storeId)
25756 
      oprot.writeFieldEnd()
25757 
    if self.fromDate is not None:
25758 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25759 
      oprot.writeI64(self.fromDate)
25760 
      oprot.writeFieldEnd()
25761 
    if self.toDate is not None:
25762 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25763 
      oprot.writeI64(self.toDate)
25764 
      oprot.writeFieldEnd()
25765 
    if self.onlyCod is not None:
25766 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25767 
      oprot.writeBool(self.onlyCod)
25768 
      oprot.writeFieldEnd()
25769 
    oprot.writeFieldStop()
25770 
    oprot.writeStructEnd()
25771 
 
25772 
  def validate(self):
25773 
    return
25774 
 
25775 
 
25776 
  def __repr__(self):
25777 
    L = ['%s=%r' % (key, value)
25778 
      for key, value in self.__dict__.iteritems()]
25779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25780 
 
25781 
  def __eq__(self, other):
25782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25783 
 
25784 
  def __ne__(self, other):
25785 
    return not (self == other)
25786 
 
25787 
class getOrdersCollectionAtStore_result:
25788 
  """
25789 
  Attributes:
25790 
   - success
25791 
  """
25792 
 
25793 
  thrift_spec = (
25794 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25795 
  )
25796 
 
25797 
  def __init__(self, success=None,):
25798 
    self.success = success
25799 
 
25800 
  def read(self, iprot):
25801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25803 
      return
25804 
    iprot.readStructBegin()
25805 
    while True:
25806 
      (fname, ftype, fid) = iprot.readFieldBegin()
25807 
      if ftype == TType.STOP:
25808 
        break
25809 
      if fid == 0:
25810 
        if ftype == TType.LIST:
25811 
          self.success = []
6188 rajveer 25812 
          (_etype652, _size649) = iprot.readListBegin()
25813 
          for _i653 in xrange(_size649):
25814 
            _elem654 = Order()
25815 
            _elem654.read(iprot)
25816 
            self.success.append(_elem654)
5713 rajveer 25817 
          iprot.readListEnd()
25818 
        else:
25819 
          iprot.skip(ftype)
25820 
      else:
25821 
        iprot.skip(ftype)
25822 
      iprot.readFieldEnd()
25823 
    iprot.readStructEnd()
25824 
 
25825 
  def write(self, oprot):
25826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25828 
      return
25829 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25830 
    if self.success is not None:
25831 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25832 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25833 
      for iter655 in self.success:
25834 
        iter655.write(oprot)
5713 rajveer 25835 
      oprot.writeListEnd()
25836 
      oprot.writeFieldEnd()
25837 
    oprot.writeFieldStop()
25838 
    oprot.writeStructEnd()
25839 
 
25840 
  def validate(self):
25841 
    return
25842 
 
25843 
 
25844 
  def __repr__(self):
25845 
    L = ['%s=%r' % (key, value)
25846 
      for key, value in self.__dict__.iteritems()]
25847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25848 
 
25849 
  def __eq__(self, other):
25850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25851 
 
25852 
  def __ne__(self, other):
25853 
    return not (self == other)
25854 
 
5833 rajveer 25855 
class getOrderAttributeValue_args:
25856 
  """
25857 
  Attributes:
25858 
   - orderId
25859 
   - attributeName
25860 
  """
25861 
 
25862 
  thrift_spec = None
25863 
  def __init__(self, orderId=None, attributeName=None,):
25864 
    self.orderId = orderId
25865 
    self.attributeName = attributeName
25866 
 
25867 
  def read(self, iprot):
25868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25870 
      return
25871 
    iprot.readStructBegin()
25872 
    while True:
25873 
      (fname, ftype, fid) = iprot.readFieldBegin()
25874 
      if ftype == TType.STOP:
25875 
        break
25876 
      if fid == 1:
25877 
        if ftype == TType.I64:
25878 
          self.orderId = iprot.readI64();
25879 
        else:
25880 
          iprot.skip(ftype)
25881 
      elif fid == -1:
25882 
        if ftype == TType.STRING:
25883 
          self.attributeName = iprot.readString();
25884 
        else:
25885 
          iprot.skip(ftype)
25886 
      else:
25887 
        iprot.skip(ftype)
25888 
      iprot.readFieldEnd()
25889 
    iprot.readStructEnd()
25890 
 
25891 
  def write(self, oprot):
25892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25894 
      return
25895 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25896 
    if self.attributeName is not None:
25897 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25898 
      oprot.writeString(self.attributeName)
25899 
      oprot.writeFieldEnd()
25900 
    if self.orderId is not None:
25901 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25902 
      oprot.writeI64(self.orderId)
25903 
      oprot.writeFieldEnd()
25904 
    oprot.writeFieldStop()
25905 
    oprot.writeStructEnd()
25906 
 
25907 
  def validate(self):
25908 
    return
25909 
 
25910 
 
25911 
  def __repr__(self):
25912 
    L = ['%s=%r' % (key, value)
25913 
      for key, value in self.__dict__.iteritems()]
25914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25915 
 
25916 
  def __eq__(self, other):
25917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25918 
 
25919 
  def __ne__(self, other):
25920 
    return not (self == other)
25921 
 
25922 
class getOrderAttributeValue_result:
25923 
  """
25924 
  Attributes:
25925 
   - success
25926 
  """
25927 
 
25928 
  thrift_spec = (
25929 
    (0, TType.STRING, 'success', None, None, ), # 0
25930 
  )
25931 
 
25932 
  def __init__(self, success=None,):
25933 
    self.success = success
25934 
 
25935 
  def read(self, iprot):
25936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25938 
      return
25939 
    iprot.readStructBegin()
25940 
    while True:
25941 
      (fname, ftype, fid) = iprot.readFieldBegin()
25942 
      if ftype == TType.STOP:
25943 
        break
25944 
      if fid == 0:
25945 
        if ftype == TType.STRING:
25946 
          self.success = iprot.readString();
25947 
        else:
25948 
          iprot.skip(ftype)
25949 
      else:
25950 
        iprot.skip(ftype)
25951 
      iprot.readFieldEnd()
25952 
    iprot.readStructEnd()
25953 
 
25954 
  def write(self, oprot):
25955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25957 
      return
25958 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25959 
    if self.success is not None:
25960 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25961 
      oprot.writeString(self.success)
25962 
      oprot.writeFieldEnd()
25963 
    oprot.writeFieldStop()
25964 
    oprot.writeStructEnd()
25965 
 
25966 
  def validate(self):
25967 
    return
25968 
 
25969 
 
25970 
  def __repr__(self):
25971 
    L = ['%s=%r' % (key, value)
25972 
      for key, value in self.__dict__.iteritems()]
25973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25974 
 
25975 
  def __eq__(self, other):
25976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25977 
 
25978 
  def __ne__(self, other):
25979 
    return not (self == other)
25980 
 
6019 rajveer 25981 
class changeJacketNumber_args:
25982 
  """
25983 
  Attributes:
25984 
   - orderId
25985 
   - jacketNumber
25986 
  """
25987 
 
25988 
  thrift_spec = (
25989 
    None, # 0
25990 
    (1, TType.I64, 'orderId', None, None, ), # 1
25991 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25992 
  )
25993 
 
25994 
  def __init__(self, orderId=None, jacketNumber=None,):
25995 
    self.orderId = orderId
25996 
    self.jacketNumber = jacketNumber
25997 
 
25998 
  def read(self, iprot):
25999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26001 
      return
26002 
    iprot.readStructBegin()
26003 
    while True:
26004 
      (fname, ftype, fid) = iprot.readFieldBegin()
26005 
      if ftype == TType.STOP:
26006 
        break
26007 
      if fid == 1:
26008 
        if ftype == TType.I64:
26009 
          self.orderId = iprot.readI64();
26010 
        else:
26011 
          iprot.skip(ftype)
26012 
      elif fid == 2:
26013 
        if ftype == TType.I64:
26014 
          self.jacketNumber = iprot.readI64();
26015 
        else:
26016 
          iprot.skip(ftype)
26017 
      else:
26018 
        iprot.skip(ftype)
26019 
      iprot.readFieldEnd()
26020 
    iprot.readStructEnd()
26021 
 
26022 
  def write(self, oprot):
26023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26025 
      return
26026 
    oprot.writeStructBegin('changeJacketNumber_args')
26027 
    if self.orderId is not None:
26028 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26029 
      oprot.writeI64(self.orderId)
26030 
      oprot.writeFieldEnd()
26031 
    if self.jacketNumber is not None:
26032 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26033 
      oprot.writeI64(self.jacketNumber)
26034 
      oprot.writeFieldEnd()
26035 
    oprot.writeFieldStop()
26036 
    oprot.writeStructEnd()
26037 
 
26038 
  def validate(self):
26039 
    return
26040 
 
26041 
 
26042 
  def __repr__(self):
26043 
    L = ['%s=%r' % (key, value)
26044 
      for key, value in self.__dict__.iteritems()]
26045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26046 
 
26047 
  def __eq__(self, other):
26048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26049 
 
26050 
  def __ne__(self, other):
26051 
    return not (self == other)
26052 
 
26053 
class changeJacketNumber_result:
26054 
  """
26055 
  Attributes:
26056 
   - success
26057 
  """
26058 
 
26059 
  thrift_spec = (
26060 
    (0, TType.BOOL, 'success', None, None, ), # 0
26061 
  )
26062 
 
26063 
  def __init__(self, success=None,):
26064 
    self.success = success
26065 
 
26066 
  def read(self, iprot):
26067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26069 
      return
26070 
    iprot.readStructBegin()
26071 
    while True:
26072 
      (fname, ftype, fid) = iprot.readFieldBegin()
26073 
      if ftype == TType.STOP:
26074 
        break
26075 
      if fid == 0:
26076 
        if ftype == TType.BOOL:
26077 
          self.success = iprot.readBool();
26078 
        else:
26079 
          iprot.skip(ftype)
26080 
      else:
26081 
        iprot.skip(ftype)
26082 
      iprot.readFieldEnd()
26083 
    iprot.readStructEnd()
26084 
 
26085 
  def write(self, oprot):
26086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26088 
      return
26089 
    oprot.writeStructBegin('changeJacketNumber_result')
26090 
    if self.success is not None:
26091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26092 
      oprot.writeBool(self.success)
26093 
      oprot.writeFieldEnd()
26094 
    oprot.writeFieldStop()
26095 
    oprot.writeStructEnd()
26096 
 
26097 
  def validate(self):
26098 
    return
26099 
 
26100 
 
26101 
  def __repr__(self):
26102 
    L = ['%s=%r' % (key, value)
26103 
      for key, value in self.__dict__.iteritems()]
26104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26105 
 
26106 
  def __eq__(self, other):
26107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26108 
 
26109 
  def __ne__(self, other):
26110 
    return not (self == other)
26111 
 
26112 
class markOrderAsRtoInTransit_args:
26113 
  """
26114 
  Attributes:
26115 
   - orderId
26116 
  """
26117 
 
26118 
  thrift_spec = (
26119 
    None, # 0
26120 
    (1, TType.I64, 'orderId', None, None, ), # 1
26121 
  )
26122 
 
26123 
  def __init__(self, orderId=None,):
26124 
    self.orderId = orderId
26125 
 
26126 
  def read(self, iprot):
26127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26129 
      return
26130 
    iprot.readStructBegin()
26131 
    while True:
26132 
      (fname, ftype, fid) = iprot.readFieldBegin()
26133 
      if ftype == TType.STOP:
26134 
        break
26135 
      if fid == 1:
26136 
        if ftype == TType.I64:
26137 
          self.orderId = iprot.readI64();
26138 
        else:
26139 
          iprot.skip(ftype)
26140 
      else:
26141 
        iprot.skip(ftype)
26142 
      iprot.readFieldEnd()
26143 
    iprot.readStructEnd()
26144 
 
26145 
  def write(self, oprot):
26146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26148 
      return
26149 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26150 
    if self.orderId is not None:
26151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26152 
      oprot.writeI64(self.orderId)
26153 
      oprot.writeFieldEnd()
26154 
    oprot.writeFieldStop()
26155 
    oprot.writeStructEnd()
26156 
 
26157 
  def validate(self):
26158 
    return
26159 
 
26160 
 
26161 
  def __repr__(self):
26162 
    L = ['%s=%r' % (key, value)
26163 
      for key, value in self.__dict__.iteritems()]
26164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26165 
 
26166 
  def __eq__(self, other):
26167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26168 
 
26169 
  def __ne__(self, other):
26170 
    return not (self == other)
26171 
 
26172 
class markOrderAsRtoInTransit_result:
26173 
  """
26174 
  Attributes:
26175 
   - success
26176 
  """
26177 
 
26178 
  thrift_spec = (
26179 
    (0, TType.BOOL, 'success', None, None, ), # 0
26180 
  )
26181 
 
26182 
  def __init__(self, success=None,):
26183 
    self.success = success
26184 
 
26185 
  def read(self, iprot):
26186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26188 
      return
26189 
    iprot.readStructBegin()
26190 
    while True:
26191 
      (fname, ftype, fid) = iprot.readFieldBegin()
26192 
      if ftype == TType.STOP:
26193 
        break
26194 
      if fid == 0:
26195 
        if ftype == TType.BOOL:
26196 
          self.success = iprot.readBool();
26197 
        else:
26198 
          iprot.skip(ftype)
26199 
      else:
26200 
        iprot.skip(ftype)
26201 
      iprot.readFieldEnd()
26202 
    iprot.readStructEnd()
26203 
 
26204 
  def write(self, oprot):
26205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26207 
      return
26208 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26209 
    if self.success is not None:
26210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26211 
      oprot.writeBool(self.success)
26212 
      oprot.writeFieldEnd()
26213 
    oprot.writeFieldStop()
26214 
    oprot.writeStructEnd()
26215 
 
26216 
  def validate(self):
26217 
    return
26218 
 
26219 
 
26220 
  def __repr__(self):
26221 
    L = ['%s=%r' % (key, value)
26222 
      for key, value in self.__dict__.iteritems()]
26223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26224 
 
26225 
  def __eq__(self, other):
26226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26227 
 
26228 
  def __ne__(self, other):
26229 
    return not (self == other)
26230 
 
5593 mandeep.dh 26231 
class acceptOrderForItem_args:
26232 
  """
26233 
  Attributes:
26234 
   - itemId
26235 
   - quantity
26236 
   - fulfilmentWarehouseId
26237 
   - billingWarehouseId
26238 
  """
26239 
 
26240 
  thrift_spec = (
26241 
    None, # 0
26242 
    (1, TType.I64, 'itemId', None, None, ), # 1
26243 
    (2, TType.I64, 'quantity', None, None, ), # 2
26244 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26245 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26246 
  )
26247 
 
26248 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26249 
    self.itemId = itemId
26250 
    self.quantity = quantity
26251 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26252 
    self.billingWarehouseId = billingWarehouseId
26253 
 
26254 
  def read(self, iprot):
26255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26257 
      return
26258 
    iprot.readStructBegin()
26259 
    while True:
26260 
      (fname, ftype, fid) = iprot.readFieldBegin()
26261 
      if ftype == TType.STOP:
26262 
        break
26263 
      if fid == 1:
26264 
        if ftype == TType.I64:
26265 
          self.itemId = iprot.readI64();
26266 
        else:
26267 
          iprot.skip(ftype)
26268 
      elif fid == 2:
26269 
        if ftype == TType.I64:
26270 
          self.quantity = iprot.readI64();
26271 
        else:
26272 
          iprot.skip(ftype)
26273 
      elif fid == 3:
26274 
        if ftype == TType.I64:
26275 
          self.fulfilmentWarehouseId = iprot.readI64();
26276 
        else:
26277 
          iprot.skip(ftype)
26278 
      elif fid == 4:
26279 
        if ftype == TType.I64:
26280 
          self.billingWarehouseId = iprot.readI64();
26281 
        else:
26282 
          iprot.skip(ftype)
26283 
      else:
26284 
        iprot.skip(ftype)
26285 
      iprot.readFieldEnd()
26286 
    iprot.readStructEnd()
26287 
 
26288 
  def write(self, oprot):
26289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26291 
      return
26292 
    oprot.writeStructBegin('acceptOrderForItem_args')
26293 
    if self.itemId is not None:
26294 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26295 
      oprot.writeI64(self.itemId)
26296 
      oprot.writeFieldEnd()
26297 
    if self.quantity is not None:
26298 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26299 
      oprot.writeI64(self.quantity)
26300 
      oprot.writeFieldEnd()
26301 
    if self.fulfilmentWarehouseId is not None:
26302 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26303 
      oprot.writeI64(self.fulfilmentWarehouseId)
26304 
      oprot.writeFieldEnd()
26305 
    if self.billingWarehouseId is not None:
26306 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26307 
      oprot.writeI64(self.billingWarehouseId)
26308 
      oprot.writeFieldEnd()
26309 
    oprot.writeFieldStop()
26310 
    oprot.writeStructEnd()
26311 
 
26312 
  def validate(self):
26313 
    return
26314 
 
26315 
 
26316 
  def __repr__(self):
26317 
    L = ['%s=%r' % (key, value)
26318 
      for key, value in self.__dict__.iteritems()]
26319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26320 
 
26321 
  def __eq__(self, other):
26322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26323 
 
26324 
  def __ne__(self, other):
26325 
    return not (self == other)
26326 
 
26327 
class acceptOrderForItem_result:
26328 
 
26329 
  thrift_spec = (
26330 
  )
26331 
 
26332 
  def read(self, iprot):
26333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26335 
      return
26336 
    iprot.readStructBegin()
26337 
    while True:
26338 
      (fname, ftype, fid) = iprot.readFieldBegin()
26339 
      if ftype == TType.STOP:
26340 
        break
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('acceptOrderForItem_result')
26351 
    oprot.writeFieldStop()
26352 
    oprot.writeStructEnd()
26353 
 
26354 
  def validate(self):
26355 
    return
26356 
 
26357 
 
26358 
  def __repr__(self):
26359 
    L = ['%s=%r' % (key, value)
26360 
      for key, value in self.__dict__.iteritems()]
26361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26362 
 
26363 
  def __eq__(self, other):
26364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26365 
 
26366 
  def __ne__(self, other):
26367 
    return not (self == other)
6000 mandeep.dh 26368 
 
26369 
class createRechargeOrder_args:
26370 
  """
26371 
  Attributes:
26372 
   - rechargeOrder
26373 
  """
26374 
 
26375 
  thrift_spec = (
26376 
    None, # 0
26377 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26378 
  )
26379 
 
26380 
  def __init__(self, rechargeOrder=None,):
26381 
    self.rechargeOrder = rechargeOrder
26382 
 
26383 
  def read(self, iprot):
26384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26386 
      return
26387 
    iprot.readStructBegin()
26388 
    while True:
26389 
      (fname, ftype, fid) = iprot.readFieldBegin()
26390 
      if ftype == TType.STOP:
26391 
        break
26392 
      if fid == 1:
26393 
        if ftype == TType.STRUCT:
26394 
          self.rechargeOrder = RechargeOrder()
26395 
          self.rechargeOrder.read(iprot)
26396 
        else:
26397 
          iprot.skip(ftype)
26398 
      else:
26399 
        iprot.skip(ftype)
26400 
      iprot.readFieldEnd()
26401 
    iprot.readStructEnd()
26402 
 
26403 
  def write(self, oprot):
26404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26406 
      return
26407 
    oprot.writeStructBegin('createRechargeOrder_args')
26408 
    if self.rechargeOrder is not None:
26409 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26410 
      self.rechargeOrder.write(oprot)
26411 
      oprot.writeFieldEnd()
26412 
    oprot.writeFieldStop()
26413 
    oprot.writeStructEnd()
26414 
 
26415 
  def validate(self):
26416 
    return
26417 
 
26418 
 
26419 
  def __repr__(self):
26420 
    L = ['%s=%r' % (key, value)
26421 
      for key, value in self.__dict__.iteritems()]
26422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26423 
 
26424 
  def __eq__(self, other):
26425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26426 
 
26427 
  def __ne__(self, other):
26428 
    return not (self == other)
26429 
 
26430 
class createRechargeOrder_result:
26431 
  """
26432 
  Attributes:
26433 
   - success
26434 
   - ex
26435 
  """
26436 
 
26437 
  thrift_spec = (
26438 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26439 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26440 
  )
26441 
 
26442 
  def __init__(self, success=None, ex=None,):
26443 
    self.success = success
26444 
    self.ex = ex
26445 
 
26446 
  def read(self, iprot):
26447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26449 
      return
26450 
    iprot.readStructBegin()
26451 
    while True:
26452 
      (fname, ftype, fid) = iprot.readFieldBegin()
26453 
      if ftype == TType.STOP:
26454 
        break
26455 
      if fid == 0:
26456 
        if ftype == TType.STRUCT:
26457 
          self.success = RechargeOrder()
26458 
          self.success.read(iprot)
26459 
        else:
26460 
          iprot.skip(ftype)
26461 
      elif fid == 1:
26462 
        if ftype == TType.STRUCT:
26463 
          self.ex = TransactionServiceException()
26464 
          self.ex.read(iprot)
26465 
        else:
26466 
          iprot.skip(ftype)
26467 
      else:
26468 
        iprot.skip(ftype)
26469 
      iprot.readFieldEnd()
26470 
    iprot.readStructEnd()
26471 
 
26472 
  def write(self, oprot):
26473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26475 
      return
26476 
    oprot.writeStructBegin('createRechargeOrder_result')
26477 
    if self.success is not None:
26478 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26479 
      self.success.write(oprot)
26480 
      oprot.writeFieldEnd()
26481 
    if self.ex is not None:
26482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26483 
      self.ex.write(oprot)
26484 
      oprot.writeFieldEnd()
26485 
    oprot.writeFieldStop()
26486 
    oprot.writeStructEnd()
26487 
 
26488 
  def validate(self):
26489 
    return
26490 
 
26491 
 
26492 
  def __repr__(self):
26493 
    L = ['%s=%r' % (key, value)
26494 
      for key, value in self.__dict__.iteritems()]
26495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26496 
 
26497 
  def __eq__(self, other):
26498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26499 
 
26500 
  def __ne__(self, other):
26501 
    return not (self == other)
26502 
 
6031 rajveer 26503 
class getRechargeOrder_args:
26504 
  """
26505 
  Attributes:
26506 
   - rechargeRrderId
26507 
  """
26508 
 
26509 
  thrift_spec = (
26510 
    None, # 0
26511 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26512 
  )
26513 
 
26514 
  def __init__(self, rechargeRrderId=None,):
26515 
    self.rechargeRrderId = rechargeRrderId
26516 
 
26517 
  def read(self, iprot):
26518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26520 
      return
26521 
    iprot.readStructBegin()
26522 
    while True:
26523 
      (fname, ftype, fid) = iprot.readFieldBegin()
26524 
      if ftype == TType.STOP:
26525 
        break
26526 
      if fid == 1:
26527 
        if ftype == TType.I64:
26528 
          self.rechargeRrderId = iprot.readI64();
26529 
        else:
26530 
          iprot.skip(ftype)
26531 
      else:
26532 
        iprot.skip(ftype)
26533 
      iprot.readFieldEnd()
26534 
    iprot.readStructEnd()
26535 
 
26536 
  def write(self, oprot):
26537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26539 
      return
26540 
    oprot.writeStructBegin('getRechargeOrder_args')
26541 
    if self.rechargeRrderId is not None:
26542 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26543 
      oprot.writeI64(self.rechargeRrderId)
26544 
      oprot.writeFieldEnd()
26545 
    oprot.writeFieldStop()
26546 
    oprot.writeStructEnd()
26547 
 
26548 
  def validate(self):
26549 
    return
26550 
 
26551 
 
26552 
  def __repr__(self):
26553 
    L = ['%s=%r' % (key, value)
26554 
      for key, value in self.__dict__.iteritems()]
26555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26556 
 
26557 
  def __eq__(self, other):
26558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26559 
 
26560 
  def __ne__(self, other):
26561 
    return not (self == other)
26562 
 
26563 
class getRechargeOrder_result:
26564 
  """
26565 
  Attributes:
26566 
   - success
26567 
   - ex
26568 
  """
26569 
 
26570 
  thrift_spec = (
26571 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26573 
  )
26574 
 
26575 
  def __init__(self, success=None, ex=None,):
26576 
    self.success = success
26577 
    self.ex = ex
26578 
 
26579 
  def read(self, iprot):
26580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26582 
      return
26583 
    iprot.readStructBegin()
26584 
    while True:
26585 
      (fname, ftype, fid) = iprot.readFieldBegin()
26586 
      if ftype == TType.STOP:
26587 
        break
26588 
      if fid == 0:
26589 
        if ftype == TType.STRUCT:
26590 
          self.success = RechargeOrder()
26591 
          self.success.read(iprot)
26592 
        else:
26593 
          iprot.skip(ftype)
26594 
      elif fid == 1:
26595 
        if ftype == TType.STRUCT:
26596 
          self.ex = TransactionServiceException()
26597 
          self.ex.read(iprot)
26598 
        else:
26599 
          iprot.skip(ftype)
26600 
      else:
26601 
        iprot.skip(ftype)
26602 
      iprot.readFieldEnd()
26603 
    iprot.readStructEnd()
26604 
 
26605 
  def write(self, oprot):
26606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26608 
      return
26609 
    oprot.writeStructBegin('getRechargeOrder_result')
26610 
    if self.success is not None:
26611 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26612 
      self.success.write(oprot)
26613 
      oprot.writeFieldEnd()
26614 
    if self.ex is not None:
26615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26616 
      self.ex.write(oprot)
26617 
      oprot.writeFieldEnd()
26618 
    oprot.writeFieldStop()
26619 
    oprot.writeStructEnd()
26620 
 
26621 
  def validate(self):
26622 
    return
26623 
 
26624 
 
26625 
  def __repr__(self):
26626 
    L = ['%s=%r' % (key, value)
26627 
      for key, value in self.__dict__.iteritems()]
26628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26629 
 
26630 
  def __eq__(self, other):
26631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26632 
 
26633 
  def __ne__(self, other):
26634 
    return not (self == other)
26635 
 
26636 
class getRechargeOrders_args:
26637 
  """
26638 
  Attributes:
26639 
   - userId
26640 
  """
26641 
 
26642 
  thrift_spec = (
26643 
    None, # 0
26644 
    (1, TType.I64, 'userId', None, None, ), # 1
26645 
  )
26646 
 
26647 
  def __init__(self, userId=None,):
26648 
    self.userId = userId
26649 
 
26650 
  def read(self, iprot):
26651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26653 
      return
26654 
    iprot.readStructBegin()
26655 
    while True:
26656 
      (fname, ftype, fid) = iprot.readFieldBegin()
26657 
      if ftype == TType.STOP:
26658 
        break
26659 
      if fid == 1:
26660 
        if ftype == TType.I64:
26661 
          self.userId = iprot.readI64();
26662 
        else:
26663 
          iprot.skip(ftype)
26664 
      else:
26665 
        iprot.skip(ftype)
26666 
      iprot.readFieldEnd()
26667 
    iprot.readStructEnd()
26668 
 
26669 
  def write(self, oprot):
26670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26672 
      return
26673 
    oprot.writeStructBegin('getRechargeOrders_args')
26674 
    if self.userId is not None:
26675 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26676 
      oprot.writeI64(self.userId)
26677 
      oprot.writeFieldEnd()
26678 
    oprot.writeFieldStop()
26679 
    oprot.writeStructEnd()
26680 
 
26681 
  def validate(self):
26682 
    return
26683 
 
26684 
 
26685 
  def __repr__(self):
26686 
    L = ['%s=%r' % (key, value)
26687 
      for key, value in self.__dict__.iteritems()]
26688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26689 
 
26690 
  def __eq__(self, other):
26691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26692 
 
26693 
  def __ne__(self, other):
26694 
    return not (self == other)
26695 
 
26696 
class getRechargeOrders_result:
26697 
  """
26698 
  Attributes:
26699 
   - success
26700 
  """
26701 
 
26702 
  thrift_spec = (
26703 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26704 
  )
26705 
 
26706 
  def __init__(self, success=None,):
26707 
    self.success = success
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 == 0:
26719 
        if ftype == TType.LIST:
26720 
          self.success = []
6188 rajveer 26721 
          (_etype659, _size656) = iprot.readListBegin()
26722 
          for _i660 in xrange(_size656):
26723 
            _elem661 = RechargeOrder()
26724 
            _elem661.read(iprot)
26725 
            self.success.append(_elem661)
6031 rajveer 26726 
          iprot.readListEnd()
26727 
        else:
26728 
          iprot.skip(ftype)
26729 
      else:
26730 
        iprot.skip(ftype)
26731 
      iprot.readFieldEnd()
26732 
    iprot.readStructEnd()
26733 
 
26734 
  def write(self, oprot):
26735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26737 
      return
26738 
    oprot.writeStructBegin('getRechargeOrders_result')
26739 
    if self.success is not None:
26740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26742 
      for iter662 in self.success:
26743 
        iter662.write(oprot)
6031 rajveer 26744 
      oprot.writeListEnd()
26745 
      oprot.writeFieldEnd()
26746 
    oprot.writeFieldStop()
26747 
    oprot.writeStructEnd()
26748 
 
26749 
  def validate(self):
26750 
    return
26751 
 
26752 
 
26753 
  def __repr__(self):
26754 
    L = ['%s=%r' % (key, value)
26755 
      for key, value in self.__dict__.iteritems()]
26756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26757 
 
26758 
  def __eq__(self, other):
26759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26760 
 
26761 
  def __ne__(self, other):
26762 
    return not (self == other)
26763 
 
6000 mandeep.dh 26764 
class updateRechargeOrderStatus_args:
26765 
  """
26766 
  Attributes:
26767 
   - rechargeOrderId
26768 
   - rechargeOrderStatus
26769 
  """
26770 
 
26771 
  thrift_spec = (
26772 
    None, # 0
26773 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26774 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26775 
  )
26776 
 
26777 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26778 
    self.rechargeOrderId = rechargeOrderId
26779 
    self.rechargeOrderStatus = rechargeOrderStatus
26780 
 
26781 
  def read(self, iprot):
26782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26784 
      return
26785 
    iprot.readStructBegin()
26786 
    while True:
26787 
      (fname, ftype, fid) = iprot.readFieldBegin()
26788 
      if ftype == TType.STOP:
26789 
        break
26790 
      if fid == 1:
26791 
        if ftype == TType.I64:
26792 
          self.rechargeOrderId = iprot.readI64();
26793 
        else:
26794 
          iprot.skip(ftype)
26795 
      elif fid == 2:
26796 
        if ftype == TType.I32:
26797 
          self.rechargeOrderStatus = iprot.readI32();
26798 
        else:
26799 
          iprot.skip(ftype)
26800 
      else:
26801 
        iprot.skip(ftype)
26802 
      iprot.readFieldEnd()
26803 
    iprot.readStructEnd()
26804 
 
26805 
  def write(self, oprot):
26806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26808 
      return
26809 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26810 
    if self.rechargeOrderId is not None:
26811 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26812 
      oprot.writeI64(self.rechargeOrderId)
26813 
      oprot.writeFieldEnd()
26814 
    if self.rechargeOrderStatus is not None:
26815 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26816 
      oprot.writeI32(self.rechargeOrderStatus)
26817 
      oprot.writeFieldEnd()
26818 
    oprot.writeFieldStop()
26819 
    oprot.writeStructEnd()
26820 
 
26821 
  def validate(self):
26822 
    return
26823 
 
26824 
 
26825 
  def __repr__(self):
26826 
    L = ['%s=%r' % (key, value)
26827 
      for key, value in self.__dict__.iteritems()]
26828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26829 
 
26830 
  def __eq__(self, other):
26831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26832 
 
26833 
  def __ne__(self, other):
26834 
    return not (self == other)
26835 
 
26836 
class updateRechargeOrderStatus_result:
26837 
  """
26838 
  Attributes:
6031 rajveer 26839 
   - success
6000 mandeep.dh 26840 
   - ex
26841 
  """
26842 
 
26843 
  thrift_spec = (
6031 rajveer 26844 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26846 
  )
26847 
 
6031 rajveer 26848 
  def __init__(self, success=None, ex=None,):
26849 
    self.success = success
6000 mandeep.dh 26850 
    self.ex = ex
26851 
 
26852 
  def read(self, iprot):
26853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26855 
      return
26856 
    iprot.readStructBegin()
26857 
    while True:
26858 
      (fname, ftype, fid) = iprot.readFieldBegin()
26859 
      if ftype == TType.STOP:
26860 
        break
6031 rajveer 26861 
      if fid == 0:
26862 
        if ftype == TType.BOOL:
26863 
          self.success = iprot.readBool();
26864 
        else:
26865 
          iprot.skip(ftype)
26866 
      elif fid == 1:
6000 mandeep.dh 26867 
        if ftype == TType.STRUCT:
26868 
          self.ex = TransactionServiceException()
26869 
          self.ex.read(iprot)
26870 
        else:
26871 
          iprot.skip(ftype)
26872 
      else:
26873 
        iprot.skip(ftype)
26874 
      iprot.readFieldEnd()
26875 
    iprot.readStructEnd()
26876 
 
26877 
  def write(self, oprot):
26878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26880 
      return
26881 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26882 
    if self.success is not None:
26883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26884 
      oprot.writeBool(self.success)
26885 
      oprot.writeFieldEnd()
6000 mandeep.dh 26886 
    if self.ex is not None:
26887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26888 
      self.ex.write(oprot)
26889 
      oprot.writeFieldEnd()
26890 
    oprot.writeFieldStop()
26891 
    oprot.writeStructEnd()
26892 
 
26893 
  def validate(self):
26894 
    return
26895 
 
26896 
 
26897 
  def __repr__(self):
26898 
    L = ['%s=%r' % (key, value)
26899 
      for key, value in self.__dict__.iteritems()]
26900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26901 
 
26902 
  def __eq__(self, other):
26903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26904 
 
26905 
  def __ne__(self, other):
26906 
    return not (self == other)
26907 
 
26908 
class activateRechargeTxn_args:
26909 
  """
26910 
  Attributes:
6031 rajveer 26911 
   - rechargeOrderId
6000 mandeep.dh 26912 
  """
26913 
 
26914 
  thrift_spec = (
26915 
    None, # 0
6031 rajveer 26916 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26917 
  )
26918 
 
6031 rajveer 26919 
  def __init__(self, rechargeOrderId=None,):
26920 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26921 
 
26922 
  def read(self, iprot):
26923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26925 
      return
26926 
    iprot.readStructBegin()
26927 
    while True:
26928 
      (fname, ftype, fid) = iprot.readFieldBegin()
26929 
      if ftype == TType.STOP:
26930 
        break
26931 
      if fid == 1:
6031 rajveer 26932 
        if ftype == TType.I64:
26933 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26934 
        else:
26935 
          iprot.skip(ftype)
26936 
      else:
26937 
        iprot.skip(ftype)
26938 
      iprot.readFieldEnd()
26939 
    iprot.readStructEnd()
26940 
 
26941 
  def write(self, oprot):
26942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26944 
      return
26945 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26946 
    if self.rechargeOrderId is not None:
26947 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26948 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26949 
      oprot.writeFieldEnd()
26950 
    oprot.writeFieldStop()
26951 
    oprot.writeStructEnd()
26952 
 
26953 
  def validate(self):
26954 
    return
26955 
 
26956 
 
26957 
  def __repr__(self):
26958 
    L = ['%s=%r' % (key, value)
26959 
      for key, value in self.__dict__.iteritems()]
26960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26961 
 
26962 
  def __eq__(self, other):
26963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26964 
 
26965 
  def __ne__(self, other):
26966 
    return not (self == other)
26967 
 
26968 
class activateRechargeTxn_result:
26969 
  """
26970 
  Attributes:
26971 
   - success
26972 
   - ex
26973 
  """
26974 
 
26975 
  thrift_spec = (
6031 rajveer 26976 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26978 
  )
26979 
 
26980 
  def __init__(self, success=None, ex=None,):
26981 
    self.success = success
26982 
    self.ex = ex
26983 
 
26984 
  def read(self, iprot):
26985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26987 
      return
26988 
    iprot.readStructBegin()
26989 
    while True:
26990 
      (fname, ftype, fid) = iprot.readFieldBegin()
26991 
      if ftype == TType.STOP:
26992 
        break
26993 
      if fid == 0:
6031 rajveer 26994 
        if ftype == TType.BOOL:
26995 
          self.success = iprot.readBool();
6000 mandeep.dh 26996 
        else:
26997 
          iprot.skip(ftype)
26998 
      elif fid == 1:
26999 
        if ftype == TType.STRUCT:
27000 
          self.ex = TransactionServiceException()
27001 
          self.ex.read(iprot)
27002 
        else:
27003 
          iprot.skip(ftype)
27004 
      else:
27005 
        iprot.skip(ftype)
27006 
      iprot.readFieldEnd()
27007 
    iprot.readStructEnd()
27008 
 
27009 
  def write(self, oprot):
27010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27012 
      return
27013 
    oprot.writeStructBegin('activateRechargeTxn_result')
27014 
    if self.success is not None:
6031 rajveer 27015 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27016 
      oprot.writeBool(self.success)
6000 mandeep.dh 27017 
      oprot.writeFieldEnd()
27018 
    if self.ex is not None:
27019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27020 
      self.ex.write(oprot)
27021 
      oprot.writeFieldEnd()
27022 
    oprot.writeFieldStop()
27023 
    oprot.writeStructEnd()
27024 
 
27025 
  def validate(self):
27026 
    return
27027 
 
27028 
 
27029 
  def __repr__(self):
27030 
    L = ['%s=%r' % (key, value)
27031 
      for key, value in self.__dict__.iteritems()]
27032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27033 
 
27034 
  def __eq__(self, other):
27035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27036 
 
27037 
  def __ne__(self, other):
27038 
    return not (self == other)
27039 
 
6031 rajveer 27040 
class getUserWallet_args:
6000 mandeep.dh 27041 
  """
27042 
  Attributes:
6031 rajveer 27043 
   - userId
6000 mandeep.dh 27044 
  """
27045 
 
27046 
  thrift_spec = (
27047 
    None, # 0
6031 rajveer 27048 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27049 
  )
27050 
 
6031 rajveer 27051 
  def __init__(self, userId=None,):
27052 
    self.userId = userId
6000 mandeep.dh 27053 
 
27054 
  def read(self, iprot):
27055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27057 
      return
27058 
    iprot.readStructBegin()
27059 
    while True:
27060 
      (fname, ftype, fid) = iprot.readFieldBegin()
27061 
      if ftype == TType.STOP:
27062 
        break
27063 
      if fid == 1:
27064 
        if ftype == TType.I64:
6031 rajveer 27065 
          self.userId = iprot.readI64();
6000 mandeep.dh 27066 
        else:
27067 
          iprot.skip(ftype)
27068 
      else:
27069 
        iprot.skip(ftype)
27070 
      iprot.readFieldEnd()
27071 
    iprot.readStructEnd()
27072 
 
27073 
  def write(self, oprot):
27074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27076 
      return
6031 rajveer 27077 
    oprot.writeStructBegin('getUserWallet_args')
27078 
    if self.userId is not None:
27079 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27080 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27081 
      oprot.writeFieldEnd()
27082 
    oprot.writeFieldStop()
27083 
    oprot.writeStructEnd()
27084 
 
27085 
  def validate(self):
27086 
    return
27087 
 
27088 
 
27089 
  def __repr__(self):
27090 
    L = ['%s=%r' % (key, value)
27091 
      for key, value in self.__dict__.iteritems()]
27092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27093 
 
27094 
  def __eq__(self, other):
27095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27096 
 
27097 
  def __ne__(self, other):
27098 
    return not (self == other)
27099 
 
6031 rajveer 27100 
class getUserWallet_result:
6000 mandeep.dh 27101 
  """
27102 
  Attributes:
27103 
   - success
27104 
  """
27105 
 
27106 
  thrift_spec = (
6031 rajveer 27107 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27108 
  )
27109 
 
27110 
  def __init__(self, success=None,):
27111 
    self.success = success
27112 
 
27113 
  def read(self, iprot):
27114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27116 
      return
27117 
    iprot.readStructBegin()
27118 
    while True:
27119 
      (fname, ftype, fid) = iprot.readFieldBegin()
27120 
      if ftype == TType.STOP:
27121 
        break
27122 
      if fid == 0:
6031 rajveer 27123 
        if ftype == TType.STRUCT:
27124 
          self.success = UserWallet()
27125 
          self.success.read(iprot)
6000 mandeep.dh 27126 
        else:
27127 
          iprot.skip(ftype)
27128 
      else:
27129 
        iprot.skip(ftype)
27130 
      iprot.readFieldEnd()
27131 
    iprot.readStructEnd()
27132 
 
27133 
  def write(self, oprot):
27134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27136 
      return
6031 rajveer 27137 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27138 
    if self.success is not None:
6031 rajveer 27139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27140 
      self.success.write(oprot)
6000 mandeep.dh 27141 
      oprot.writeFieldEnd()
27142 
    oprot.writeFieldStop()
27143 
    oprot.writeStructEnd()
27144 
 
27145 
  def validate(self):
27146 
    return
27147 
 
27148 
 
27149 
  def __repr__(self):
27150 
    L = ['%s=%r' % (key, value)
27151 
      for key, value in self.__dict__.iteritems()]
27152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27153 
 
27154 
  def __eq__(self, other):
27155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27156 
 
27157 
  def __ne__(self, other):
27158 
    return not (self == other)
27159 
 
6031 rajveer 27160 
class getUserWalletHistory_args:
6000 mandeep.dh 27161 
  """
27162 
  Attributes:
6031 rajveer 27163 
   - userId
6000 mandeep.dh 27164 
  """
27165 
 
27166 
  thrift_spec = (
27167 
    None, # 0
6031 rajveer 27168 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27169 
  )
27170 
 
6031 rajveer 27171 
  def __init__(self, userId=None,):
27172 
    self.userId = userId
6000 mandeep.dh 27173 
 
27174 
  def read(self, iprot):
27175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27177 
      return
27178 
    iprot.readStructBegin()
27179 
    while True:
27180 
      (fname, ftype, fid) = iprot.readFieldBegin()
27181 
      if ftype == TType.STOP:
27182 
        break
27183 
      if fid == 1:
27184 
        if ftype == TType.I64:
6031 rajveer 27185 
          self.userId = iprot.readI64();
6000 mandeep.dh 27186 
        else:
27187 
          iprot.skip(ftype)
27188 
      else:
27189 
        iprot.skip(ftype)
27190 
      iprot.readFieldEnd()
27191 
    iprot.readStructEnd()
27192 
 
27193 
  def write(self, oprot):
27194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27196 
      return
6031 rajveer 27197 
    oprot.writeStructBegin('getUserWalletHistory_args')
27198 
    if self.userId is not None:
27199 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27200 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27201 
      oprot.writeFieldEnd()
27202 
    oprot.writeFieldStop()
27203 
    oprot.writeStructEnd()
27204 
 
27205 
  def validate(self):
27206 
    return
27207 
 
27208 
 
27209 
  def __repr__(self):
27210 
    L = ['%s=%r' % (key, value)
27211 
      for key, value in self.__dict__.iteritems()]
27212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27213 
 
27214 
  def __eq__(self, other):
27215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27216 
 
27217 
  def __ne__(self, other):
27218 
    return not (self == other)
27219 
 
6031 rajveer 27220 
class getUserWalletHistory_result:
6000 mandeep.dh 27221 
  """
27222 
  Attributes:
27223 
   - success
27224 
  """
27225 
 
27226 
  thrift_spec = (
6031 rajveer 27227 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27228 
  )
27229 
 
27230 
  def __init__(self, success=None,):
27231 
    self.success = success
27232 
 
27233 
  def read(self, iprot):
27234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27236 
      return
27237 
    iprot.readStructBegin()
27238 
    while True:
27239 
      (fname, ftype, fid) = iprot.readFieldBegin()
27240 
      if ftype == TType.STOP:
27241 
        break
27242 
      if fid == 0:
27243 
        if ftype == TType.LIST:
27244 
          self.success = []
6188 rajveer 27245 
          (_etype666, _size663) = iprot.readListBegin()
27246 
          for _i667 in xrange(_size663):
27247 
            _elem668 = UserWalletHistory()
27248 
            _elem668.read(iprot)
27249 
            self.success.append(_elem668)
6000 mandeep.dh 27250 
          iprot.readListEnd()
27251 
        else:
27252 
          iprot.skip(ftype)
27253 
      else:
27254 
        iprot.skip(ftype)
27255 
      iprot.readFieldEnd()
27256 
    iprot.readStructEnd()
27257 
 
27258 
  def write(self, oprot):
27259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27261 
      return
6031 rajveer 27262 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27263 
    if self.success is not None:
27264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27266 
      for iter669 in self.success:
27267 
        iter669.write(oprot)
6000 mandeep.dh 27268 
      oprot.writeListEnd()
27269 
      oprot.writeFieldEnd()
27270 
    oprot.writeFieldStop()
27271 
    oprot.writeStructEnd()
27272 
 
27273 
  def validate(self):
27274 
    return
27275 
 
27276 
 
27277 
  def __repr__(self):
27278 
    L = ['%s=%r' % (key, value)
27279 
      for key, value in self.__dict__.iteritems()]
27280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27281 
 
27282 
  def __eq__(self, other):
27283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27284 
 
27285 
  def __ne__(self, other):
27286 
    return not (self == other)
6048 rajveer 27287 
 
6050 anupam.sin 27288 
class getRechargeOrdersForTransaction_args:
27289 
  """
27290 
  Attributes:
27291 
   - txnId
27292 
  """
27293 
 
27294 
  thrift_spec = (
27295 
    None, # 0
27296 
    (1, TType.I64, 'txnId', None, None, ), # 1
27297 
  )
27298 
 
27299 
  def __init__(self, txnId=None,):
27300 
    self.txnId = txnId
27301 
 
27302 
  def read(self, iprot):
27303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27305 
      return
27306 
    iprot.readStructBegin()
27307 
    while True:
27308 
      (fname, ftype, fid) = iprot.readFieldBegin()
27309 
      if ftype == TType.STOP:
27310 
        break
27311 
      if fid == 1:
27312 
        if ftype == TType.I64:
27313 
          self.txnId = iprot.readI64();
27314 
        else:
27315 
          iprot.skip(ftype)
27316 
      else:
27317 
        iprot.skip(ftype)
27318 
      iprot.readFieldEnd()
27319 
    iprot.readStructEnd()
27320 
 
27321 
  def write(self, oprot):
27322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27324 
      return
27325 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27326 
    if self.txnId is not None:
27327 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27328 
      oprot.writeI64(self.txnId)
27329 
      oprot.writeFieldEnd()
27330 
    oprot.writeFieldStop()
27331 
    oprot.writeStructEnd()
27332 
 
27333 
  def validate(self):
27334 
    return
27335 
 
27336 
 
27337 
  def __repr__(self):
27338 
    L = ['%s=%r' % (key, value)
27339 
      for key, value in self.__dict__.iteritems()]
27340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27341 
 
27342 
  def __eq__(self, other):
27343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27344 
 
27345 
  def __ne__(self, other):
27346 
    return not (self == other)
27347 
 
27348 
class getRechargeOrdersForTransaction_result:
27349 
  """
27350 
  Attributes:
27351 
   - success
27352 
   - ex
27353 
  """
27354 
 
27355 
  thrift_spec = (
27356 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27358 
  )
27359 
 
27360 
  def __init__(self, success=None, ex=None,):
27361 
    self.success = success
27362 
    self.ex = ex
27363 
 
27364 
  def read(self, iprot):
27365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27367 
      return
27368 
    iprot.readStructBegin()
27369 
    while True:
27370 
      (fname, ftype, fid) = iprot.readFieldBegin()
27371 
      if ftype == TType.STOP:
27372 
        break
27373 
      if fid == 0:
27374 
        if ftype == TType.STRUCT:
27375 
          self.success = RechargeOrder()
27376 
          self.success.read(iprot)
27377 
        else:
27378 
          iprot.skip(ftype)
27379 
      elif fid == 1:
27380 
        if ftype == TType.STRUCT:
27381 
          self.ex = TransactionServiceException()
27382 
          self.ex.read(iprot)
27383 
        else:
27384 
          iprot.skip(ftype)
27385 
      else:
27386 
        iprot.skip(ftype)
27387 
      iprot.readFieldEnd()
27388 
    iprot.readStructEnd()
27389 
 
27390 
  def write(self, oprot):
27391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27393 
      return
27394 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27395 
    if self.success is not None:
27396 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27397 
      self.success.write(oprot)
27398 
      oprot.writeFieldEnd()
27399 
    if self.ex is not None:
27400 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27401 
      self.ex.write(oprot)
27402 
      oprot.writeFieldEnd()
27403 
    oprot.writeFieldStop()
27404 
    oprot.writeStructEnd()
27405 
 
27406 
  def validate(self):
27407 
    return
27408 
 
27409 
 
27410 
  def __repr__(self):
27411 
    L = ['%s=%r' % (key, value)
27412 
      for key, value in self.__dict__.iteritems()]
27413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27414 
 
27415 
  def __eq__(self, other):
27416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27417 
 
27418 
  def __ne__(self, other):
27419 
    return not (self == other)
27420 
 
6048 rajveer 27421 
class getServiceProviders_args:
27422 
  """
27423 
  Attributes:
27424 
   - rechargeType
27425 
  """
27426 
 
27427 
  thrift_spec = (
27428 
    None, # 0
27429 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27430 
  )
27431 
 
27432 
  def __init__(self, rechargeType=None,):
27433 
    self.rechargeType = rechargeType
27434 
 
27435 
  def read(self, iprot):
27436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27438 
      return
27439 
    iprot.readStructBegin()
27440 
    while True:
27441 
      (fname, ftype, fid) = iprot.readFieldBegin()
27442 
      if ftype == TType.STOP:
27443 
        break
27444 
      if fid == 1:
27445 
        if ftype == TType.I32:
27446 
          self.rechargeType = iprot.readI32();
27447 
        else:
27448 
          iprot.skip(ftype)
27449 
      else:
27450 
        iprot.skip(ftype)
27451 
      iprot.readFieldEnd()
27452 
    iprot.readStructEnd()
27453 
 
27454 
  def write(self, oprot):
27455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27457 
      return
27458 
    oprot.writeStructBegin('getServiceProviders_args')
27459 
    if self.rechargeType is not None:
27460 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27461 
      oprot.writeI32(self.rechargeType)
27462 
      oprot.writeFieldEnd()
27463 
    oprot.writeFieldStop()
27464 
    oprot.writeStructEnd()
27465 
 
27466 
  def validate(self):
27467 
    return
27468 
 
27469 
 
27470 
  def __repr__(self):
27471 
    L = ['%s=%r' % (key, value)
27472 
      for key, value in self.__dict__.iteritems()]
27473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27474 
 
27475 
  def __eq__(self, other):
27476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27477 
 
27478 
  def __ne__(self, other):
27479 
    return not (self == other)
27480 
 
27481 
class getServiceProviders_result:
27482 
  """
27483 
  Attributes:
27484 
   - success
27485 
  """
27486 
 
27487 
  thrift_spec = (
27488 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27489 
  )
27490 
 
27491 
  def __init__(self, success=None,):
27492 
    self.success = success
27493 
 
27494 
  def read(self, iprot):
27495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27497 
      return
27498 
    iprot.readStructBegin()
27499 
    while True:
27500 
      (fname, ftype, fid) = iprot.readFieldBegin()
27501 
      if ftype == TType.STOP:
27502 
        break
27503 
      if fid == 0:
27504 
        if ftype == TType.MAP:
27505 
          self.success = {}
6188 rajveer 27506 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27507 
          for _i674 in xrange(_size670):
27508 
            _key675 = iprot.readI64();
27509 
            _val676 = iprot.readString();
27510 
            self.success[_key675] = _val676
6048 rajveer 27511 
          iprot.readMapEnd()
27512 
        else:
27513 
          iprot.skip(ftype)
27514 
      else:
27515 
        iprot.skip(ftype)
27516 
      iprot.readFieldEnd()
27517 
    iprot.readStructEnd()
27518 
 
27519 
  def write(self, oprot):
27520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27522 
      return
27523 
    oprot.writeStructBegin('getServiceProviders_result')
27524 
    if self.success is not None:
27525 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27526 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27527 
      for kiter677,viter678 in self.success.items():
27528 
        oprot.writeI64(kiter677)
27529 
        oprot.writeString(viter678)
6048 rajveer 27530 
      oprot.writeMapEnd()
27531 
      oprot.writeFieldEnd()
27532 
    oprot.writeFieldStop()
27533 
    oprot.writeStructEnd()
27534 
 
27535 
  def validate(self):
27536 
    return
27537 
 
27538 
 
27539 
  def __repr__(self):
27540 
    L = ['%s=%r' % (key, value)
27541 
      for key, value in self.__dict__.iteritems()]
27542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27543 
 
27544 
  def __eq__(self, other):
27545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27546 
 
27547 
  def __ne__(self, other):
27548 
    return not (self == other)
27549 
 
27550 
class getServiceProviderForDevice_args:
27551 
  """
27552 
  Attributes:
6049 rajveer 27553 
   - rechargeType
6048 rajveer 27554 
   - deviceNumber
27555 
  """
27556 
 
27557 
  thrift_spec = (
27558 
    None, # 0
6049 rajveer 27559 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27560 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27561 
  )
27562 
 
6049 rajveer 27563 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27564 
    self.rechargeType = rechargeType
6048 rajveer 27565 
    self.deviceNumber = deviceNumber
27566 
 
27567 
  def read(self, iprot):
27568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27570 
      return
27571 
    iprot.readStructBegin()
27572 
    while True:
27573 
      (fname, ftype, fid) = iprot.readFieldBegin()
27574 
      if ftype == TType.STOP:
27575 
        break
27576 
      if fid == 1:
6049 rajveer 27577 
        if ftype == TType.I32:
27578 
          self.rechargeType = iprot.readI32();
27579 
        else:
27580 
          iprot.skip(ftype)
27581 
      elif fid == 2:
6048 rajveer 27582 
        if ftype == TType.STRING:
27583 
          self.deviceNumber = iprot.readString();
27584 
        else:
27585 
          iprot.skip(ftype)
27586 
      else:
27587 
        iprot.skip(ftype)
27588 
      iprot.readFieldEnd()
27589 
    iprot.readStructEnd()
27590 
 
27591 
  def write(self, oprot):
27592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27594 
      return
27595 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27596 
    if self.rechargeType is not None:
27597 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27598 
      oprot.writeI32(self.rechargeType)
27599 
      oprot.writeFieldEnd()
6048 rajveer 27600 
    if self.deviceNumber is not None:
6049 rajveer 27601 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27602 
      oprot.writeString(self.deviceNumber)
27603 
      oprot.writeFieldEnd()
27604 
    oprot.writeFieldStop()
27605 
    oprot.writeStructEnd()
27606 
 
27607 
  def validate(self):
27608 
    return
27609 
 
27610 
 
27611 
  def __repr__(self):
27612 
    L = ['%s=%r' % (key, value)
27613 
      for key, value in self.__dict__.iteritems()]
27614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27615 
 
27616 
  def __eq__(self, other):
27617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27618 
 
27619 
  def __ne__(self, other):
27620 
    return not (self == other)
27621 
 
27622 
class getServiceProviderForDevice_result:
27623 
  """
27624 
  Attributes:
27625 
   - success
27626 
  """
27627 
 
27628 
  thrift_spec = (
27629 
    (0, TType.I64, 'success', None, None, ), # 0
27630 
  )
27631 
 
27632 
  def __init__(self, success=None,):
27633 
    self.success = success
27634 
 
27635 
  def read(self, iprot):
27636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27638 
      return
27639 
    iprot.readStructBegin()
27640 
    while True:
27641 
      (fname, ftype, fid) = iprot.readFieldBegin()
27642 
      if ftype == TType.STOP:
27643 
        break
27644 
      if fid == 0:
27645 
        if ftype == TType.I64:
27646 
          self.success = iprot.readI64();
27647 
        else:
27648 
          iprot.skip(ftype)
27649 
      else:
27650 
        iprot.skip(ftype)
27651 
      iprot.readFieldEnd()
27652 
    iprot.readStructEnd()
27653 
 
27654 
  def write(self, oprot):
27655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27657 
      return
27658 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27659 
    if self.success is not None:
27660 
      oprot.writeFieldBegin('success', TType.I64, 0)
27661 
      oprot.writeI64(self.success)
27662 
      oprot.writeFieldEnd()
27663 
    oprot.writeFieldStop()
27664 
    oprot.writeStructEnd()
27665 
 
27666 
  def validate(self):
27667 
    return
27668 
 
27669 
 
27670 
  def __repr__(self):
27671 
    L = ['%s=%r' % (key, value)
27672 
      for key, value in self.__dict__.iteritems()]
27673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27674 
 
27675 
  def __eq__(self, other):
27676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27677 
 
27678 
  def __ne__(self, other):
27679 
    return not (self == other)
6094 rajveer 27680 
 
27681 
class getRechargeOrdersForDevice_args:
27682 
  """
27683 
  Attributes:
27684 
   - deviceNumber
27685 
  """
27686 
 
27687 
  thrift_spec = (
27688 
    None, # 0
27689 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27690 
  )
27691 
 
27692 
  def __init__(self, deviceNumber=None,):
27693 
    self.deviceNumber = deviceNumber
27694 
 
27695 
  def read(self, iprot):
27696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27698 
      return
27699 
    iprot.readStructBegin()
27700 
    while True:
27701 
      (fname, ftype, fid) = iprot.readFieldBegin()
27702 
      if ftype == TType.STOP:
27703 
        break
27704 
      if fid == 1:
27705 
        if ftype == TType.STRING:
27706 
          self.deviceNumber = iprot.readString();
27707 
        else:
27708 
          iprot.skip(ftype)
27709 
      else:
27710 
        iprot.skip(ftype)
27711 
      iprot.readFieldEnd()
27712 
    iprot.readStructEnd()
27713 
 
27714 
  def write(self, oprot):
27715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27717 
      return
27718 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27719 
    if self.deviceNumber is not None:
27720 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27721 
      oprot.writeString(self.deviceNumber)
27722 
      oprot.writeFieldEnd()
27723 
    oprot.writeFieldStop()
27724 
    oprot.writeStructEnd()
27725 
 
27726 
  def validate(self):
27727 
    return
27728 
 
27729 
 
27730 
  def __repr__(self):
27731 
    L = ['%s=%r' % (key, value)
27732 
      for key, value in self.__dict__.iteritems()]
27733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27734 
 
27735 
  def __eq__(self, other):
27736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27737 
 
27738 
  def __ne__(self, other):
27739 
    return not (self == other)
27740 
 
27741 
class getRechargeOrdersForDevice_result:
27742 
  """
27743 
  Attributes:
27744 
   - success
27745 
  """
27746 
 
27747 
  thrift_spec = (
27748 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27749 
  )
27750 
 
27751 
  def __init__(self, success=None,):
27752 
    self.success = success
27753 
 
27754 
  def read(self, iprot):
27755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27757 
      return
27758 
    iprot.readStructBegin()
27759 
    while True:
27760 
      (fname, ftype, fid) = iprot.readFieldBegin()
27761 
      if ftype == TType.STOP:
27762 
        break
27763 
      if fid == 0:
27764 
        if ftype == TType.LIST:
27765 
          self.success = []
6188 rajveer 27766 
          (_etype682, _size679) = iprot.readListBegin()
27767 
          for _i683 in xrange(_size679):
27768 
            _elem684 = RechargeOrder()
27769 
            _elem684.read(iprot)
27770 
            self.success.append(_elem684)
6094 rajveer 27771 
          iprot.readListEnd()
27772 
        else:
27773 
          iprot.skip(ftype)
27774 
      else:
27775 
        iprot.skip(ftype)
27776 
      iprot.readFieldEnd()
27777 
    iprot.readStructEnd()
27778 
 
27779 
  def write(self, oprot):
27780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27782 
      return
27783 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27784 
    if self.success is not None:
27785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27787 
      for iter685 in self.success:
27788 
        iter685.write(oprot)
6094 rajveer 27789 
      oprot.writeListEnd()
27790 
      oprot.writeFieldEnd()
27791 
    oprot.writeFieldStop()
27792 
    oprot.writeStructEnd()
27793 
 
27794 
  def validate(self):
27795 
    return
27796 
 
27797 
 
27798 
  def __repr__(self):
27799 
    L = ['%s=%r' % (key, value)
27800 
      for key, value in self.__dict__.iteritems()]
27801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27802 
 
27803 
  def __eq__(self, other):
27804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27805 
 
27806 
  def __ne__(self, other):
27807 
    return not (self == other)
27808 
 
27809 
class addAmountToWallet_args:
27810 
  """
27811 
  Attributes:
27812 
   - userId
27813 
   - orderId
27814 
   - amount
27815 
  """
27816 
 
27817 
  thrift_spec = (
27818 
    None, # 0
27819 
    (1, TType.I64, 'userId', None, None, ), # 1
27820 
    (2, TType.I64, 'orderId', None, None, ), # 2
27821 
    (3, TType.I64, 'amount', None, None, ), # 3
27822 
  )
27823 
 
27824 
  def __init__(self, userId=None, orderId=None, amount=None,):
27825 
    self.userId = userId
27826 
    self.orderId = orderId
27827 
    self.amount = amount
27828 
 
27829 
  def read(self, iprot):
27830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27832 
      return
27833 
    iprot.readStructBegin()
27834 
    while True:
27835 
      (fname, ftype, fid) = iprot.readFieldBegin()
27836 
      if ftype == TType.STOP:
27837 
        break
27838 
      if fid == 1:
27839 
        if ftype == TType.I64:
27840 
          self.userId = iprot.readI64();
27841 
        else:
27842 
          iprot.skip(ftype)
27843 
      elif fid == 2:
27844 
        if ftype == TType.I64:
27845 
          self.orderId = iprot.readI64();
27846 
        else:
27847 
          iprot.skip(ftype)
27848 
      elif fid == 3:
27849 
        if ftype == TType.I64:
27850 
          self.amount = iprot.readI64();
27851 
        else:
27852 
          iprot.skip(ftype)
27853 
      else:
27854 
        iprot.skip(ftype)
27855 
      iprot.readFieldEnd()
27856 
    iprot.readStructEnd()
27857 
 
27858 
  def write(self, oprot):
27859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27861 
      return
27862 
    oprot.writeStructBegin('addAmountToWallet_args')
27863 
    if self.userId is not None:
27864 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27865 
      oprot.writeI64(self.userId)
27866 
      oprot.writeFieldEnd()
27867 
    if self.orderId is not None:
27868 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
27869 
      oprot.writeI64(self.orderId)
27870 
      oprot.writeFieldEnd()
27871 
    if self.amount is not None:
27872 
      oprot.writeFieldBegin('amount', TType.I64, 3)
27873 
      oprot.writeI64(self.amount)
27874 
      oprot.writeFieldEnd()
27875 
    oprot.writeFieldStop()
27876 
    oprot.writeStructEnd()
27877 
 
27878 
  def validate(self):
27879 
    return
27880 
 
27881 
 
27882 
  def __repr__(self):
27883 
    L = ['%s=%r' % (key, value)
27884 
      for key, value in self.__dict__.iteritems()]
27885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27886 
 
27887 
  def __eq__(self, other):
27888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27889 
 
27890 
  def __ne__(self, other):
27891 
    return not (self == other)
27892 
 
27893 
class addAmountToWallet_result:
27894 
 
27895 
  thrift_spec = (
27896 
  )
27897 
 
27898 
  def read(self, iprot):
27899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27901 
      return
27902 
    iprot.readStructBegin()
27903 
    while True:
27904 
      (fname, ftype, fid) = iprot.readFieldBegin()
27905 
      if ftype == TType.STOP:
27906 
        break
27907 
      else:
27908 
        iprot.skip(ftype)
27909 
      iprot.readFieldEnd()
27910 
    iprot.readStructEnd()
27911 
 
27912 
  def write(self, oprot):
27913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27915 
      return
27916 
    oprot.writeStructBegin('addAmountToWallet_result')
27917 
    oprot.writeFieldStop()
27918 
    oprot.writeStructEnd()
27919 
 
27920 
  def validate(self):
27921 
    return
27922 
 
27923 
 
27924 
  def __repr__(self):
27925 
    L = ['%s=%r' % (key, value)
27926 
      for key, value in self.__dict__.iteritems()]
27927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27928 
 
27929 
  def __eq__(self, other):
27930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27931 
 
27932 
  def __ne__(self, other):
27933 
    return not (self == other)
6154 rajveer 27934 
 
6188 rajveer 27935 
class getRechargeStatistics_args:
27936 
 
27937 
  thrift_spec = (
27938 
  )
27939 
 
27940 
  def read(self, iprot):
27941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27943 
      return
27944 
    iprot.readStructBegin()
27945 
    while True:
27946 
      (fname, ftype, fid) = iprot.readFieldBegin()
27947 
      if ftype == TType.STOP:
27948 
        break
27949 
      else:
27950 
        iprot.skip(ftype)
27951 
      iprot.readFieldEnd()
27952 
    iprot.readStructEnd()
27953 
 
27954 
  def write(self, oprot):
27955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27957 
      return
27958 
    oprot.writeStructBegin('getRechargeStatistics_args')
27959 
    oprot.writeFieldStop()
27960 
    oprot.writeStructEnd()
27961 
 
27962 
  def validate(self):
27963 
    return
27964 
 
27965 
 
27966 
  def __repr__(self):
27967 
    L = ['%s=%r' % (key, value)
27968 
      for key, value in self.__dict__.iteritems()]
27969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27970 
 
27971 
  def __eq__(self, other):
27972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27973 
 
27974 
  def __ne__(self, other):
27975 
    return not (self == other)
27976 
 
27977 
class getRechargeStatistics_result:
27978 
  """
27979 
  Attributes:
27980 
   - success
27981 
  """
27982 
 
27983 
  thrift_spec = (
27984 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
27985 
  )
27986 
 
27987 
  def __init__(self, success=None,):
27988 
    self.success = success
27989 
 
27990 
  def read(self, iprot):
27991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27993 
      return
27994 
    iprot.readStructBegin()
27995 
    while True:
27996 
      (fname, ftype, fid) = iprot.readFieldBegin()
27997 
      if ftype == TType.STOP:
27998 
        break
27999 
      if fid == 0:
28000 
        if ftype == TType.STRUCT:
28001 
          self.success = RechargeStatistics()
28002 
          self.success.read(iprot)
28003 
        else:
28004 
          iprot.skip(ftype)
28005 
      else:
28006 
        iprot.skip(ftype)
28007 
      iprot.readFieldEnd()
28008 
    iprot.readStructEnd()
28009 
 
28010 
  def write(self, oprot):
28011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28013 
      return
28014 
    oprot.writeStructBegin('getRechargeStatistics_result')
28015 
    if self.success is not None:
28016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28017 
      self.success.write(oprot)
28018 
      oprot.writeFieldEnd()
28019 
    oprot.writeFieldStop()
28020 
    oprot.writeStructEnd()
28021 
 
28022 
  def validate(self):
28023 
    return
28024 
 
28025 
 
28026 
  def __repr__(self):
28027 
    L = ['%s=%r' % (key, value)
28028 
      for key, value in self.__dict__.iteritems()]
28029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28030 
 
28031 
  def __eq__(self, other):
28032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28033 
 
28034 
  def __ne__(self, other):
28035 
    return not (self == other)
28036 
 
6154 rajveer 28037 
class getRechargeOrdersForStatus_args:
28038 
  """
28039 
  Attributes:
28040 
   - status
28041 
  """
28042 
 
28043 
  thrift_spec = (
28044 
    None, # 0
28045 
    (1, TType.I64, 'status', None, None, ), # 1
28046 
  )
28047 
 
28048 
  def __init__(self, status=None,):
28049 
    self.status = status
28050 
 
28051 
  def read(self, iprot):
28052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28054 
      return
28055 
    iprot.readStructBegin()
28056 
    while True:
28057 
      (fname, ftype, fid) = iprot.readFieldBegin()
28058 
      if ftype == TType.STOP:
28059 
        break
28060 
      if fid == 1:
28061 
        if ftype == TType.I64:
28062 
          self.status = iprot.readI64();
28063 
        else:
28064 
          iprot.skip(ftype)
28065 
      else:
28066 
        iprot.skip(ftype)
28067 
      iprot.readFieldEnd()
28068 
    iprot.readStructEnd()
28069 
 
28070 
  def write(self, oprot):
28071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28073 
      return
28074 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28075 
    if self.status is not None:
28076 
      oprot.writeFieldBegin('status', TType.I64, 1)
28077 
      oprot.writeI64(self.status)
28078 
      oprot.writeFieldEnd()
28079 
    oprot.writeFieldStop()
28080 
    oprot.writeStructEnd()
28081 
 
28082 
  def validate(self):
28083 
    return
28084 
 
28085 
 
28086 
  def __repr__(self):
28087 
    L = ['%s=%r' % (key, value)
28088 
      for key, value in self.__dict__.iteritems()]
28089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28090 
 
28091 
  def __eq__(self, other):
28092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28093 
 
28094 
  def __ne__(self, other):
28095 
    return not (self == other)
28096 
 
28097 
class getRechargeOrdersForStatus_result:
28098 
  """
28099 
  Attributes:
28100 
   - success
28101 
  """
28102 
 
28103 
  thrift_spec = (
28104 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28105 
  )
28106 
 
28107 
  def __init__(self, success=None,):
28108 
    self.success = success
28109 
 
28110 
  def read(self, iprot):
28111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28113 
      return
28114 
    iprot.readStructBegin()
28115 
    while True:
28116 
      (fname, ftype, fid) = iprot.readFieldBegin()
28117 
      if ftype == TType.STOP:
28118 
        break
28119 
      if fid == 0:
28120 
        if ftype == TType.LIST:
28121 
          self.success = []
6188 rajveer 28122 
          (_etype689, _size686) = iprot.readListBegin()
28123 
          for _i690 in xrange(_size686):
28124 
            _elem691 = RechargeOrder()
28125 
            _elem691.read(iprot)
28126 
            self.success.append(_elem691)
6154 rajveer 28127 
          iprot.readListEnd()
28128 
        else:
28129 
          iprot.skip(ftype)
28130 
      else:
28131 
        iprot.skip(ftype)
28132 
      iprot.readFieldEnd()
28133 
    iprot.readStructEnd()
28134 
 
28135 
  def write(self, oprot):
28136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28138 
      return
28139 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28140 
    if self.success is not None:
28141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28143 
      for iter692 in self.success:
28144 
        iter692.write(oprot)
6154 rajveer 28145 
      oprot.writeListEnd()
28146 
      oprot.writeFieldEnd()
28147 
    oprot.writeFieldStop()
28148 
    oprot.writeStructEnd()
28149 
 
28150 
  def validate(self):
28151 
    return
28152 
 
28153 
 
28154 
  def __repr__(self):
28155 
    L = ['%s=%r' % (key, value)
28156 
      for key, value in self.__dict__.iteritems()]
28157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28158 
 
28159 
  def __eq__(self, other):
28160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28161 
 
28162 
  def __ne__(self, other):
28163 
    return not (self == other)
6159 rajveer 28164 
 
28165 
class getPlansForOperator_args:
28166 
  """
28167 
  Attributes:
28168 
   - operatorId
28169 
  """
28170 
 
28171 
  thrift_spec = (
28172 
    None, # 0
28173 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28174 
  )
28175 
 
28176 
  def __init__(self, operatorId=None,):
28177 
    self.operatorId = operatorId
28178 
 
28179 
  def read(self, iprot):
28180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28182 
      return
28183 
    iprot.readStructBegin()
28184 
    while True:
28185 
      (fname, ftype, fid) = iprot.readFieldBegin()
28186 
      if ftype == TType.STOP:
28187 
        break
28188 
      if fid == 1:
28189 
        if ftype == TType.I64:
28190 
          self.operatorId = iprot.readI64();
28191 
        else:
28192 
          iprot.skip(ftype)
28193 
      else:
28194 
        iprot.skip(ftype)
28195 
      iprot.readFieldEnd()
28196 
    iprot.readStructEnd()
28197 
 
28198 
  def write(self, oprot):
28199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28201 
      return
28202 
    oprot.writeStructBegin('getPlansForOperator_args')
28203 
    if self.operatorId is not None:
28204 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28205 
      oprot.writeI64(self.operatorId)
28206 
      oprot.writeFieldEnd()
28207 
    oprot.writeFieldStop()
28208 
    oprot.writeStructEnd()
28209 
 
28210 
  def validate(self):
28211 
    return
28212 
 
28213 
 
28214 
  def __repr__(self):
28215 
    L = ['%s=%r' % (key, value)
28216 
      for key, value in self.__dict__.iteritems()]
28217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28218 
 
28219 
  def __eq__(self, other):
28220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28221 
 
28222 
  def __ne__(self, other):
28223 
    return not (self == other)
28224 
 
28225 
class getPlansForOperator_result:
28226 
  """
28227 
  Attributes:
28228 
   - success
28229 
  """
28230 
 
28231 
  thrift_spec = (
28232 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28233 
  )
28234 
 
28235 
  def __init__(self, success=None,):
28236 
    self.success = success
28237 
 
28238 
  def read(self, iprot):
28239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28241 
      return
28242 
    iprot.readStructBegin()
28243 
    while True:
28244 
      (fname, ftype, fid) = iprot.readFieldBegin()
28245 
      if ftype == TType.STOP:
28246 
        break
28247 
      if fid == 0:
28248 
        if ftype == TType.LIST:
28249 
          self.success = []
6188 rajveer 28250 
          (_etype696, _size693) = iprot.readListBegin()
28251 
          for _i697 in xrange(_size693):
28252 
            _elem698 = RechargePlan()
28253 
            _elem698.read(iprot)
28254 
            self.success.append(_elem698)
6159 rajveer 28255 
          iprot.readListEnd()
28256 
        else:
28257 
          iprot.skip(ftype)
28258 
      else:
28259 
        iprot.skip(ftype)
28260 
      iprot.readFieldEnd()
28261 
    iprot.readStructEnd()
28262 
 
28263 
  def write(self, oprot):
28264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28266 
      return
28267 
    oprot.writeStructBegin('getPlansForOperator_result')
28268 
    if self.success is not None:
28269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28271 
      for iter699 in self.success:
28272 
        iter699.write(oprot)
6159 rajveer 28273 
      oprot.writeListEnd()
28274 
      oprot.writeFieldEnd()
28275 
    oprot.writeFieldStop()
28276 
    oprot.writeStructEnd()
28277 
 
28278 
  def validate(self):
28279 
    return
28280 
 
28281 
 
28282 
  def __repr__(self):
28283 
    L = ['%s=%r' % (key, value)
28284 
      for key, value in self.__dict__.iteritems()]
28285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28286 
 
28287 
  def __eq__(self, other):
28288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28289 
 
28290 
  def __ne__(self, other):
28291 
    return not (self == other)