Subversion Repositories SmartDukaan

Rev

Rev 6188 | Rev 6269 | 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 
 
6206 rajveer 1349 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
6206 rajveer 1353 
     - onlyActive
6048 rajveer 1354 
    """
1355 
    pass
6000 mandeep.dh 1356 
 
6049 rajveer 1357 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1358 
    """
1359 
    Parameters:
6049 rajveer 1360 
     - rechargeType
6048 rajveer 1361 
     - deviceNumber
1362 
    """
1363 
    pass
1364 
 
6094 rajveer 1365 
  def getRechargeOrdersForDevice(self, deviceNumber):
1366 
    """
1367 
    Parameters:
1368 
     - deviceNumber
1369 
    """
1370 
    pass
6048 rajveer 1371 
 
6094 rajveer 1372 
  def addAmountToWallet(self, userId, orderId, amount):
1373 
    """
1374 
    Parameters:
1375 
     - userId
1376 
     - orderId
1377 
     - amount
1378 
    """
1379 
    pass
1380 
 
6188 rajveer 1381 
  def getRechargeStatistics(self, ):
1382 
    pass
1383 
 
6154 rajveer 1384 
  def getRechargeOrdersForStatus(self, status):
1385 
    """
1386 
    Parameters:
1387 
     - status
1388 
    """
1389 
    pass
6094 rajveer 1390 
 
6159 rajveer 1391 
  def getPlansForOperator(self, operatorId):
1392 
    """
1393 
    Parameters:
1394 
     - operatorId
1395 
    """
1396 
    pass
6154 rajveer 1397 
 
6159 rajveer 1398 
 
3376 rajveer 1399 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1400 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1401 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1402 
 
1403 
  def createTransaction(self, transaction):
1404 
    """
1405 
    Parameters:
1406 
     - transaction
1407 
    """
1408 
    self.send_createTransaction(transaction)
132 ashish 1409 
    return self.recv_createTransaction()
94 ashish 1410 
 
1411 
  def send_createTransaction(self, transaction):
1412 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1413 
    args = createTransaction_args()
1414 
    args.transaction = transaction
1415 
    args.write(self._oprot)
1416 
    self._oprot.writeMessageEnd()
1417 
    self._oprot.trans.flush()
1418 
 
1419 
  def recv_createTransaction(self, ):
1420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1421 
    if mtype == TMessageType.EXCEPTION:
1422 
      x = TApplicationException()
1423 
      x.read(self._iprot)
1424 
      self._iprot.readMessageEnd()
1425 
      raise x
1426 
    result = createTransaction_result()
1427 
    result.read(self._iprot)
1428 
    self._iprot.readMessageEnd()
3431 rajveer 1429 
    if result.success is not None:
132 ashish 1430 
      return result.success
3431 rajveer 1431 
    if result.ex is not None:
94 ashish 1432 
      raise result.ex
132 ashish 1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1434 
 
1435 
  def getTransaction(self, id):
1436 
    """
1437 
    Parameters:
1438 
     - id
1439 
    """
1440 
    self.send_getTransaction(id)
1441 
    return self.recv_getTransaction()
1442 
 
1443 
  def send_getTransaction(self, id):
1444 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1445 
    args = getTransaction_args()
1446 
    args.id = id
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_getTransaction(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = getTransaction_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
3431 rajveer 1461 
    if result.success is not None:
94 ashish 1462 
      return result.success
3431 rajveer 1463 
    if result.ex is not None:
94 ashish 1464 
      raise result.ex
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1466 
 
1467 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1468 
    """
1469 
    Parameters:
1470 
     - customerId
1471 
     - from_date
1472 
     - to_date
1473 
     - status
1474 
    """
1475 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1476 
    return self.recv_getTransactionsForCustomer()
1477 
 
1478 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1479 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1480 
    args = getTransactionsForCustomer_args()
1481 
    args.customerId = customerId
1482 
    args.from_date = from_date
1483 
    args.to_date = to_date
1484 
    args.status = status
1485 
    args.write(self._oprot)
1486 
    self._oprot.writeMessageEnd()
1487 
    self._oprot.trans.flush()
1488 
 
1489 
  def recv_getTransactionsForCustomer(self, ):
1490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1491 
    if mtype == TMessageType.EXCEPTION:
1492 
      x = TApplicationException()
1493 
      x.read(self._iprot)
1494 
      self._iprot.readMessageEnd()
1495 
      raise x
1496 
    result = getTransactionsForCustomer_result()
1497 
    result.read(self._iprot)
1498 
    self._iprot.readMessageEnd()
3431 rajveer 1499 
    if result.success is not None:
94 ashish 1500 
      return result.success
3431 rajveer 1501 
    if result.ex is not None:
94 ashish 1502 
      raise result.ex
1503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1504 
 
132 ashish 1505 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1506 
    """
1507 
    Parameters:
1508 
     - shoppingCartId
1509 
    """
1510 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1511 
    return self.recv_getTransactionsForShoppingCartId()
1512 
 
1513 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1514 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1515 
    args = getTransactionsForShoppingCartId_args()
1516 
    args.shoppingCartId = shoppingCartId
1517 
    args.write(self._oprot)
1518 
    self._oprot.writeMessageEnd()
1519 
    self._oprot.trans.flush()
1520 
 
1521 
  def recv_getTransactionsForShoppingCartId(self, ):
1522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1523 
    if mtype == TMessageType.EXCEPTION:
1524 
      x = TApplicationException()
1525 
      x.read(self._iprot)
1526 
      self._iprot.readMessageEnd()
1527 
      raise x
1528 
    result = getTransactionsForShoppingCartId_result()
1529 
    result.read(self._iprot)
1530 
    self._iprot.readMessageEnd()
3431 rajveer 1531 
    if result.success is not None:
132 ashish 1532 
      return result.success
3431 rajveer 1533 
    if result.ex is not None:
132 ashish 1534 
      raise result.ex
1535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1536 
 
94 ashish 1537 
  def getTransactionStatus(self, transactionId):
1538 
    """
1539 
    Parameters:
1540 
     - transactionId
1541 
    """
1542 
    self.send_getTransactionStatus(transactionId)
1543 
    return self.recv_getTransactionStatus()
1544 
 
1545 
  def send_getTransactionStatus(self, transactionId):
1546 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1547 
    args = getTransactionStatus_args()
1548 
    args.transactionId = transactionId
1549 
    args.write(self._oprot)
1550 
    self._oprot.writeMessageEnd()
1551 
    self._oprot.trans.flush()
1552 
 
1553 
  def recv_getTransactionStatus(self, ):
1554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1555 
    if mtype == TMessageType.EXCEPTION:
1556 
      x = TApplicationException()
1557 
      x.read(self._iprot)
1558 
      self._iprot.readMessageEnd()
1559 
      raise x
1560 
    result = getTransactionStatus_result()
1561 
    result.read(self._iprot)
1562 
    self._iprot.readMessageEnd()
3431 rajveer 1563 
    if result.success is not None:
94 ashish 1564 
      return result.success
3431 rajveer 1565 
    if result.ex is not None:
94 ashish 1566 
      raise result.ex
1567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1568 
 
5527 anupam.sin 1569 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1570 
    """
1571 
    Parameters:
1572 
     - transactionId
1573 
     - status
1574 
     - description
5527 anupam.sin 1575 
     - pickUp
1576 
     - orderType
94 ashish 1577 
    """
5527 anupam.sin 1578 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1579 
    return self.recv_changeTransactionStatus()
1580 
 
5527 anupam.sin 1581 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1582 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1583 
    args = changeTransactionStatus_args()
1584 
    args.transactionId = transactionId
1585 
    args.status = status
1586 
    args.description = description
5527 anupam.sin 1587 
    args.pickUp = pickUp
1588 
    args.orderType = orderType
94 ashish 1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_changeTransactionStatus(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = changeTransactionStatus_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
3431 rajveer 1603 
    if result.success is not None:
94 ashish 1604 
      return result.success
3431 rajveer 1605 
    if result.ex is not None:
94 ashish 1606 
      raise result.ex
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1608 
 
1398 varun.gupt 1609 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1610 
    """
1611 
    Parameters:
1612 
     - transactionId
1613 
    """
1398 varun.gupt 1614 
    self.send_enqueueTransactionInfoEmail(transactionId)
1615 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1616 
 
1398 varun.gupt 1617 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1618 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1619 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1620 
    args.transactionId = transactionId
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1398 varun.gupt 1625 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1398 varun.gupt 1632 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
3431 rajveer 1635 
    if result.success is not None:
1382 varun.gupt 1636 
      return result.success
3431 rajveer 1637 
    if result.ex is not None:
1382 varun.gupt 1638 
      raise result.ex
1398 varun.gupt 1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1640 
 
4801 anupam.sin 1641 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1642 
    """
1643 
    Parameters:
4801 anupam.sin 1644 
     - statuses
483 rajveer 1645 
     - from_date
1646 
     - to_date
1647 
     - warehouse_id
94 ashish 1648 
    """
4801 anupam.sin 1649 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1650 
    return self.recv_getAllOrders()
94 ashish 1651 
 
4801 anupam.sin 1652 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1653 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1654 
    args = getAllOrders_args()
4801 anupam.sin 1655 
    args.statuses = statuses
483 rajveer 1656 
    args.from_date = from_date
1657 
    args.to_date = to_date
1658 
    args.warehouse_id = warehouse_id
94 ashish 1659 
    args.write(self._oprot)
1660 
    self._oprot.writeMessageEnd()
1661 
    self._oprot.trans.flush()
1662 
 
483 rajveer 1663 
  def recv_getAllOrders(self, ):
94 ashish 1664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1665 
    if mtype == TMessageType.EXCEPTION:
1666 
      x = TApplicationException()
1667 
      x.read(self._iprot)
1668 
      self._iprot.readMessageEnd()
1669 
      raise x
483 rajveer 1670 
    result = getAllOrders_result()
94 ashish 1671 
    result.read(self._iprot)
1672 
    self._iprot.readMessageEnd()
3431 rajveer 1673 
    if result.success is not None:
94 ashish 1674 
      return result.success
3431 rajveer 1675 
    if result.ex is not None:
94 ashish 1676 
      raise result.ex
483 rajveer 1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1678 
 
4133 chandransh 1679 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1680 
    """
1681 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1682 
    Pass the status as null and the limit as 0 to ignore them.
1683 
 
1684 
    Parameters:
1685 
     - statuses
1686 
     - offset
1687 
     - limit
1688 
     - warehouse_id
1689 
    """
1690 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1691 
    return self.recv_getOrdersInBatch()
1692 
 
1693 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1694 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1695 
    args = getOrdersInBatch_args()
1696 
    args.statuses = statuses
1697 
    args.offset = offset
1698 
    args.limit = limit
1699 
    args.warehouse_id = warehouse_id
1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_getOrdersInBatch(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = getOrdersInBatch_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
1714 
    if result.success is not None:
1715 
      return result.success
1716 
    if result.ex is not None:
1717 
      raise result.ex
1718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1719 
 
1720 
  def getOrderCount(self, statuses, warehouseId):
1721 
    """
1722 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1723 
 
1724 
    Parameters:
1725 
     - statuses
1726 
     - warehouseId
1727 
    """
1728 
    self.send_getOrderCount(statuses, warehouseId)
1729 
    return self.recv_getOrderCount()
1730 
 
1731 
  def send_getOrderCount(self, statuses, warehouseId):
1732 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1733 
    args = getOrderCount_args()
1734 
    args.statuses = statuses
1735 
    args.warehouseId = warehouseId
1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
1740 
  def recv_getOrderCount(self, ):
1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
1747 
    result = getOrderCount_result()
1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
1750 
    if result.success is not None:
1751 
      return result.success
1752 
    if result.ex is not None:
1753 
      raise result.ex
1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1755 
 
999 varun.gupt 1756 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1757 
    """
1132 chandransh 1758 
    Returns orders within a range of their billing dates
3431 rajveer 1759 
 
999 varun.gupt 1760 
    Parameters:
1761 
     - status
1762 
     - start_billing_date
1763 
     - end_billing_date
1764 
     - warehouse_id
1765 
    """
1766 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1767 
    return self.recv_getOrdersByBillingDate()
1768 
 
1769 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1770 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1771 
    args = getOrdersByBillingDate_args()
1772 
    args.status = status
1773 
    args.start_billing_date = start_billing_date
1774 
    args.end_billing_date = end_billing_date
1775 
    args.warehouse_id = warehouse_id
1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_getOrdersByBillingDate(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = getOrdersByBillingDate_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
3431 rajveer 1790 
    if result.success is not None:
999 varun.gupt 1791 
      return result.success
3431 rajveer 1792 
    if result.ex is not None:
999 varun.gupt 1793 
      raise result.ex
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1795 
 
3451 chandransh 1796 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1797 
    """
1798 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1799 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1800 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1801 
 
3427 chandransh 1802 
    Parameters:
1803 
     - fromShippingDate
1804 
     - toShippingDate
1805 
     - providerId
1806 
     - warehouseId
3451 chandransh 1807 
     - cod
3427 chandransh 1808 
    """
3451 chandransh 1809 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1810 
    return self.recv_getOrdersByShippingDate()
1811 
 
3451 chandransh 1812 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1813 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1814 
    args = getOrdersByShippingDate_args()
1815 
    args.fromShippingDate = fromShippingDate
1816 
    args.toShippingDate = toShippingDate
1817 
    args.providerId = providerId
1818 
    args.warehouseId = warehouseId
3451 chandransh 1819 
    args.cod = cod
3427 chandransh 1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
1824 
  def recv_getOrdersByShippingDate(self, ):
1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
1831 
    result = getOrdersByShippingDate_result()
1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
3431 rajveer 1834 
    if result.success is not None:
3427 chandransh 1835 
      return result.success
3431 rajveer 1836 
    if result.ex is not None:
3427 chandransh 1837 
      raise result.ex
1838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1839 
 
1382 varun.gupt 1840 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1841 
    """
1842 
    Returns order ids for orders which can be returned
3431 rajveer 1843 
 
1382 varun.gupt 1844 
    Parameters:
1845 
     - customer_id
1846 
     - limit
1847 
    """
1848 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1849 
    return self.recv_getReturnableOrdersForCustomer()
1850 
 
1851 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1852 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1853 
    args = getReturnableOrdersForCustomer_args()
1854 
    args.customer_id = customer_id
1855 
    args.limit = limit
1856 
    args.write(self._oprot)
1857 
    self._oprot.writeMessageEnd()
1858 
    self._oprot.trans.flush()
1859 
 
1860 
  def recv_getReturnableOrdersForCustomer(self, ):
1861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1862 
    if mtype == TMessageType.EXCEPTION:
1863 
      x = TApplicationException()
1864 
      x.read(self._iprot)
1865 
      self._iprot.readMessageEnd()
1866 
      raise x
1867 
    result = getReturnableOrdersForCustomer_result()
1868 
    result.read(self._iprot)
1869 
    self._iprot.readMessageEnd()
3431 rajveer 1870 
    if result.success is not None:
1382 varun.gupt 1871 
      return result.success
3431 rajveer 1872 
    if result.ex is not None:
1382 varun.gupt 1873 
      raise result.ex
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1875 
 
1876 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1877 
    """
1878 
    Returns order ids for orders which can be cancelled
3431 rajveer 1879 
 
1382 varun.gupt 1880 
    Parameters:
1881 
     - customer_id
1882 
     - limit
1883 
    """
1884 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1885 
    return self.recv_getCancellableOrdersForCustomer()
1886 
 
1887 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1888 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1889 
    args = getCancellableOrdersForCustomer_args()
1890 
    args.customer_id = customer_id
1891 
    args.limit = limit
1892 
    args.write(self._oprot)
1893 
    self._oprot.writeMessageEnd()
1894 
    self._oprot.trans.flush()
1895 
 
1896 
  def recv_getCancellableOrdersForCustomer(self, ):
1897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1898 
    if mtype == TMessageType.EXCEPTION:
1899 
      x = TApplicationException()
1900 
      x.read(self._iprot)
1901 
      self._iprot.readMessageEnd()
1902 
      raise x
1903 
    result = getCancellableOrdersForCustomer_result()
1904 
    result.read(self._iprot)
1905 
    self._iprot.readMessageEnd()
3431 rajveer 1906 
    if result.success is not None:
1382 varun.gupt 1907 
      return result.success
3431 rajveer 1908 
    if result.ex is not None:
1382 varun.gupt 1909 
      raise result.ex
1910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1911 
 
483 rajveer 1912 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1913 
    """
1914 
    Parameters:
483 rajveer 1915 
     - orderId
1916 
     - status
1917 
     - description
94 ashish 1918 
    """
483 rajveer 1919 
    self.send_changeOrderStatus(orderId, status, description)
1920 
    return self.recv_changeOrderStatus()
94 ashish 1921 
 
483 rajveer 1922 
  def send_changeOrderStatus(self, orderId, status, description):
1923 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1924 
    args = changeOrderStatus_args()
1925 
    args.orderId = orderId
1926 
    args.status = status
1927 
    args.description = description
94 ashish 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
483 rajveer 1932 
  def recv_changeOrderStatus(self, ):
94 ashish 1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
483 rajveer 1939 
    result = changeOrderStatus_result()
94 ashish 1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
3431 rajveer 1942 
    if result.success is not None:
94 ashish 1943 
      return result.success
3431 rajveer 1944 
    if result.ex is not None:
94 ashish 1945 
      raise result.ex
483 rajveer 1946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1947 
 
1528 ankur.sing 1948 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1949 
    """
1528 ankur.sing 1950 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1951 
    only user who owns the transaction can view its order details.
3431 rajveer 1952 
 
94 ashish 1953 
    Parameters:
1954 
     - transactionId
1528 ankur.sing 1955 
     - customerId
94 ashish 1956 
    """
1528 ankur.sing 1957 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1958 
    return self.recv_getOrdersForTransaction()
94 ashish 1959 
 
1528 ankur.sing 1960 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1961 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1962 
    args = getOrdersForTransaction_args()
94 ashish 1963 
    args.transactionId = transactionId
1528 ankur.sing 1964 
    args.customerId = customerId
94 ashish 1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
483 rajveer 1969 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
483 rajveer 1976 
    result = getOrdersForTransaction_result()
94 ashish 1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
3431 rajveer 1979 
    if result.success is not None:
94 ashish 1980 
      return result.success
3431 rajveer 1981 
    if result.ex is not None:
94 ashish 1982 
      raise result.ex
483 rajveer 1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1984 
 
3014 chandransh 1985 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1986 
    """
3014 chandransh 1987 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1988 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1989 
 
94 ashish 1990 
    Parameters:
483 rajveer 1991 
     - customerId
1992 
     - from_date
1993 
     - to_date
3014 chandransh 1994 
     - statuses
94 ashish 1995 
    """
3014 chandransh 1996 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1997 
    return self.recv_getOrdersForCustomer()
94 ashish 1998 
 
3014 chandransh 1999 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2000 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2001 
    args = getOrdersForCustomer_args()
2002 
    args.customerId = customerId
2003 
    args.from_date = from_date
2004 
    args.to_date = to_date
3014 chandransh 2005 
    args.statuses = statuses
94 ashish 2006 
    args.write(self._oprot)
2007 
    self._oprot.writeMessageEnd()
2008 
    self._oprot.trans.flush()
2009 
 
483 rajveer 2010 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2012 
    if mtype == TMessageType.EXCEPTION:
2013 
      x = TApplicationException()
2014 
      x.read(self._iprot)
2015 
      self._iprot.readMessageEnd()
2016 
      raise x
483 rajveer 2017 
    result = getOrdersForCustomer_result()
94 ashish 2018 
    result.read(self._iprot)
2019 
    self._iprot.readMessageEnd()
3431 rajveer 2020 
    if result.success is not None:
94 ashish 2021 
      return result.success
3431 rajveer 2022 
    if result.ex is not None:
94 ashish 2023 
      raise result.ex
483 rajveer 2024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2025 
 
483 rajveer 2026 
  def createOrder(self, order):
94 ashish 2027 
    """
2028 
    Parameters:
483 rajveer 2029 
     - order
94 ashish 2030 
    """
483 rajveer 2031 
    self.send_createOrder(order)
2032 
    return self.recv_createOrder()
94 ashish 2033 
 
483 rajveer 2034 
  def send_createOrder(self, order):
2035 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2036 
    args = createOrder_args()
2037 
    args.order = order
94 ashish 2038 
    args.write(self._oprot)
2039 
    self._oprot.writeMessageEnd()
2040 
    self._oprot.trans.flush()
2041 
 
483 rajveer 2042 
  def recv_createOrder(self, ):
94 ashish 2043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2044 
    if mtype == TMessageType.EXCEPTION:
2045 
      x = TApplicationException()
2046 
      x.read(self._iprot)
2047 
      self._iprot.readMessageEnd()
2048 
      raise x
483 rajveer 2049 
    result = createOrder_result()
94 ashish 2050 
    result.read(self._iprot)
2051 
    self._iprot.readMessageEnd()
3431 rajveer 2052 
    if result.success is not None:
94 ashish 2053 
      return result.success
3431 rajveer 2054 
    if result.ex is not None:
94 ashish 2055 
      raise result.ex
483 rajveer 2056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2057 
 
483 rajveer 2058 
  def getOrder(self, id):
94 ashish 2059 
    """
2060 
    Parameters:
483 rajveer 2061 
     - id
94 ashish 2062 
    """
483 rajveer 2063 
    self.send_getOrder(id)
2064 
    return self.recv_getOrder()
94 ashish 2065 
 
483 rajveer 2066 
  def send_getOrder(self, id):
2067 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2068 
    args = getOrder_args()
2069 
    args.id = id
94 ashish 2070 
    args.write(self._oprot)
2071 
    self._oprot.writeMessageEnd()
2072 
    self._oprot.trans.flush()
2073 
 
483 rajveer 2074 
  def recv_getOrder(self, ):
94 ashish 2075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2076 
    if mtype == TMessageType.EXCEPTION:
2077 
      x = TApplicationException()
2078 
      x.read(self._iprot)
2079 
      self._iprot.readMessageEnd()
2080 
      raise x
483 rajveer 2081 
    result = getOrder_result()
94 ashish 2082 
    result.read(self._iprot)
2083 
    self._iprot.readMessageEnd()
3431 rajveer 2084 
    if result.success is not None:
94 ashish 2085 
      return result.success
3431 rajveer 2086 
    if result.ex is not None:
94 ashish 2087 
      raise result.ex
483 rajveer 2088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2089 
 
483 rajveer 2090 
  def getLineItemsForOrder(self, orderId):
94 ashish 2091 
    """
2092 
    Parameters:
483 rajveer 2093 
     - orderId
94 ashish 2094 
    """
483 rajveer 2095 
    self.send_getLineItemsForOrder(orderId)
2096 
    return self.recv_getLineItemsForOrder()
94 ashish 2097 
 
483 rajveer 2098 
  def send_getLineItemsForOrder(self, orderId):
2099 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2100 
    args = getLineItemsForOrder_args()
2101 
    args.orderId = orderId
94 ashish 2102 
    args.write(self._oprot)
2103 
    self._oprot.writeMessageEnd()
2104 
    self._oprot.trans.flush()
2105 
 
483 rajveer 2106 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2108 
    if mtype == TMessageType.EXCEPTION:
2109 
      x = TApplicationException()
2110 
      x.read(self._iprot)
2111 
      self._iprot.readMessageEnd()
2112 
      raise x
483 rajveer 2113 
    result = getLineItemsForOrder_result()
94 ashish 2114 
    result.read(self._iprot)
2115 
    self._iprot.readMessageEnd()
3431 rajveer 2116 
    if result.success is not None:
94 ashish 2117 
      return result.success
3431 rajveer 2118 
    if result.ex is not None:
94 ashish 2119 
      raise result.ex
483 rajveer 2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2121 
 
4999 phani.kuma 2122 
  def getOrderList(self, order_ids):
2123 
    """
2124 
    Parameters:
2125 
     - order_ids
2126 
    """
2127 
    self.send_getOrderList(order_ids)
2128 
    return self.recv_getOrderList()
2129 
 
2130 
  def send_getOrderList(self, order_ids):
2131 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2132 
    args = getOrderList_args()
2133 
    args.order_ids = order_ids
2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
2138 
  def recv_getOrderList(self, ):
2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
2145 
    result = getOrderList_result()
2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
2148 
    if result.success is not None:
2149 
      return result.success
2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2151 
 
5386 phani.kuma 2152 
  def getOrderListForVendor(self, order_ids, vendorId):
2153 
    """
2154 
    Parameters:
2155 
     - order_ids
2156 
     - vendorId
2157 
    """
2158 
    self.send_getOrderListForVendor(order_ids, vendorId)
2159 
    return self.recv_getOrderListForVendor()
2160 
 
2161 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2162 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2163 
    args = getOrderListForVendor_args()
2164 
    args.order_ids = order_ids
2165 
    args.vendorId = vendorId
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_getOrderListForVendor(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = getOrderListForVendor_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
2180 
    if result.success is not None:
2181 
      return result.success
2182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2183 
 
1528 ankur.sing 2184 
  def getOrderForCustomer(self, orderId, customerId):
2185 
    """
2186 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2187 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2188 
 
1528 ankur.sing 2189 
    Parameters:
2190 
     - orderId
2191 
     - customerId
2192 
    """
2193 
    self.send_getOrderForCustomer(orderId, customerId)
2194 
    return self.recv_getOrderForCustomer()
2195 
 
2196 
  def send_getOrderForCustomer(self, orderId, customerId):
2197 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2198 
    args = getOrderForCustomer_args()
2199 
    args.orderId = orderId
2200 
    args.customerId = customerId
2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
2205 
  def recv_getOrderForCustomer(self, ):
2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
2212 
    result = getOrderForCustomer_result()
2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
3431 rajveer 2215 
    if result.success is not None:
1528 ankur.sing 2216 
      return result.success
3431 rajveer 2217 
    if result.ex is not None:
1528 ankur.sing 2218 
      raise result.ex
2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2220 
 
4444 rajveer 2221 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2222 
    """
2223 
    Parameters:
4394 rajveer 2224 
     - type
4444 rajveer 2225 
     - warehouseId
4394 rajveer 2226 
     - status
2227 
     - timestamp
3064 chandransh 2228 
    """
4444 rajveer 2229 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2230 
    return self.recv_getAlerts()
2231 
 
4444 rajveer 2232 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2233 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2234 
    args = getAlerts_args()
4394 rajveer 2235 
    args.type = type
4444 rajveer 2236 
    args.warehouseId = warehouseId
4394 rajveer 2237 
    args.status = status
2238 
    args.timestamp = timestamp
3064 chandransh 2239 
    args.write(self._oprot)
2240 
    self._oprot.writeMessageEnd()
2241 
    self._oprot.trans.flush()
2242 
 
2243 
  def recv_getAlerts(self, ):
2244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2245 
    if mtype == TMessageType.EXCEPTION:
2246 
      x = TApplicationException()
2247 
      x.read(self._iprot)
2248 
      self._iprot.readMessageEnd()
2249 
      raise x
2250 
    result = getAlerts_result()
2251 
    result.read(self._iprot)
2252 
    self._iprot.readMessageEnd()
3431 rajveer 2253 
    if result.success is not None:
3064 chandransh 2254 
      return result.success
2255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2256 
 
4444 rajveer 2257 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2258 
    """
2259 
    Parameters:
2260 
     - type
4444 rajveer 2261 
     - warehouseId
4394 rajveer 2262 
     - description
3064 chandransh 2263 
    """
4444 rajveer 2264 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2265 
    self.recv_addAlert()
3064 chandransh 2266 
 
4444 rajveer 2267 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2268 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2269 
    args = addAlert_args()
3064 chandransh 2270 
    args.type = type
4444 rajveer 2271 
    args.warehouseId = warehouseId
4394 rajveer 2272 
    args.description = description
3064 chandransh 2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
4394 rajveer 2277 
  def recv_addAlert(self, ):
3064 chandransh 2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
4394 rajveer 2284 
    result = addAlert_result()
3064 chandransh 2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    return
2288 
 
4444 rajveer 2289 
  def markAlertsAsSeen(self, warehouseId):
2290 
    """
2291 
    Parameters:
2292 
     - warehouseId
2293 
    """
2294 
    self.send_markAlertsAsSeen(warehouseId)
2295 
    self.recv_markAlertsAsSeen()
2296 
 
2297 
  def send_markAlertsAsSeen(self, warehouseId):
2298 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2299 
    args = markAlertsAsSeen_args()
2300 
    args.warehouseId = warehouseId
2301 
    args.write(self._oprot)
2302 
    self._oprot.writeMessageEnd()
2303 
    self._oprot.trans.flush()
2304 
 
2305 
  def recv_markAlertsAsSeen(self, ):
2306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2307 
    if mtype == TMessageType.EXCEPTION:
2308 
      x = TApplicationException()
2309 
      x.read(self._iprot)
2310 
      self._iprot.readMessageEnd()
2311 
      raise x
2312 
    result = markAlertsAsSeen_result()
2313 
    result.read(self._iprot)
2314 
    self._iprot.readMessageEnd()
2315 
    return
2316 
 
3064 chandransh 2317 
  def getValidOrderCount(self, ):
2318 
    """
2319 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2320 
    """
2321 
    self.send_getValidOrderCount()
2322 
    return self.recv_getValidOrderCount()
2323 
 
2324 
  def send_getValidOrderCount(self, ):
2325 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2326 
    args = getValidOrderCount_args()
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_getValidOrderCount(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = getValidOrderCount_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
3431 rajveer 2341 
    if result.success is not None:
3064 chandransh 2342 
      return result.success
2343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2344 
 
2345 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2346 
    """
2347 
    Returns the number of distinct customers who have done successful transactions
2348 
    """
2349 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2350 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2351 
 
2352 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2353 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2354 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2355 
    args.write(self._oprot)
2356 
    self._oprot.writeMessageEnd()
2357 
    self._oprot.trans.flush()
2358 
 
2359 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2361 
    if mtype == TMessageType.EXCEPTION:
2362 
      x = TApplicationException()
2363 
      x.read(self._iprot)
2364 
      self._iprot.readMessageEnd()
2365 
      raise x
2366 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2367 
    result.read(self._iprot)
2368 
    self._iprot.readMessageEnd()
3431 rajveer 2369 
    if result.success is not None:
3064 chandransh 2370 
      return result.success
2371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2372 
 
2373 
  def getValidOrdersAmountRange(self, ):
2374 
    """
2375 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2376 
    List contains two values, first minimum amount and second maximum amount.
2377 
    """
2378 
    self.send_getValidOrdersAmountRange()
2379 
    return self.recv_getValidOrdersAmountRange()
2380 
 
2381 
  def send_getValidOrdersAmountRange(self, ):
2382 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2383 
    args = getValidOrdersAmountRange_args()
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_getValidOrdersAmountRange(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = getValidOrdersAmountRange_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.success is not None:
3064 chandransh 2399 
      return result.success
2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2401 
 
5874 rajveer 2402 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2403 
    """
2404 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2405 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2406 
 
3064 chandransh 2407 
    Parameters:
2408 
     - limit
5874 rajveer 2409 
     - onlyStore
3064 chandransh 2410 
    """
5874 rajveer 2411 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2412 
    return self.recv_getValidOrders()
2413 
 
5874 rajveer 2414 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2415 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2416 
    args = getValidOrders_args()
2417 
    args.limit = limit
5874 rajveer 2418 
    args.onlyStore = onlyStore
3064 chandransh 2419 
    args.write(self._oprot)
2420 
    self._oprot.writeMessageEnd()
2421 
    self._oprot.trans.flush()
2422 
 
2423 
  def recv_getValidOrders(self, ):
2424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2425 
    if mtype == TMessageType.EXCEPTION:
2426 
      x = TApplicationException()
2427 
      x.read(self._iprot)
2428 
      self._iprot.readMessageEnd()
2429 
      raise x
2430 
    result = getValidOrders_result()
2431 
    result.read(self._iprot)
2432 
    self._iprot.readMessageEnd()
3431 rajveer 2433 
    if result.success is not None:
3064 chandransh 2434 
      return result.success
2435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2436 
 
1220 chandransh 2437 
  def batchOrders(self, warehouseId):
2438 
    """
2439 
    Create a batch of all the pending orders for the given warehouse.
2440 
    The returned list is orderd by created_timestamp.
2441 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2442 
 
1220 chandransh 2443 
    Parameters:
2444 
     - warehouseId
2445 
    """
2446 
    self.send_batchOrders(warehouseId)
2447 
    return self.recv_batchOrders()
2448 
 
2449 
  def send_batchOrders(self, warehouseId):
2450 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2451 
    args = batchOrders_args()
2452 
    args.warehouseId = warehouseId
2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
2457 
  def recv_batchOrders(self, ):
2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
2464 
    result = batchOrders_result()
2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
3431 rajveer 2467 
    if result.success is not None:
1220 chandransh 2468 
      return result.success
3431 rajveer 2469 
    if result.ex is not None:
1220 chandransh 2470 
      raise result.ex
2471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2472 
 
1208 chandransh 2473 
  def markOrderAsOutOfStock(self, orderId):
2474 
    """
2475 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2476 
 
1208 chandransh 2477 
    Parameters:
2478 
     - orderId
2479 
    """
2480 
    self.send_markOrderAsOutOfStock(orderId)
2481 
    return self.recv_markOrderAsOutOfStock()
2482 
 
2483 
  def send_markOrderAsOutOfStock(self, orderId):
2484 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2485 
    args = markOrderAsOutOfStock_args()
2486 
    args.orderId = orderId
2487 
    args.write(self._oprot)
2488 
    self._oprot.writeMessageEnd()
2489 
    self._oprot.trans.flush()
2490 
 
2491 
  def recv_markOrderAsOutOfStock(self, ):
2492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2493 
    if mtype == TMessageType.EXCEPTION:
2494 
      x = TApplicationException()
2495 
      x.read(self._iprot)
2496 
      self._iprot.readMessageEnd()
2497 
      raise x
2498 
    result = markOrderAsOutOfStock_result()
2499 
    result.read(self._iprot)
2500 
    self._iprot.readMessageEnd()
3431 rajveer 2501 
    if result.success is not None:
1208 chandransh 2502 
      return result.success
3431 rajveer 2503 
    if result.ex is not None:
1208 chandransh 2504 
      raise result.ex
2505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2506 
 
3064 chandransh 2507 
  def verifyOrder(self, orderId):
759 chandransh 2508 
    """
3064 chandransh 2509 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2510 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2511 
    used for all other orders as well.
2512 
    Throws an exception if no such order exists.
3431 rajveer 2513 
 
759 chandransh 2514 
    Parameters:
3064 chandransh 2515 
     - orderId
759 chandransh 2516 
    """
3064 chandransh 2517 
    self.send_verifyOrder(orderId)
2518 
    return self.recv_verifyOrder()
759 chandransh 2519 
 
3064 chandransh 2520 
  def send_verifyOrder(self, orderId):
2521 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2522 
    args = verifyOrder_args()
2523 
    args.orderId = orderId
759 chandransh 2524 
    args.write(self._oprot)
2525 
    self._oprot.writeMessageEnd()
2526 
    self._oprot.trans.flush()
2527 
 
3064 chandransh 2528 
  def recv_verifyOrder(self, ):
759 chandransh 2529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2530 
    if mtype == TMessageType.EXCEPTION:
2531 
      x = TApplicationException()
2532 
      x.read(self._iprot)
2533 
      self._iprot.readMessageEnd()
2534 
      raise x
3064 chandransh 2535 
    result = verifyOrder_result()
759 chandransh 2536 
    result.read(self._iprot)
2537 
    self._iprot.readMessageEnd()
3431 rajveer 2538 
    if result.success is not None:
759 chandransh 2539 
      return result.success
3431 rajveer 2540 
    if result.ex is not None:
759 chandransh 2541 
      raise result.ex
3064 chandransh 2542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2543 
 
3064 chandransh 2544 
  def acceptOrder(self, orderId):
1113 chandransh 2545 
    """
3064 chandransh 2546 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2547 
    given order is not a COD order, it also captures the payment if the same has
2548 
    not been captured.
2549 
    Throws an exception if no such order exists.
3431 rajveer 2550 
 
1113 chandransh 2551 
    Parameters:
3064 chandransh 2552 
     - orderId
1113 chandransh 2553 
    """
3064 chandransh 2554 
    self.send_acceptOrder(orderId)
2555 
    return self.recv_acceptOrder()
1113 chandransh 2556 
 
3064 chandransh 2557 
  def send_acceptOrder(self, orderId):
2558 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2559 
    args = acceptOrder_args()
2560 
    args.orderId = orderId
1113 chandransh 2561 
    args.write(self._oprot)
2562 
    self._oprot.writeMessageEnd()
2563 
    self._oprot.trans.flush()
2564 
 
3064 chandransh 2565 
  def recv_acceptOrder(self, ):
1113 chandransh 2566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2567 
    if mtype == TMessageType.EXCEPTION:
2568 
      x = TApplicationException()
2569 
      x.read(self._iprot)
2570 
      self._iprot.readMessageEnd()
2571 
      raise x
3064 chandransh 2572 
    result = acceptOrder_result()
1113 chandransh 2573 
    result.read(self._iprot)
2574 
    self._iprot.readMessageEnd()
3431 rajveer 2575 
    if result.success is not None:
1113 chandransh 2576 
      return result.success
3431 rajveer 2577 
    if result.ex is not None:
1113 chandransh 2578 
      raise result.ex
3064 chandransh 2579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2580 
 
5110 mandeep.dh 2581 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2582 
    """
3064 chandransh 2583 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2584 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2585 
    the IMEI no. if a -1 is supplied.
2586 
    Also, it generates an invoice number for the order, marks the order as
2587 
    BILLED and sets the billing timestamp.
2588 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2589 
 
1135 chandransh 2590 
    Parameters:
3064 chandransh 2591 
     - orderId
2592 
     - invoice_number
4658 mandeep.dh 2593 
     - serialNumber
4283 anupam.sin 2594 
     - itemNumber
3064 chandransh 2595 
     - billed_by
4264 rajveer 2596 
     - jacketNumber
4283 anupam.sin 2597 
     - billingType
5110 mandeep.dh 2598 
     - fulfilmentWarehouseId
4763 rajveer 2599 
     - authorize
1135 chandransh 2600 
    """
5110 mandeep.dh 2601 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2602 
    return self.recv_addBillingDetails()
1135 chandransh 2603 
 
5110 mandeep.dh 2604 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2605 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2606 
    args = addBillingDetails_args()
2607 
    args.orderId = orderId
2608 
    args.invoice_number = invoice_number
4658 mandeep.dh 2609 
    args.serialNumber = serialNumber
4283 anupam.sin 2610 
    args.itemNumber = itemNumber
3064 chandransh 2611 
    args.billed_by = billed_by
4264 rajveer 2612 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2613 
    args.billingType = billingType
5110 mandeep.dh 2614 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2615 
    args.authorize = authorize
1135 chandransh 2616 
    args.write(self._oprot)
2617 
    self._oprot.writeMessageEnd()
2618 
    self._oprot.trans.flush()
2619 
 
3064 chandransh 2620 
  def recv_addBillingDetails(self, ):
1135 chandransh 2621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2622 
    if mtype == TMessageType.EXCEPTION:
2623 
      x = TApplicationException()
2624 
      x.read(self._iprot)
2625 
      self._iprot.readMessageEnd()
2626 
      raise x
3064 chandransh 2627 
    result = addBillingDetails_result()
1135 chandransh 2628 
    result.read(self._iprot)
2629 
    self._iprot.readMessageEnd()
3431 rajveer 2630 
    if result.success is not None:
3064 chandransh 2631 
      return result.success
3431 rajveer 2632 
    if result.ex is not None:
1135 chandransh 2633 
      raise result.ex
3064 chandransh 2634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2635 
 
4763 rajveer 2636 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2637 
    """
2638 
    Add the invoice number to the order.
2639 
 
2640 
    Parameters:
2641 
     - orderId
2642 
     - invoiceNumber
4763 rajveer 2643 
     - color
4579 rajveer 2644 
    """
4763 rajveer 2645 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2646 
    self.recv_addInvoiceNumber()
2647 
 
4763 rajveer 2648 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2649 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2650 
    args = addInvoiceNumber_args()
2651 
    args.orderId = orderId
2652 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2653 
    args.color = color
4579 rajveer 2654 
    args.write(self._oprot)
2655 
    self._oprot.writeMessageEnd()
2656 
    self._oprot.trans.flush()
2657 
 
2658 
  def recv_addInvoiceNumber(self, ):
2659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2660 
    if mtype == TMessageType.EXCEPTION:
2661 
      x = TApplicationException()
2662 
      x.read(self._iprot)
2663 
      self._iprot.readMessageEnd()
2664 
      raise x
2665 
    result = addInvoiceNumber_result()
2666 
    result.read(self._iprot)
2667 
    self._iprot.readMessageEnd()
2668 
    if result.ex is not None:
2669 
      raise result.ex
2670 
    return
2671 
 
4910 phani.kuma 2672 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2673 
    """
3064 chandransh 2674 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2675 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2676 
 
1408 ankur.sing 2677 
    Parameters:
3064 chandransh 2678 
     - warehouseId
1408 ankur.sing 2679 
     - providerId
3064 chandransh 2680 
     - cod
4910 phani.kuma 2681 
     - orderIds
1408 ankur.sing 2682 
    """
4910 phani.kuma 2683 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2684 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2685 
 
4910 phani.kuma 2686 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2687 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2688 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2689 
    args.warehouseId = warehouseId
1408 ankur.sing 2690 
    args.providerId = providerId
3064 chandransh 2691 
    args.cod = cod
4910 phani.kuma 2692 
    args.orderIds = orderIds
1408 ankur.sing 2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
4910 phani.kuma 2697 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
4910 phani.kuma 2704 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
3431 rajveer 2707 
    if result.success is not None:
1408 ankur.sing 2708 
      return result.success
3431 rajveer 2709 
    if result.ex is not None:
3064 chandransh 2710 
      raise result.ex
4910 phani.kuma 2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2712 
 
5713 rajveer 2713 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2714 
    """
2715 
    Parameters:
2716 
     - providerId
2717 
     - orderIds
5713 rajveer 2718 
     - awbs
5676 rajveer 2719 
    """
5713 rajveer 2720 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2721 
    return self.recv_markOrdersAsReturnedFromStore()
2722 
 
5713 rajveer 2723 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2724 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2725 
    args = markOrdersAsReturnedFromStore_args()
2726 
    args.providerId = providerId
2727 
    args.orderIds = orderIds
5713 rajveer 2728 
    args.awbs = awbs
5676 rajveer 2729 
    args.write(self._oprot)
2730 
    self._oprot.writeMessageEnd()
2731 
    self._oprot.trans.flush()
2732 
 
2733 
  def recv_markOrdersAsReturnedFromStore(self, ):
2734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2735 
    if mtype == TMessageType.EXCEPTION:
2736 
      x = TApplicationException()
2737 
      x.read(self._iprot)
2738 
      self._iprot.readMessageEnd()
2739 
      raise x
2740 
    result = markOrdersAsReturnedFromStore_result()
2741 
    result.read(self._iprot)
2742 
    self._iprot.readMessageEnd()
2743 
    if result.success is not None:
2744 
      return result.success
2745 
    if result.ex is not None:
2746 
      raise result.ex
2747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2748 
 
4910 phani.kuma 2749 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2750 
    """
4910 phani.kuma 2751 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2752 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2753 
 
2754 
    Parameters:
2755 
     - providerId
4910 phani.kuma 2756 
     - pickupDetails
4410 rajveer 2757 
    """
4910 phani.kuma 2758 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2759 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2760 
 
4910 phani.kuma 2761 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2762 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2763 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2764 
    args.providerId = providerId
4910 phani.kuma 2765 
    args.pickupDetails = pickupDetails
4410 rajveer 2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
4910 phani.kuma 2770 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
4910 phani.kuma 2777 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
2780 
    if result.ex is not None:
2781 
      raise result.ex
4910 phani.kuma 2782 
    return
4410 rajveer 2783 
 
4910 phani.kuma 2784 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2785 
    """
3064 chandransh 2786 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2787 
 
94 ashish 2788 
    Parameters:
3064 chandransh 2789 
     - providerId
304 ashish 2790 
    """
4910 phani.kuma 2791 
    self.send_getOrdersNotPickedUp(providerId)
2792 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2793 
 
4910 phani.kuma 2794 
  def send_getOrdersNotPickedUp(self, providerId):
2795 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2796 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2797 
    args.providerId = providerId
304 ashish 2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
4910 phani.kuma 2802 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
4910 phani.kuma 2809 
    result = getOrdersNotPickedUp_result()
304 ashish 2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
3431 rajveer 2812 
    if result.success is not None:
304 ashish 2813 
      return result.success
4910 phani.kuma 2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2815 
 
3064 chandransh 2816 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2817 
    """
3064 chandransh 2818 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2819 
    the name of the receiver.
2820 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2821 
 
304 ashish 2822 
    Parameters:
3064 chandransh 2823 
     - providerId
2824 
     - deliveredOrders
304 ashish 2825 
    """
3064 chandransh 2826 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2827 
    self.recv_markOrdersAsDelivered()
304 ashish 2828 
 
3064 chandransh 2829 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2830 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2831 
    args = markOrdersAsDelivered_args()
2832 
    args.providerId = providerId
2833 
    args.deliveredOrders = deliveredOrders
304 ashish 2834 
    args.write(self._oprot)
2835 
    self._oprot.writeMessageEnd()
2836 
    self._oprot.trans.flush()
2837 
 
3064 chandransh 2838 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2840 
    if mtype == TMessageType.EXCEPTION:
2841 
      x = TApplicationException()
2842 
      x.read(self._iprot)
2843 
      self._iprot.readMessageEnd()
2844 
      raise x
3064 chandransh 2845 
    result = markOrdersAsDelivered_result()
304 ashish 2846 
    result.read(self._iprot)
2847 
    self._iprot.readMessageEnd()
3431 rajveer 2848 
    if result.ex is not None:
3064 chandransh 2849 
      raise result.ex
304 ashish 2850 
    return
2851 
 
4910 phani.kuma 2852 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2853 
    """
4910 phani.kuma 2854 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2855 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2856 
 
3064 chandransh 2857 
    Parameters:
2858 
     - providerId
2859 
     - returnedOrders
1596 ankur.sing 2860 
    """
4910 phani.kuma 2861 
    self.send_markAsRTOrders(providerId, returnedOrders)
2862 
    self.recv_markAsRTOrders()
304 ashish 2863 
 
4910 phani.kuma 2864 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2865 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2866 
    args = markAsRTOrders_args()
3064 chandransh 2867 
    args.providerId = providerId
2868 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
4910 phani.kuma 2873 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
4910 phani.kuma 2880 
    result = markAsRTOrders_result()
1596 ankur.sing 2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
3431 rajveer 2883 
    if result.ex is not None:
3064 chandransh 2884 
      raise result.ex
2885 
    return
1596 ankur.sing 2886 
 
4910 phani.kuma 2887 
  def getRTOrders(self, providerId):
2888 
    """
2889 
    Returns a list of orders that were returned by courier.
2890 
 
2891 
    Parameters:
2892 
     - providerId
2893 
    """
2894 
    self.send_getRTOrders(providerId)
2895 
    return self.recv_getRTOrders()
2896 
 
2897 
  def send_getRTOrders(self, providerId):
2898 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2899 
    args = getRTOrders_args()
2900 
    args.providerId = providerId
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getRTOrders(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getRTOrders_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2918 
 
3064 chandransh 2919 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2920 
    """
3064 chandransh 2921 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2922 
 
3064 chandransh 2923 
    Parameters:
2924 
     - providerId
2925 
     - undeliveredOrders
1627 ankur.sing 2926 
    """
3064 chandransh 2927 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2928 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2929 
 
3064 chandransh 2930 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2931 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2932 
    args = updateNonDeliveryReason_args()
2933 
    args.providerId = providerId
2934 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2935 
    args.write(self._oprot)
2936 
    self._oprot.writeMessageEnd()
2937 
    self._oprot.trans.flush()
2938 
 
3064 chandransh 2939 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2941 
    if mtype == TMessageType.EXCEPTION:
2942 
      x = TApplicationException()
2943 
      x.read(self._iprot)
2944 
      self._iprot.readMessageEnd()
2945 
      raise x
3064 chandransh 2946 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2947 
    result.read(self._iprot)
2948 
    self._iprot.readMessageEnd()
4910 phani.kuma 2949 
    if result.ex is not None:
2950 
      raise result.ex
2951 
    return
2952 
 
2953 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2954 
    """
2955 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2956 
 
2957 
    Parameters:
2958 
     - providerId
2959 
    """
2960 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2961 
    return self.recv_getNonDeliveredOrdersbyCourier()
2962 
 
2963 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2964 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2965 
    args = getNonDeliveredOrdersbyCourier_args()
2966 
    args.providerId = providerId
2967 
    args.write(self._oprot)
2968 
    self._oprot.writeMessageEnd()
2969 
    self._oprot.trans.flush()
2970 
 
2971 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2973 
    if mtype == TMessageType.EXCEPTION:
2974 
      x = TApplicationException()
2975 
      x.read(self._iprot)
2976 
      self._iprot.readMessageEnd()
2977 
      raise x
2978 
    result = getNonDeliveredOrdersbyCourier_result()
2979 
    result.read(self._iprot)
2980 
    self._iprot.readMessageEnd()
4581 phani.kuma 2981 
    if result.success is not None:
2982 
      return result.success
4910 phani.kuma 2983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2984 
 
2985 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2986 
    """
2987 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2988 
 
2989 
    Parameters:
2990 
     - providerId
2991 
     - local_connected_orders
2992 
    """
2993 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2994 
    self.recv_markOrdersAsLocalConnected()
2995 
 
2996 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2997 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2998 
    args = markOrdersAsLocalConnected_args()
2999 
    args.providerId = providerId
3000 
    args.local_connected_orders = local_connected_orders
3001 
    args.write(self._oprot)
3002 
    self._oprot.writeMessageEnd()
3003 
    self._oprot.trans.flush()
3004 
 
3005 
  def recv_markOrdersAsLocalConnected(self, ):
3006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3007 
    if mtype == TMessageType.EXCEPTION:
3008 
      x = TApplicationException()
3009 
      x.read(self._iprot)
3010 
      self._iprot.readMessageEnd()
3011 
      raise x
3012 
    result = markOrdersAsLocalConnected_result()
3013 
    result.read(self._iprot)
3014 
    self._iprot.readMessageEnd()
3431 rajveer 3015 
    if result.ex is not None:
3064 chandransh 3016 
      raise result.ex
4910 phani.kuma 3017 
    return
1627 ankur.sing 3018 
 
4910 phani.kuma 3019 
  def getOrdersNotLocalConnected(self, providerId):
3020 
    """
3021 
    Returns a list of orders that were picked up or shipped but pending local connection.
3022 
 
3023 
    Parameters:
3024 
     - providerId
3025 
    """
3026 
    self.send_getOrdersNotLocalConnected(providerId)
3027 
    return self.recv_getOrdersNotLocalConnected()
3028 
 
3029 
  def send_getOrdersNotLocalConnected(self, providerId):
3030 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3031 
    args = getOrdersNotLocalConnected_args()
3032 
    args.providerId = providerId
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_getOrdersNotLocalConnected(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = getOrdersNotLocalConnected_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3050 
 
3051 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3052 
    """
3053 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3054 
 
3055 
    Parameters:
3056 
     - providerId
3057 
     - destination_city_reached_orders
3058 
    """
3059 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3060 
    self.recv_markOrdersAsDestinationCityReached()
3061 
 
3062 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3063 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3064 
    args = markOrdersAsDestinationCityReached_args()
3065 
    args.providerId = providerId
3066 
    args.destination_city_reached_orders = destination_city_reached_orders
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_markOrdersAsDestinationCityReached(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = markOrdersAsDestinationCityReached_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    if result.ex is not None:
3082 
      raise result.ex
3083 
    return
3084 
 
3085 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3086 
    """
3087 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3088 
 
3089 
    Parameters:
3090 
     - providerId
3091 
     - first_atdl_orders
3092 
    """
3093 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3094 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3095 
 
3096 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3097 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3098 
    args = markOrdersAsFirstDeliveryAttempted_args()
3099 
    args.providerId = providerId
3100 
    args.first_atdl_orders = first_atdl_orders
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = markOrdersAsFirstDeliveryAttempted_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.ex is not None:
3116 
      raise result.ex
3117 
    return
3118 
 
3064 chandransh 3119 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3120 
    """
3064 chandransh 3121 
    Returns the list of orders whose delivery time has passed but have not been
3122 
    delivered yet for the given provider and warehouse. To get a complete list of
3123 
    undelivered orders, pass them as -1.
3124 
    Returns an empty list if no such orders exist.
3431 rajveer 3125 
 
1886 ankur.sing 3126 
    Parameters:
3064 chandransh 3127 
     - providerId
3128 
     - warehouseId
1886 ankur.sing 3129 
    """
3064 chandransh 3130 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3131 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3132 
 
3064 chandransh 3133 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3134 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3135 
    args = getUndeliveredOrders_args()
3136 
    args.providerId = providerId
3137 
    args.warehouseId = warehouseId
1886 ankur.sing 3138 
    args.write(self._oprot)
3139 
    self._oprot.writeMessageEnd()
3140 
    self._oprot.trans.flush()
3141 
 
3064 chandransh 3142 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3144 
    if mtype == TMessageType.EXCEPTION:
3145 
      x = TApplicationException()
3146 
      x.read(self._iprot)
3147 
      self._iprot.readMessageEnd()
3148 
      raise x
3064 chandransh 3149 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3150 
    result.read(self._iprot)
3151 
    self._iprot.readMessageEnd()
3431 rajveer 3152 
    if result.success is not None:
1886 ankur.sing 3153 
      return result.success
3064 chandransh 3154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3155 
 
4783 phani.kuma 3156 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3157 
    """
3158 
    Returns the list of orders whose expected delivery date has passed but have not been
3159 
    delivered yet.
3160 
    Returns an empty list if no such orders exist.
3161 
    """
3162 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3163 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3164 
 
3165 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3166 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3167 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3168 
    args.write(self._oprot)
3169 
    self._oprot.writeMessageEnd()
3170 
    self._oprot.trans.flush()
3171 
 
3172 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3174 
    if mtype == TMessageType.EXCEPTION:
3175 
      x = TApplicationException()
3176 
      x.read(self._iprot)
3177 
      self._iprot.readMessageEnd()
3178 
      raise x
3179 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3180 
    result.read(self._iprot)
3181 
    self._iprot.readMessageEnd()
3182 
    if result.success is not None:
3183 
      return result.success
3184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3185 
 
2536 chandransh 3186 
  def toggleDOAFlag(self, orderId):
3187 
    """
3188 
    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.
3189 
    Returns the final flag status.
3190 
    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 3191 
 
2536 chandransh 3192 
    Parameters:
3193 
     - orderId
3194 
    """
3195 
    self.send_toggleDOAFlag(orderId)
3196 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3197 
 
2536 chandransh 3198 
  def send_toggleDOAFlag(self, orderId):
3199 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3200 
    args = toggleDOAFlag_args()
3201 
    args.orderId = orderId
3202 
    args.write(self._oprot)
3203 
    self._oprot.writeMessageEnd()
3204 
    self._oprot.trans.flush()
3205 
 
3206 
  def recv_toggleDOAFlag(self, ):
3207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3208 
    if mtype == TMessageType.EXCEPTION:
3209 
      x = TApplicationException()
3210 
      x.read(self._iprot)
3211 
      self._iprot.readMessageEnd()
3212 
      raise x
3213 
    result = toggleDOAFlag_result()
3214 
    result.read(self._iprot)
3215 
    self._iprot.readMessageEnd()
3431 rajveer 3216 
    if result.success is not None:
2536 chandransh 3217 
      return result.success
3431 rajveer 3218 
    if result.ex is not None:
2536 chandransh 3219 
      raise result.ex
3220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3221 
 
4712 rajveer 3222 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3223 
    """
3224 
    Parameters:
3225 
     - orderId
3226 
     - deliveryTimestamp
3227 
     - receiver
3228 
    """
3229 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3230 
    self.recv_markOrderAsDelivered()
3231 
 
3232 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3233 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3234 
    args = markOrderAsDelivered_args()
3235 
    args.orderId = orderId
3236 
    args.deliveryTimestamp = deliveryTimestamp
3237 
    args.receiver = receiver
3238 
    args.write(self._oprot)
3239 
    self._oprot.writeMessageEnd()
3240 
    self._oprot.trans.flush()
3241 
 
3242 
  def recv_markOrderAsDelivered(self, ):
3243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3244 
    if mtype == TMessageType.EXCEPTION:
3245 
      x = TApplicationException()
3246 
      x.read(self._iprot)
3247 
      self._iprot.readMessageEnd()
3248 
      raise x
3249 
    result = markOrderAsDelivered_result()
3250 
    result.read(self._iprot)
3251 
    self._iprot.readMessageEnd()
3252 
    if result.ex is not None:
3253 
      raise result.ex
3254 
    return
3255 
 
5553 rajveer 3256 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3257 
    """
3258 
    Parameters:
3259 
     - orderId
3260 
     - deliveryTimestamp
3261 
    """
3262 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3263 
    self.recv_markOrderAsReceivedAtStore()
3264 
 
3265 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3266 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3267 
    args = markOrderAsReceivedAtStore_args()
3268 
    args.orderId = orderId
3269 
    args.deliveryTimestamp = deliveryTimestamp
3270 
    args.write(self._oprot)
3271 
    self._oprot.writeMessageEnd()
3272 
    self._oprot.trans.flush()
3273 
 
3274 
  def recv_markOrderAsReceivedAtStore(self, ):
3275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3276 
    if mtype == TMessageType.EXCEPTION:
3277 
      x = TApplicationException()
3278 
      x.read(self._iprot)
3279 
      self._iprot.readMessageEnd()
3280 
      raise x
3281 
    result = markOrderAsReceivedAtStore_result()
3282 
    result.read(self._iprot)
3283 
    self._iprot.readMessageEnd()
3284 
    if result.ex is not None:
3285 
      raise result.ex
3286 
    return
3287 
 
4454 rajveer 3288 
  def markOrderDoaRequestReceived(self, orderId):
3289 
    """
3290 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3291 
 
3292 
    Parameters:
3293 
     - orderId
3294 
    """
3295 
    self.send_markOrderDoaRequestReceived(orderId)
3296 
    return self.recv_markOrderDoaRequestReceived()
3297 
 
3298 
  def send_markOrderDoaRequestReceived(self, orderId):
3299 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3300 
    args = markOrderDoaRequestReceived_args()
3301 
    args.orderId = orderId
3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
3306 
  def recv_markOrderDoaRequestReceived(self, ):
3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
3313 
    result = markOrderDoaRequestReceived_result()
3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3316 
    if result.success is not None:
3317 
      return result.success
3318 
    if result.ex is not None:
3319 
      raise result.ex
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3321 
 
3322 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3323 
    """
3324 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3325 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3326 
 
3327 
    Parameters:
3328 
     - orderId
3329 
     - isAuthorized
3330 
    """
3331 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3332 
    return self.recv_markOrderDoaRequestAuthorized()
3333 
 
3334 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3335 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3336 
    args = markOrderDoaRequestAuthorized_args()
3337 
    args.orderId = orderId
3338 
    args.isAuthorized = isAuthorized
3339 
    args.write(self._oprot)
3340 
    self._oprot.writeMessageEnd()
3341 
    self._oprot.trans.flush()
3342 
 
3343 
  def recv_markOrderDoaRequestAuthorized(self, ):
3344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3345 
    if mtype == TMessageType.EXCEPTION:
3346 
      x = TApplicationException()
3347 
      x.read(self._iprot)
3348 
      self._iprot.readMessageEnd()
3349 
      raise x
3350 
    result = markOrderDoaRequestAuthorized_result()
3351 
    result.read(self._iprot)
3352 
    self._iprot.readMessageEnd()
3353 
    if result.success is not None:
3354 
      return result.success
3355 
    if result.ex is not None:
3356 
      raise result.ex
3357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3358 
 
4488 rajveer 3359 
  def markOrderReturnRequestReceived(self, orderId):
3360 
    """
3361 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3362 
 
3363 
    Parameters:
3364 
     - orderId
3365 
    """
3366 
    self.send_markOrderReturnRequestReceived(orderId)
3367 
    return self.recv_markOrderReturnRequestReceived()
3368 
 
3369 
  def send_markOrderReturnRequestReceived(self, orderId):
3370 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3371 
    args = markOrderReturnRequestReceived_args()
3372 
    args.orderId = orderId
3373 
    args.write(self._oprot)
3374 
    self._oprot.writeMessageEnd()
3375 
    self._oprot.trans.flush()
3376 
 
3377 
  def recv_markOrderReturnRequestReceived(self, ):
3378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3379 
    if mtype == TMessageType.EXCEPTION:
3380 
      x = TApplicationException()
3381 
      x.read(self._iprot)
3382 
      self._iprot.readMessageEnd()
3383 
      raise x
3384 
    result = markOrderReturnRequestReceived_result()
3385 
    result.read(self._iprot)
3386 
    self._iprot.readMessageEnd()
3387 
    if result.success is not None:
3388 
      return result.success
3389 
    if result.ex is not None:
3390 
      raise result.ex
3391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3392 
 
3393 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3394 
    """
3395 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3396 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3397 
 
3398 
    Parameters:
3399 
     - orderId
3400 
     - isAuthorized
3401 
    """
3402 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3403 
    return self.recv_markOrderReturnRequestAuthorized()
3404 
 
3405 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3406 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3407 
    args = markOrderReturnRequestAuthorized_args()
3408 
    args.orderId = orderId
3409 
    args.isAuthorized = isAuthorized
3410 
    args.write(self._oprot)
3411 
    self._oprot.writeMessageEnd()
3412 
    self._oprot.trans.flush()
3413 
 
3414 
  def recv_markOrderReturnRequestAuthorized(self, ):
3415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3416 
    if mtype == TMessageType.EXCEPTION:
3417 
      x = TApplicationException()
3418 
      x.read(self._iprot)
3419 
      self._iprot.readMessageEnd()
3420 
      raise x
3421 
    result = markOrderReturnRequestAuthorized_result()
3422 
    result.read(self._iprot)
3423 
    self._iprot.readMessageEnd()
3424 
    if result.success is not None:
3425 
      return result.success
3426 
    if result.ex is not None:
3427 
      raise result.ex
3428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3429 
 
4579 rajveer 3430 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3431 
    """
3432 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3433 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3434 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3435 
    For any other status, it returns false.
3436 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3437 
 
2536 chandransh 3438 
    Parameters:
3439 
     - orderId
4579 rajveer 3440 
     - providerId
2536 chandransh 3441 
    """
4579 rajveer 3442 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3443 
    return self.recv_requestPickupNumber()
3444 
 
4579 rajveer 3445 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3446 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3447 
    args = requestPickupNumber_args()
3448 
    args.orderId = orderId
4579 rajveer 3449 
    args.providerId = providerId
2536 chandransh 3450 
    args.write(self._oprot)
3451 
    self._oprot.writeMessageEnd()
3452 
    self._oprot.trans.flush()
3453 
 
3454 
  def recv_requestPickupNumber(self, ):
3455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3456 
    if mtype == TMessageType.EXCEPTION:
3457 
      x = TApplicationException()
3458 
      x.read(self._iprot)
3459 
      self._iprot.readMessageEnd()
3460 
      raise x
3461 
    result = requestPickupNumber_result()
3462 
    result.read(self._iprot)
3463 
    self._iprot.readMessageEnd()
3431 rajveer 3464 
    if result.success is not None:
2536 chandransh 3465 
      return result.success
3431 rajveer 3466 
    if result.ex is not None:
2536 chandransh 3467 
      raise result.ex
3468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3469 
 
4602 rajveer 3470 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3471 
    """
4452 rajveer 3472 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3473 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3474 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3475 
    	3. Returns true
2591 chandransh 3476 
    If the order is in any other status, it returns false.
2536 chandransh 3477 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3478 
 
2536 chandransh 3479 
    Parameters:
3480 
     - orderId
3481 
     - pickupNumber
4602 rajveer 3482 
     - providerId
2536 chandransh 3483 
    """
4602 rajveer 3484 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3485 
    return self.recv_authorizePickup()
3486 
 
4602 rajveer 3487 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3488 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3489 
    args = authorizePickup_args()
3490 
    args.orderId = orderId
3491 
    args.pickupNumber = pickupNumber
4602 rajveer 3492 
    args.providerId = providerId
2536 chandransh 3493 
    args.write(self._oprot)
3494 
    self._oprot.writeMessageEnd()
3495 
    self._oprot.trans.flush()
3496 
 
3497 
  def recv_authorizePickup(self, ):
3498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3499 
    if mtype == TMessageType.EXCEPTION:
3500 
      x = TApplicationException()
3501 
      x.read(self._iprot)
3502 
      self._iprot.readMessageEnd()
3503 
      raise x
3504 
    result = authorizePickup_result()
3505 
    result.read(self._iprot)
3506 
    self._iprot.readMessageEnd()
3431 rajveer 3507 
    if result.success is not None:
2536 chandransh 3508 
      return result.success
3431 rajveer 3509 
    if result.ex is not None:
2536 chandransh 3510 
      raise result.ex
3511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3512 
 
2764 chandransh 3513 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3514 
    """
3515 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3516 
 
2764 chandransh 3517 
    Parameters:
3518 
     - providerId
3519 
     - pickupDetails
3520 
    """
3521 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3522 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3523 
 
3524 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3525 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3526 
    args = markDoasAsPickedUp_args()
3527 
    args.providerId = providerId
3528 
    args.pickupDetails = pickupDetails
3529 
    args.write(self._oprot)
3530 
    self._oprot.writeMessageEnd()
3531 
    self._oprot.trans.flush()
3532 
 
3533 
  def recv_markDoasAsPickedUp(self, ):
3534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3535 
    if mtype == TMessageType.EXCEPTION:
3536 
      x = TApplicationException()
3537 
      x.read(self._iprot)
3538 
      self._iprot.readMessageEnd()
3539 
      raise x
3540 
    result = markDoasAsPickedUp_result()
3541 
    result.read(self._iprot)
3542 
    self._iprot.readMessageEnd()
4910 phani.kuma 3543 
    return
3544 
 
3545 
  def getDoasNotPickedUp(self, providerId):
3546 
    """
3547 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3548 
 
3549 
    Parameters:
3550 
     - providerId
3551 
    """
3552 
    self.send_getDoasNotPickedUp(providerId)
3553 
    return self.recv_getDoasNotPickedUp()
3554 
 
3555 
  def send_getDoasNotPickedUp(self, providerId):
3556 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3557 
    args = getDoasNotPickedUp_args()
3558 
    args.providerId = providerId
3559 
    args.write(self._oprot)
3560 
    self._oprot.writeMessageEnd()
3561 
    self._oprot.trans.flush()
3562 
 
3563 
  def recv_getDoasNotPickedUp(self, ):
3564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3565 
    if mtype == TMessageType.EXCEPTION:
3566 
      x = TApplicationException()
3567 
      x.read(self._iprot)
3568 
      self._iprot.readMessageEnd()
3569 
      raise x
3570 
    result = getDoasNotPickedUp_result()
3571 
    result.read(self._iprot)
3572 
    self._iprot.readMessageEnd()
3431 rajveer 3573 
    if result.success is not None:
2764 chandransh 3574 
      return result.success
4910 phani.kuma 3575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3576 
 
4741 phani.kuma 3577 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3578 
    """
3579 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3580 
 
3581 
    Parameters:
3582 
     - providerId
3583 
     - pickupDetails
3584 
    """
3585 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3586 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3587 
 
3588 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3589 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3590 
    args = markReturnOrdersAsPickedUp_args()
3591 
    args.providerId = providerId
3592 
    args.pickupDetails = pickupDetails
3593 
    args.write(self._oprot)
3594 
    self._oprot.writeMessageEnd()
3595 
    self._oprot.trans.flush()
3596 
 
3597 
  def recv_markReturnOrdersAsPickedUp(self, ):
3598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3599 
    if mtype == TMessageType.EXCEPTION:
3600 
      x = TApplicationException()
3601 
      x.read(self._iprot)
3602 
      self._iprot.readMessageEnd()
3603 
      raise x
3604 
    result = markReturnOrdersAsPickedUp_result()
3605 
    result.read(self._iprot)
3606 
    self._iprot.readMessageEnd()
4910 phani.kuma 3607 
    return
3608 
 
3609 
  def getReturnOrdersNotPickedUp(self, providerId):
3610 
    """
3611 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3612 
 
3613 
    Parameters:
3614 
     - providerId
3615 
    """
3616 
    self.send_getReturnOrdersNotPickedUp(providerId)
3617 
    return self.recv_getReturnOrdersNotPickedUp()
3618 
 
3619 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3620 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3621 
    args = getReturnOrdersNotPickedUp_args()
3622 
    args.providerId = providerId
3623 
    args.write(self._oprot)
3624 
    self._oprot.writeMessageEnd()
3625 
    self._oprot.trans.flush()
3626 
 
3627 
  def recv_getReturnOrdersNotPickedUp(self, ):
3628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3629 
    if mtype == TMessageType.EXCEPTION:
3630 
      x = TApplicationException()
3631 
      x.read(self._iprot)
3632 
      self._iprot.readMessageEnd()
3633 
      raise x
3634 
    result = getReturnOrdersNotPickedUp_result()
3635 
    result.read(self._iprot)
3636 
    self._iprot.readMessageEnd()
4741 phani.kuma 3637 
    if result.success is not None:
3638 
      return result.success
4910 phani.kuma 3639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3640 
 
4479 rajveer 3641 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3642 
    """
4452 rajveer 3643 
    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 3644 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3645 
    If the order is in any other state, it returns false.
3646 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3647 
 
2591 chandransh 3648 
    Parameters:
3649 
     - orderId
4479 rajveer 3650 
     - receiveCondition
2591 chandransh 3651 
    """
4479 rajveer 3652 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3653 
    return self.recv_receiveReturn()
2536 chandransh 3654 
 
4479 rajveer 3655 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3656 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3657 
    args = receiveReturn_args()
2591 chandransh 3658 
    args.orderId = orderId
4479 rajveer 3659 
    args.receiveCondition = receiveCondition
2591 chandransh 3660 
    args.write(self._oprot)
3661 
    self._oprot.writeMessageEnd()
3662 
    self._oprot.trans.flush()
3663 
 
2616 chandransh 3664 
  def recv_receiveReturn(self, ):
2591 chandransh 3665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3666 
    if mtype == TMessageType.EXCEPTION:
3667 
      x = TApplicationException()
3668 
      x.read(self._iprot)
3669 
      self._iprot.readMessageEnd()
3670 
      raise x
2616 chandransh 3671 
    result = receiveReturn_result()
2591 chandransh 3672 
    result.read(self._iprot)
3673 
    self._iprot.readMessageEnd()
3431 rajveer 3674 
    if result.success is not None:
2591 chandransh 3675 
      return result.success
3431 rajveer 3676 
    if result.ex is not None:
2591 chandransh 3677 
      raise result.ex
2616 chandransh 3678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3679 
 
3680 
  def validateDoa(self, orderId, isValid):
3681 
    """
4452 rajveer 3682 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3683 
    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 3684 
    If the order is in any other state, it returns false.
3685 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3686 
 
2591 chandransh 3687 
    Parameters:
3688 
     - orderId
3689 
     - isValid
3690 
    """
3691 
    self.send_validateDoa(orderId, isValid)
3692 
    return self.recv_validateDoa()
3693 
 
3694 
  def send_validateDoa(self, orderId, isValid):
3695 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3696 
    args = validateDoa_args()
3697 
    args.orderId = orderId
3698 
    args.isValid = isValid
3699 
    args.write(self._oprot)
3700 
    self._oprot.writeMessageEnd()
3701 
    self._oprot.trans.flush()
3702 
 
3703 
  def recv_validateDoa(self, ):
3704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3705 
    if mtype == TMessageType.EXCEPTION:
3706 
      x = TApplicationException()
3707 
      x.read(self._iprot)
3708 
      self._iprot.readMessageEnd()
3709 
      raise x
3710 
    result = validateDoa_result()
3711 
    result.read(self._iprot)
3712 
    self._iprot.readMessageEnd()
3431 rajveer 3713 
    if result.success is not None:
2591 chandransh 3714 
      return result.success
3431 rajveer 3715 
    if result.ex is not None:
2591 chandransh 3716 
      raise result.ex
3717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3718 
 
4495 rajveer 3719 
  def validateReturnProduct(self, orderId, isUsable):
3720 
    """
3721 
    Parameters:
3722 
     - orderId
3723 
     - isUsable
3724 
    """
3725 
    self.send_validateReturnProduct(orderId, isUsable)
3726 
    return self.recv_validateReturnProduct()
3727 
 
3728 
  def send_validateReturnProduct(self, orderId, isUsable):
3729 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3730 
    args = validateReturnProduct_args()
3731 
    args.orderId = orderId
3732 
    args.isUsable = isUsable
3733 
    args.write(self._oprot)
3734 
    self._oprot.writeMessageEnd()
3735 
    self._oprot.trans.flush()
3736 
 
3737 
  def recv_validateReturnProduct(self, ):
3738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3739 
    if mtype == TMessageType.EXCEPTION:
3740 
      x = TApplicationException()
3741 
      x.read(self._iprot)
3742 
      self._iprot.readMessageEnd()
3743 
      raise x
3744 
    result = validateReturnProduct_result()
3745 
    result.read(self._iprot)
3746 
    self._iprot.readMessageEnd()
3747 
    if result.success is not None:
3748 
      return result.success
3749 
    if result.ex is not None:
3750 
      raise result.ex
3751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3752 
 
2616 chandransh 3753 
  def reshipOrder(self, orderId):
3754 
    """
4484 rajveer 3755 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3756 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3757 
    	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 3758 
 
3759 
    If the order is in DOA_CERT_VALID state, it does the following:
3760 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3761 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3762 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3763 
 
2616 chandransh 3764 
    Returns the id of the newly created order.
3431 rajveer 3765 
 
2616 chandransh 3766 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3767 
 
2616 chandransh 3768 
    Parameters:
3769 
     - orderId
3770 
    """
3771 
    self.send_reshipOrder(orderId)
3772 
    return self.recv_reshipOrder()
2591 chandransh 3773 
 
2616 chandransh 3774 
  def send_reshipOrder(self, orderId):
3775 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3776 
    args = reshipOrder_args()
3777 
    args.orderId = orderId
3778 
    args.write(self._oprot)
3779 
    self._oprot.writeMessageEnd()
3780 
    self._oprot.trans.flush()
3781 
 
3782 
  def recv_reshipOrder(self, ):
3783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3784 
    if mtype == TMessageType.EXCEPTION:
3785 
      x = TApplicationException()
3786 
      x.read(self._iprot)
3787 
      self._iprot.readMessageEnd()
3788 
      raise x
3789 
    result = reshipOrder_result()
3790 
    result.read(self._iprot)
3791 
    self._iprot.readMessageEnd()
3431 rajveer 3792 
    if result.success is not None:
2616 chandransh 3793 
      return result.success
3431 rajveer 3794 
    if result.ex is not None:
2616 chandransh 3795 
      raise result.ex
3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3797 
 
3226 chandransh 3798 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3799 
    """
4484 rajveer 3800 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3801 
    	1. Creates a refund request for batch processing.
3802 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3803 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3804 
 
2616 chandransh 3805 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3806 
    	1. Creates a refund request for batch processing.
3226 chandransh 3807 
    	2. Cancels the reservation of the item in the warehouse.
3808 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3809 
 
3226 chandransh 3810 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3811 
    	1. Cancels the reservation of the item in the warehouse.
3812 
    	2. Marks the current order as CANCELED.
3813 
 
3814 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3815 
 
2616 chandransh 3816 
    Returns True if it is successful, False otherwise.
3431 rajveer 3817 
 
2616 chandransh 3818 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3819 
 
2616 chandransh 3820 
    Parameters:
3821 
     - orderId
3226 chandransh 3822 
     - refundedBy
3823 
     - reason
2616 chandransh 3824 
    """
3226 chandransh 3825 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3826 
    return self.recv_refundOrder()
3827 
 
3226 chandransh 3828 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3829 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3830 
    args = refundOrder_args()
3831 
    args.orderId = orderId
3226 chandransh 3832 
    args.refundedBy = refundedBy
3833 
    args.reason = reason
2616 chandransh 3834 
    args.write(self._oprot)
3835 
    self._oprot.writeMessageEnd()
3836 
    self._oprot.trans.flush()
3837 
 
3838 
  def recv_refundOrder(self, ):
3839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3840 
    if mtype == TMessageType.EXCEPTION:
3841 
      x = TApplicationException()
3842 
      x.read(self._iprot)
3843 
      self._iprot.readMessageEnd()
3844 
      raise x
3845 
    result = refundOrder_result()
3846 
    result.read(self._iprot)
3847 
    self._iprot.readMessageEnd()
3431 rajveer 3848 
    if result.success is not None:
2616 chandransh 3849 
      return result.success
3431 rajveer 3850 
    if result.ex is not None:
2616 chandransh 3851 
      raise result.ex
3852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3853 
 
2690 chandransh 3854 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3855 
    """
3856 
    Get all return orders created between the from and to dates for the given warehouse.
3857 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3858 
 
2690 chandransh 3859 
    Parameters:
3860 
     - warehouseId
3861 
     - fromDate
3862 
     - toDate
3863 
    """
3864 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3865 
    return self.recv_getReturnOrders()
2616 chandransh 3866 
 
2690 chandransh 3867 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3868 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3869 
    args = getReturnOrders_args()
3870 
    args.warehouseId = warehouseId
3871 
    args.fromDate = fromDate
3872 
    args.toDate = toDate
3873 
    args.write(self._oprot)
3874 
    self._oprot.writeMessageEnd()
3875 
    self._oprot.trans.flush()
3876 
 
3877 
  def recv_getReturnOrders(self, ):
3878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3879 
    if mtype == TMessageType.EXCEPTION:
3880 
      x = TApplicationException()
3881 
      x.read(self._iprot)
3882 
      self._iprot.readMessageEnd()
3883 
      raise x
3884 
    result = getReturnOrders_result()
3885 
    result.read(self._iprot)
3886 
    self._iprot.readMessageEnd()
3431 rajveer 3887 
    if result.success is not None:
2690 chandransh 3888 
      return result.success
3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3890 
 
5481 phani.kuma 3891 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3892 
    """
3893 
    Get all return orders created between the from and to dates.
3894 
 
3895 
    Parameters:
3896 
     - onlyNotProcessed
3897 
     - fromDate
3898 
     - toDate
3899 
    """
3900 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3901 
    return self.recv_getAllReturnOrders()
3902 
 
3903 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3904 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3905 
    args = getAllReturnOrders_args()
3906 
    args.onlyNotProcessed = onlyNotProcessed
3907 
    args.fromDate = fromDate
3908 
    args.toDate = toDate
3909 
    args.write(self._oprot)
3910 
    self._oprot.writeMessageEnd()
3911 
    self._oprot.trans.flush()
3912 
 
3913 
  def recv_getAllReturnOrders(self, ):
3914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3915 
    if mtype == TMessageType.EXCEPTION:
3916 
      x = TApplicationException()
3917 
      x.read(self._iprot)
3918 
      self._iprot.readMessageEnd()
3919 
      raise x
3920 
    result = getAllReturnOrders_result()
3921 
    result.read(self._iprot)
3922 
    self._iprot.readMessageEnd()
3923 
    if result.success is not None:
3924 
      return result.success
3925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3926 
 
2700 chandransh 3927 
  def getReturnOrder(self, id):
3928 
    """
3929 
    Returns the ReturnOrder corresponding to the given id.
3930 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3931 
 
2700 chandransh 3932 
    Parameters:
3933 
     - id
3934 
    """
3935 
    self.send_getReturnOrder(id)
3936 
    return self.recv_getReturnOrder()
3937 
 
3938 
  def send_getReturnOrder(self, id):
3939 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3940 
    args = getReturnOrder_args()
3941 
    args.id = id
3942 
    args.write(self._oprot)
3943 
    self._oprot.writeMessageEnd()
3944 
    self._oprot.trans.flush()
3945 
 
3946 
  def recv_getReturnOrder(self, ):
3947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3948 
    if mtype == TMessageType.EXCEPTION:
3949 
      x = TApplicationException()
3950 
      x.read(self._iprot)
3951 
      self._iprot.readMessageEnd()
3952 
      raise x
3953 
    result = getReturnOrder_result()
3954 
    result.read(self._iprot)
3955 
    self._iprot.readMessageEnd()
3431 rajveer 3956 
    if result.success is not None:
2700 chandransh 3957 
      return result.success
3431 rajveer 3958 
    if result.ex is not None:
2700 chandransh 3959 
      raise result.ex
3960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3961 
 
2690 chandransh 3962 
  def processReturn(self, returnOrderId):
3963 
    """
3964 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3965 
 
2690 chandransh 3966 
    Parameters:
3967 
     - returnOrderId
3968 
    """
3969 
    self.send_processReturn(returnOrderId)
3970 
    self.recv_processReturn()
3971 
 
3972 
  def send_processReturn(self, returnOrderId):
3973 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3974 
    args = processReturn_args()
3975 
    args.returnOrderId = returnOrderId
3976 
    args.write(self._oprot)
3977 
    self._oprot.writeMessageEnd()
3978 
    self._oprot.trans.flush()
3979 
 
3980 
  def recv_processReturn(self, ):
3981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3982 
    if mtype == TMessageType.EXCEPTION:
3983 
      x = TApplicationException()
3984 
      x.read(self._iprot)
3985 
      self._iprot.readMessageEnd()
3986 
      raise x
3987 
    result = processReturn_result()
3988 
    result.read(self._iprot)
3989 
    self._iprot.readMessageEnd()
3431 rajveer 3990 
    if result.ex is not None:
2690 chandransh 3991 
      raise result.ex
3992 
    return
3993 
 
3451 chandransh 3994 
  def updateWeight(self, orderId, weight):
3995 
    """
3996 
    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 3997 
 
3451 chandransh 3998 
    Parameters:
3999 
     - orderId
4000 
     - weight
4001 
    """
4002 
    self.send_updateWeight(orderId, weight)
4003 
    return self.recv_updateWeight()
4004 
 
4005 
  def send_updateWeight(self, orderId, weight):
4006 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4007 
    args = updateWeight_args()
4008 
    args.orderId = orderId
4009 
    args.weight = weight
4010 
    args.write(self._oprot)
4011 
    self._oprot.writeMessageEnd()
4012 
    self._oprot.trans.flush()
4013 
 
4014 
  def recv_updateWeight(self, ):
4015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4016 
    if mtype == TMessageType.EXCEPTION:
4017 
      x = TApplicationException()
4018 
      x.read(self._iprot)
4019 
      self._iprot.readMessageEnd()
4020 
      raise x
4021 
    result = updateWeight_result()
4022 
    result.read(self._iprot)
4023 
    self._iprot.readMessageEnd()
4024 
    if result.success is not None:
4025 
      return result.success
4026 
    if result.ex is not None:
4027 
      raise result.ex
4028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4029 
 
3469 chandransh 4030 
  def changeItem(self, orderId, itemId):
4031 
    """
4032 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4033 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4034 
 
3469 chandransh 4035 
    Parameters:
4036 
     - orderId
4037 
     - itemId
4038 
    """
4039 
    self.send_changeItem(orderId, itemId)
4040 
    return self.recv_changeItem()
4041 
 
4042 
  def send_changeItem(self, orderId, itemId):
4043 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4044 
    args = changeItem_args()
4045 
    args.orderId = orderId
4046 
    args.itemId = itemId
4047 
    args.write(self._oprot)
4048 
    self._oprot.writeMessageEnd()
4049 
    self._oprot.trans.flush()
4050 
 
4051 
  def recv_changeItem(self, ):
4052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4053 
    if mtype == TMessageType.EXCEPTION:
4054 
      x = TApplicationException()
4055 
      x.read(self._iprot)
4056 
      self._iprot.readMessageEnd()
4057 
      raise x
4058 
    result = changeItem_result()
4059 
    result.read(self._iprot)
4060 
    self._iprot.readMessageEnd()
4061 
    if result.success is not None:
4062 
      return result.success
4063 
    if result.ex is not None:
4064 
      raise result.ex
4065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4066 
 
4067 
  def shiftToWarehouse(self, orderId, warehouseId):
4068 
    """
4069 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4070 
 
4071 
    Parameters:
4072 
     - orderId
4073 
     - warehouseId
4074 
    """
4075 
    self.send_shiftToWarehouse(orderId, warehouseId)
4076 
    return self.recv_shiftToWarehouse()
4077 
 
4078 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4079 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4080 
    args = shiftToWarehouse_args()
4081 
    args.orderId = orderId
4082 
    args.warehouseId = warehouseId
4083 
    args.write(self._oprot)
4084 
    self._oprot.writeMessageEnd()
4085 
    self._oprot.trans.flush()
4086 
 
4087 
  def recv_shiftToWarehouse(self, ):
4088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4089 
    if mtype == TMessageType.EXCEPTION:
4090 
      x = TApplicationException()
4091 
      x.read(self._iprot)
4092 
      self._iprot.readMessageEnd()
4093 
      raise x
4094 
    result = shiftToWarehouse_result()
4095 
    result.read(self._iprot)
4096 
    self._iprot.readMessageEnd()
4097 
    if result.success is not None:
4098 
      return result.success
4099 
    if result.ex is not None:
4100 
      raise result.ex
4101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4102 
 
4647 rajveer 4103 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4104 
    """
4105 
    Adds the given delay reason to the given order.
3986 chandransh 4106 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4107 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4108 
 
3553 chandransh 4109 
    Parameters:
4110 
     - orderId
4111 
     - delayReason
3986 chandransh 4112 
     - furtherDelay
4647 rajveer 4113 
     - delayReasonText
3553 chandransh 4114 
    """
4647 rajveer 4115 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4116 
    return self.recv_addDelayReason()
4117 
 
4647 rajveer 4118 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4119 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4120 
    args = addDelayReason_args()
4121 
    args.orderId = orderId
4122 
    args.delayReason = delayReason
3986 chandransh 4123 
    args.furtherDelay = furtherDelay
4647 rajveer 4124 
    args.delayReasonText = delayReasonText
3553 chandransh 4125 
    args.write(self._oprot)
4126 
    self._oprot.writeMessageEnd()
4127 
    self._oprot.trans.flush()
4128 
 
4129 
  def recv_addDelayReason(self, ):
4130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4131 
    if mtype == TMessageType.EXCEPTION:
4132 
      x = TApplicationException()
4133 
      x.read(self._iprot)
4134 
      self._iprot.readMessageEnd()
4135 
      raise x
4136 
    result = addDelayReason_result()
4137 
    result.read(self._iprot)
4138 
    self._iprot.readMessageEnd()
4139 
    if result.success is not None:
4140 
      return result.success
4141 
    if result.ex is not None:
4142 
      raise result.ex
4143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4144 
 
3956 chandransh 4145 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4146 
    """
4147 
    Marks the COD orders with given AWB nos. as having been processed.
4148 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4149 
 
3956 chandransh 4150 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4151 
    1. There is no order corresponding to an AWB number.
4152 
    2. The captured amount for a payment exceeds the total payment.
4153 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4154 
 
4155 
    Parameters:
4156 
     - collectedAmountMap
4157 
     - xferBy
4158 
     - xferTxnId
4159 
     - xferDate
4160 
    """
4161 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4162 
    return self.recv_reconcileCodCollection()
4163 
 
4164 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4165 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4166 
    args = reconcileCodCollection_args()
4167 
    args.collectedAmountMap = collectedAmountMap
4168 
    args.xferBy = xferBy
4169 
    args.xferTxnId = xferTxnId
4170 
    args.xferDate = xferDate
4171 
    args.write(self._oprot)
4172 
    self._oprot.writeMessageEnd()
4173 
    self._oprot.trans.flush()
4174 
 
4175 
  def recv_reconcileCodCollection(self, ):
4176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4177 
    if mtype == TMessageType.EXCEPTION:
4178 
      x = TApplicationException()
4179 
      x.read(self._iprot)
4180 
      self._iprot.readMessageEnd()
4181 
      raise x
4182 
    result = reconcileCodCollection_result()
4183 
    result.read(self._iprot)
4184 
    self._iprot.readMessageEnd()
4185 
    if result.success is not None:
4186 
      return result.success
4187 
    if result.ex is not None:
4188 
      raise result.ex
4189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4190 
 
4008 mandeep.dh 4191 
  def getTransactionsRequiringExtraProcessing(self, category):
4192 
    """
4065 mandeep.dh 4193 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4194 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4195 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4196 
 
4008 mandeep.dh 4197 
    Parameters:
4198 
     - category
4199 
    """
4200 
    self.send_getTransactionsRequiringExtraProcessing(category)
4201 
    return self.recv_getTransactionsRequiringExtraProcessing()
4202 
 
4203 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4204 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4205 
    args = getTransactionsRequiringExtraProcessing_args()
4206 
    args.category = category
4207 
    args.write(self._oprot)
4208 
    self._oprot.writeMessageEnd()
4209 
    self._oprot.trans.flush()
4210 
 
4211 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4213 
    if mtype == TMessageType.EXCEPTION:
4214 
      x = TApplicationException()
4215 
      x.read(self._iprot)
4216 
      self._iprot.readMessageEnd()
4217 
      raise x
4218 
    result = getTransactionsRequiringExtraProcessing_result()
4219 
    result.read(self._iprot)
4220 
    self._iprot.readMessageEnd()
4221 
    if result.success is not None:
4222 
      return result.success
4223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4224 
 
4225 
  def markTransactionAsProcessed(self, transactionId, category):
4226 
    """
4227 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4228 
    It essentially deletes the transaction id record for a particular
4229 
    processing type category (if present) from DB.
4230 
    This is currently used by CRM application.
4008 mandeep.dh 4231 
 
4232 
    Parameters:
4233 
     - transactionId
4234 
     - category
4235 
    """
4236 
    self.send_markTransactionAsProcessed(transactionId, category)
4237 
    self.recv_markTransactionAsProcessed()
4238 
 
4239 
  def send_markTransactionAsProcessed(self, transactionId, category):
4240 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4241 
    args = markTransactionAsProcessed_args()
4242 
    args.transactionId = transactionId
4243 
    args.category = category
4244 
    args.write(self._oprot)
4245 
    self._oprot.writeMessageEnd()
4246 
    self._oprot.trans.flush()
4247 
 
4248 
  def recv_markTransactionAsProcessed(self, ):
4249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4250 
    if mtype == TMessageType.EXCEPTION:
4251 
      x = TApplicationException()
4252 
      x.read(self._iprot)
4253 
      self._iprot.readMessageEnd()
4254 
      raise x
4255 
    result = markTransactionAsProcessed_result()
4256 
    result.read(self._iprot)
4257 
    self._iprot.readMessageEnd()
4258 
    return
4259 
 
4018 chandransh 4260 
  def getItemWiseRiskyOrdersCount(self, ):
4261 
    """
4262 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4263 
    is defined as one whose shipping date is about to expire.
4264 
    """
4265 
    self.send_getItemWiseRiskyOrdersCount()
4266 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4267 
 
4018 chandransh 4268 
  def send_getItemWiseRiskyOrdersCount(self, ):
4269 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4270 
    args = getItemWiseRiskyOrdersCount_args()
4271 
    args.write(self._oprot)
4272 
    self._oprot.writeMessageEnd()
4273 
    self._oprot.trans.flush()
4274 
 
4275 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4277 
    if mtype == TMessageType.EXCEPTION:
4278 
      x = TApplicationException()
4279 
      x.read(self._iprot)
4280 
      self._iprot.readMessageEnd()
4281 
      raise x
4282 
    result = getItemWiseRiskyOrdersCount_result()
4283 
    result.read(self._iprot)
4284 
    self._iprot.readMessageEnd()
4285 
    if result.success is not None:
4286 
      return result.success
4287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4288 
 
4295 varun.gupt 4289 
  def getOrdersForItemIds(self, itemIds):
4290 
    """
4291 
    Returns a list of all orders which have items with given id
4292 
 
4293 
    Parameters:
4294 
     - itemIds
4295 
    """
4296 
    self.send_getOrdersForItemIds(itemIds)
4297 
    return self.recv_getOrdersForItemIds()
4298 
 
4299 
  def send_getOrdersForItemIds(self, itemIds):
4300 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4301 
    args = getOrdersForItemIds_args()
4302 
    args.itemIds = itemIds
4303 
    args.write(self._oprot)
4304 
    self._oprot.writeMessageEnd()
4305 
    self._oprot.trans.flush()
4306 
 
4307 
  def recv_getOrdersForItemIds(self, ):
4308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4309 
    if mtype == TMessageType.EXCEPTION:
4310 
      x = TApplicationException()
4311 
      x.read(self._iprot)
4312 
      self._iprot.readMessageEnd()
4313 
      raise x
4314 
    result = getOrdersForItemIds_result()
4315 
    result.read(self._iprot)
4316 
    self._iprot.readMessageEnd()
4317 
    if result.success is not None:
4318 
      return result.success
4319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4320 
 
4247 rajveer 4321 
  def markOrderCancellationRequestReceived(self, orderId):
4322 
    """
4323 
    Mark order as cancellation request received. If customer sends request of cancellation of
4324 
    a particular order, this method will be called. It will just change status of the order
4325 
    depending on its current status. It also records the previous status, so that we can move
4326 
    back to that status if cancellation request is denied.
4018 chandransh 4327 
 
4247 rajveer 4328 
    Parameters:
4329 
     - orderId
4330 
    """
4331 
    self.send_markOrderCancellationRequestReceived(orderId)
4332 
    self.recv_markOrderCancellationRequestReceived()
4333 
 
4334 
  def send_markOrderCancellationRequestReceived(self, orderId):
4335 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4336 
    args = markOrderCancellationRequestReceived_args()
4337 
    args.orderId = orderId
4338 
    args.write(self._oprot)
4339 
    self._oprot.writeMessageEnd()
4340 
    self._oprot.trans.flush()
4341 
 
4342 
  def recv_markOrderCancellationRequestReceived(self, ):
4343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4344 
    if mtype == TMessageType.EXCEPTION:
4345 
      x = TApplicationException()
4346 
      x.read(self._iprot)
4347 
      self._iprot.readMessageEnd()
4348 
      raise x
4349 
    result = markOrderCancellationRequestReceived_result()
4350 
    result.read(self._iprot)
4351 
    self._iprot.readMessageEnd()
4352 
    if result.ex is not None:
4353 
      raise result.ex
4354 
    return
4355 
 
4356 
  def markOrderCancellationRequestConfirmed(self, orderId):
4357 
    """
4358 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4359 
    cancellation request confirmed. After this OM will be able to cancel the order.
4360 
 
4361 
    Parameters:
4362 
     - orderId
4363 
    """
4364 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4365 
    self.recv_markOrderCancellationRequestConfirmed()
4366 
 
4367 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4368 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4369 
    args = markOrderCancellationRequestConfirmed_args()
4370 
    args.orderId = orderId
4371 
    args.write(self._oprot)
4372 
    self._oprot.writeMessageEnd()
4373 
    self._oprot.trans.flush()
4374 
 
4375 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4377 
    if mtype == TMessageType.EXCEPTION:
4378 
      x = TApplicationException()
4379 
      x.read(self._iprot)
4380 
      self._iprot.readMessageEnd()
4381 
      raise x
4382 
    result = markOrderCancellationRequestConfirmed_result()
4383 
    result.read(self._iprot)
4384 
    self._iprot.readMessageEnd()
4385 
    if result.ex is not None:
4386 
      raise result.ex
4387 
    return
4388 
 
4389 
  def markOrderCancellationRequestDenied(self, orderId):
4390 
    """
4391 
    If we decide to not to cancel order, we will move the order ro previous status.
4392 
 
4393 
    Parameters:
4394 
     - orderId
4395 
    """
4396 
    self.send_markOrderCancellationRequestDenied(orderId)
4397 
    self.recv_markOrderCancellationRequestDenied()
4398 
 
4399 
  def send_markOrderCancellationRequestDenied(self, orderId):
4400 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4401 
    args = markOrderCancellationRequestDenied_args()
4402 
    args.orderId = orderId
4403 
    args.write(self._oprot)
4404 
    self._oprot.writeMessageEnd()
4405 
    self._oprot.trans.flush()
4406 
 
4407 
  def recv_markOrderCancellationRequestDenied(self, ):
4408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4409 
    if mtype == TMessageType.EXCEPTION:
4410 
      x = TApplicationException()
4411 
      x.read(self._iprot)
4412 
      self._iprot.readMessageEnd()
4413 
      raise x
4414 
    result = markOrderCancellationRequestDenied_result()
4415 
    result.read(self._iprot)
4416 
    self._iprot.readMessageEnd()
4417 
    if result.ex is not None:
4418 
      raise result.ex
4419 
    return
4420 
 
4258 rajveer 4421 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4422 
    """
4258 rajveer 4423 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4424 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4425 
 
4426 
    Parameters:
4258 rajveer 4427 
     - transactionId
4247 rajveer 4428 
    """
4258 rajveer 4429 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4430 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4431 
 
4258 rajveer 4432 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4433 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4434 
    args = markTransactionAsPaymentFlagRemoved_args()
4435 
    args.transactionId = transactionId
4247 rajveer 4436 
    args.write(self._oprot)
4437 
    self._oprot.writeMessageEnd()
4438 
    self._oprot.trans.flush()
4439 
 
4258 rajveer 4440 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4442 
    if mtype == TMessageType.EXCEPTION:
4443 
      x = TApplicationException()
4444 
      x.read(self._iprot)
4445 
      self._iprot.readMessageEnd()
4446 
      raise x
4258 rajveer 4447 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4448 
    result.read(self._iprot)
4449 
    self._iprot.readMessageEnd()
4450 
    if result.ex is not None:
4451 
      raise result.ex
4452 
    return
4453 
 
4259 anupam.sin 4454 
  def refundTransaction(self, transactionId, refundedBy, reason):
4455 
    """
4456 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4457 
    need to be cancelled
4247 rajveer 4458 
 
4259 anupam.sin 4459 
    Parameters:
4460 
     - transactionId
4461 
     - refundedBy
4462 
     - reason
4463 
    """
4464 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4465 
    self.recv_refundTransaction()
4466 
 
4467 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4468 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4469 
    args = refundTransaction_args()
4470 
    args.transactionId = transactionId
4471 
    args.refundedBy = refundedBy
4472 
    args.reason = reason
4473 
    args.write(self._oprot)
4474 
    self._oprot.writeMessageEnd()
4475 
    self._oprot.trans.flush()
4476 
 
4477 
  def recv_refundTransaction(self, ):
4478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4479 
    if mtype == TMessageType.EXCEPTION:
4480 
      x = TApplicationException()
4481 
      x.read(self._iprot)
4482 
      self._iprot.readMessageEnd()
4483 
      raise x
4484 
    result = refundTransaction_result()
4485 
    result.read(self._iprot)
4486 
    self._iprot.readMessageEnd()
4487 
    if result.ex is not None:
4488 
      raise result.ex
4489 
    return
4490 
 
4324 mandeep.dh 4491 
  def updateShipmentAddress(self, orderId, addressId):
4492 
    """
4493 
    Updates shipment address of an order. Delivery and shipping date estimates
4494 
    etc. are also updated here.
4495 
 
4496 
    Throws TransactionServiceException in case address change is not
4497 
    possible due to certain reasons such as new pincode in address is
4498 
    not serviceable etc.
4499 
 
4500 
    Parameters:
4501 
     - orderId
4502 
     - addressId
4503 
    """
4504 
    self.send_updateShipmentAddress(orderId, addressId)
4505 
    self.recv_updateShipmentAddress()
4506 
 
4507 
  def send_updateShipmentAddress(self, orderId, addressId):
4508 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4509 
    args = updateShipmentAddress_args()
4510 
    args.orderId = orderId
4511 
    args.addressId = addressId
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_updateShipmentAddress(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = updateShipmentAddress_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.ex is not None:
4527 
      raise result.ex
4528 
    return
4529 
 
4285 rajveer 4530 
  def acceptOrdersForItemId(self, itemId, inventory):
4531 
    """
4532 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4533 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4534 
 
4285 rajveer 4535 
    Parameters:
4536 
     - itemId
4537 
     - inventory
4538 
    """
4539 
    self.send_acceptOrdersForItemId(itemId, inventory)
4540 
    return self.recv_acceptOrdersForItemId()
4541 
 
4542 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4543 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4544 
    args = acceptOrdersForItemId_args()
4545 
    args.itemId = itemId
4546 
    args.inventory = inventory
4547 
    args.write(self._oprot)
4548 
    self._oprot.writeMessageEnd()
4549 
    self._oprot.trans.flush()
4550 
 
4551 
  def recv_acceptOrdersForItemId(self, ):
4552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4553 
    if mtype == TMessageType.EXCEPTION:
4554 
      x = TApplicationException()
4555 
      x.read(self._iprot)
4556 
      self._iprot.readMessageEnd()
4557 
      raise x
4558 
    result = acceptOrdersForItemId_result()
4559 
    result.read(self._iprot)
4560 
    self._iprot.readMessageEnd()
4561 
    if result.success is not None:
4562 
      return result.success
4563 
    if result.ex is not None:
4564 
      raise result.ex
4565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4566 
 
4369 rajveer 4567 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4568 
    """
4569 
    Parameters:
4570 
     - vendorId
4571 
     - itemId
4572 
     - quantity
4573 
     - estimate
4369 rajveer 4574 
     - isReminder
4303 rajveer 4575 
    """
4369 rajveer 4576 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4577 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4578 
 
4369 rajveer 4579 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4580 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4581 
    args = markOrdersAsPORaised_args()
4582 
    args.vendorId = vendorId
4583 
    args.itemId = itemId
4584 
    args.quantity = quantity
4585 
    args.estimate = estimate
4369 rajveer 4586 
    args.isReminder = isReminder
4303 rajveer 4587 
    args.write(self._oprot)
4588 
    self._oprot.writeMessageEnd()
4589 
    self._oprot.trans.flush()
4590 
 
4591 
  def recv_markOrdersAsPORaised(self, ):
4592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4593 
    if mtype == TMessageType.EXCEPTION:
4594 
      x = TApplicationException()
4595 
      x.read(self._iprot)
4596 
      self._iprot.readMessageEnd()
4597 
      raise x
4598 
    result = markOrdersAsPORaised_result()
4599 
    result.read(self._iprot)
4600 
    self._iprot.readMessageEnd()
4601 
    if result.ex is not None:
4602 
      raise result.ex
4603 
    return
4604 
 
4369 rajveer 4605 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4606 
    """
4607 
    Parameters:
4608 
     - vendorId
4609 
     - itemId
4610 
     - quantity
4611 
     - estimate
4369 rajveer 4612 
     - isReminder
4303 rajveer 4613 
    """
4369 rajveer 4614 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4615 
    self.recv_markOrdersAsReversalInitiated()
4616 
 
4369 rajveer 4617 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4618 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4619 
    args = markOrdersAsReversalInitiated_args()
4620 
    args.vendorId = vendorId
4621 
    args.itemId = itemId
4622 
    args.quantity = quantity
4623 
    args.estimate = estimate
4369 rajveer 4624 
    args.isReminder = isReminder
4303 rajveer 4625 
    args.write(self._oprot)
4626 
    self._oprot.writeMessageEnd()
4627 
    self._oprot.trans.flush()
4628 
 
4629 
  def recv_markOrdersAsReversalInitiated(self, ):
4630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4631 
    if mtype == TMessageType.EXCEPTION:
4632 
      x = TApplicationException()
4633 
      x.read(self._iprot)
4634 
      self._iprot.readMessageEnd()
4635 
      raise x
4636 
    result = markOrdersAsReversalInitiated_result()
4637 
    result.read(self._iprot)
4638 
    self._iprot.readMessageEnd()
4639 
    if result.ex is not None:
4640 
      raise result.ex
4641 
    return
4642 
 
4369 rajveer 4643 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4644 
    """
4645 
    Parameters:
4646 
     - vendorId
4647 
     - itemId
4648 
     - quantity
4649 
     - estimate
4369 rajveer 4650 
     - isReminder
4303 rajveer 4651 
    """
4369 rajveer 4652 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4653 
    self.recv_markOrdersAsNotAvailabke()
4654 
 
4369 rajveer 4655 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4656 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4657 
    args = markOrdersAsNotAvailabke_args()
4658 
    args.vendorId = vendorId
4659 
    args.itemId = itemId
4660 
    args.quantity = quantity
4661 
    args.estimate = estimate
4369 rajveer 4662 
    args.isReminder = isReminder
4303 rajveer 4663 
    args.write(self._oprot)
4664 
    self._oprot.writeMessageEnd()
4665 
    self._oprot.trans.flush()
4666 
 
4667 
  def recv_markOrdersAsNotAvailabke(self, ):
4668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4669 
    if mtype == TMessageType.EXCEPTION:
4670 
      x = TApplicationException()
4671 
      x.read(self._iprot)
4672 
      self._iprot.readMessageEnd()
4673 
      raise x
4674 
    result = markOrdersAsNotAvailabke_result()
4675 
    result.read(self._iprot)
4676 
    self._iprot.readMessageEnd()
4677 
    if result.ex is not None:
4678 
      raise result.ex
4679 
    return
4680 
 
4369 rajveer 4681 
  def markOrdersAsTimeout(self, vendorId):
4682 
    """
4683 
    Parameters:
4684 
     - vendorId
4685 
    """
4686 
    self.send_markOrdersAsTimeout(vendorId)
4687 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4688 
 
4369 rajveer 4689 
  def send_markOrdersAsTimeout(self, vendorId):
4690 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4691 
    args = markOrdersAsTimeout_args()
4692 
    args.vendorId = vendorId
4693 
    args.write(self._oprot)
4694 
    self._oprot.writeMessageEnd()
4695 
    self._oprot.trans.flush()
4696 
 
4697 
  def recv_markOrdersAsTimeout(self, ):
4698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4699 
    if mtype == TMessageType.EXCEPTION:
4700 
      x = TApplicationException()
4701 
      x.read(self._iprot)
4702 
      self._iprot.readMessageEnd()
4703 
      raise x
4704 
    result = markOrdersAsTimeout_result()
4705 
    result.read(self._iprot)
4706 
    self._iprot.readMessageEnd()
4707 
    if result.success is not None:
4708 
      return result.success
4709 
    if result.ex is not None:
4710 
      raise result.ex
4711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4712 
 
4662 rajveer 4713 
  def markOrderAsLostInTransit(self, orderId):
4714 
    """
4715 
    Mark order as LOST_IN_TRANSIT
4716 
 
4717 
    Parameters:
4718 
     - orderId
4719 
    """
4720 
    self.send_markOrderAsLostInTransit(orderId)
4721 
    return self.recv_markOrderAsLostInTransit()
4722 
 
4723 
  def send_markOrderAsLostInTransit(self, orderId):
4724 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4725 
    args = markOrderAsLostInTransit_args()
4726 
    args.orderId = orderId
4727 
    args.write(self._oprot)
4728 
    self._oprot.writeMessageEnd()
4729 
    self._oprot.trans.flush()
4730 
 
4731 
  def recv_markOrderAsLostInTransit(self, ):
4732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4733 
    if mtype == TMessageType.EXCEPTION:
4734 
      x = TApplicationException()
4735 
      x.read(self._iprot)
4736 
      self._iprot.readMessageEnd()
4737 
      raise x
4738 
    result = markOrderAsLostInTransit_result()
4739 
    result.read(self._iprot)
4740 
    self._iprot.readMessageEnd()
4741 
    if result.success is not None:
4742 
      return result.success
4743 
    if result.ex is not None:
4744 
      raise result.ex
4745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4746 
 
4386 anupam.sin 4747 
  def getOrderForAwb(self, awb):
4748 
    """
4749 
    Returns the order corresponding to an AWB number
4369 rajveer 4750 
 
4386 anupam.sin 4751 
    Parameters:
4752 
     - awb
4753 
    """
4754 
    self.send_getOrderForAwb(awb)
4755 
    return self.recv_getOrderForAwb()
4756 
 
4757 
  def send_getOrderForAwb(self, awb):
4758 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4759 
    args = getOrderForAwb_args()
4760 
    args.awb = awb
4761 
    args.write(self._oprot)
4762 
    self._oprot.writeMessageEnd()
4763 
    self._oprot.trans.flush()
4764 
 
4765 
  def recv_getOrderForAwb(self, ):
4766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4767 
    if mtype == TMessageType.EXCEPTION:
4768 
      x = TApplicationException()
4769 
      x.read(self._iprot)
4770 
      self._iprot.readMessageEnd()
4771 
      raise x
4772 
    result = getOrderForAwb_result()
4773 
    result.read(self._iprot)
4774 
    self._iprot.readMessageEnd()
4775 
    if result.success is not None:
4776 
      return result.success
4777 
    if result.ex is not None:
4778 
      raise result.ex
4779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4780 
 
4910 phani.kuma 4781 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4782 
    """
4910 phani.kuma 4783 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4784 
 
4506 phani.kuma 4785 
    Parameters:
4786 
     - logistics_provider_id
4910 phani.kuma 4787 
     - order_status_list
4506 phani.kuma 4788 
    """
4910 phani.kuma 4789 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4790 
    return self.recv_getOrdersForProviderForStatus()
4791 
 
4910 phani.kuma 4792 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4793 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4794 
    args = getOrdersForProviderForStatus_args()
4795 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4796 
    args.order_status_list = order_status_list
4506 phani.kuma 4797 
    args.write(self._oprot)
4798 
    self._oprot.writeMessageEnd()
4799 
    self._oprot.trans.flush()
4800 
 
4801 
  def recv_getOrdersForProviderForStatus(self, ):
4802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4803 
    if mtype == TMessageType.EXCEPTION:
4804 
      x = TApplicationException()
4805 
      x.read(self._iprot)
4806 
      self._iprot.readMessageEnd()
4807 
      raise x
4808 
    result = getOrdersForProviderForStatus_result()
4809 
    result.read(self._iprot)
4810 
    self._iprot.readMessageEnd()
4811 
    if result.success is not None:
4812 
      return result.success
4813 
    if result.ex is not None:
4814 
      raise result.ex
4815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4816 
 
4600 varun.gupt 4817 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4818 
    """
4819 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4820 
 
4600 varun.gupt 4821 
    Parameters:
4822 
     - vendorId
4823 
     - billingDateFrom
4824 
     - billingDateTo
4825 
    """
4826 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4827 
    return self.recv_getBilledOrdersForVendor()
4828 
 
4829 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4830 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4831 
    args = getBilledOrdersForVendor_args()
4832 
    args.vendorId = vendorId
4833 
    args.billingDateFrom = billingDateFrom
4834 
    args.billingDateTo = billingDateTo
4835 
    args.write(self._oprot)
4836 
    self._oprot.writeMessageEnd()
4837 
    self._oprot.trans.flush()
4838 
 
4839 
  def recv_getBilledOrdersForVendor(self, ):
4840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4841 
    if mtype == TMessageType.EXCEPTION:
4842 
      x = TApplicationException()
4843 
      x.read(self._iprot)
4844 
      self._iprot.readMessageEnd()
4845 
      raise x
4846 
    result = getBilledOrdersForVendor_result()
4847 
    result.read(self._iprot)
4848 
    self._iprot.readMessageEnd()
4849 
    if result.success is not None:
4850 
      return result.success
4851 
    if result.ex is not None:
4852 
      raise result.ex
4853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4854 
 
4607 rajveer 4855 
  def getSlippedSippingDateOrders(self, ):
4856 
    self.send_getSlippedSippingDateOrders()
4857 
    return self.recv_getSlippedSippingDateOrders()
4858 
 
4859 
  def send_getSlippedSippingDateOrders(self, ):
4860 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4861 
    args = getSlippedSippingDateOrders_args()
4862 
    args.write(self._oprot)
4863 
    self._oprot.writeMessageEnd()
4864 
    self._oprot.trans.flush()
4865 
 
4866 
  def recv_getSlippedSippingDateOrders(self, ):
4867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4868 
    if mtype == TMessageType.EXCEPTION:
4869 
      x = TApplicationException()
4870 
      x.read(self._iprot)
4871 
      self._iprot.readMessageEnd()
4872 
      raise x
4873 
    result = getSlippedSippingDateOrders_result()
4874 
    result.read(self._iprot)
4875 
    self._iprot.readMessageEnd()
4876 
    if result.success is not None:
4877 
      return result.success
4878 
    if result.ex is not None:
4879 
      raise result.ex
4880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4881 
 
4709 rajveer 4882 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4883 
    """
4884 
    Parameters:
4885 
     - cancelDateFrom
4886 
     - cancelDateTo
4887 
    """
4888 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4889 
    return self.recv_getCancelledOrders()
4890 
 
4891 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4892 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4893 
    args = getCancelledOrders_args()
4894 
    args.cancelDateFrom = cancelDateFrom
4895 
    args.cancelDateTo = cancelDateTo
4896 
    args.write(self._oprot)
4897 
    self._oprot.writeMessageEnd()
4898 
    self._oprot.trans.flush()
4899 
 
4900 
  def recv_getCancelledOrders(self, ):
4901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4902 
    if mtype == TMessageType.EXCEPTION:
4903 
      x = TApplicationException()
4904 
      x.read(self._iprot)
4905 
      self._iprot.readMessageEnd()
4906 
      raise x
4907 
    result = getCancelledOrders_result()
4908 
    result.read(self._iprot)
4909 
    self._iprot.readMessageEnd()
4910 
    if result.success is not None:
4911 
      return result.success
4912 
    if result.ex is not None:
4913 
      raise result.ex
4914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4915 
 
4600 varun.gupt 4916 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4917 
    """
4918 
    Parameters:
4919 
     - mapAWBAndAmount
4920 
    """
4921 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4922 
    self.recv_saveBluedartSettlements()
4923 
 
4924 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4925 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4926 
    args = saveBluedartSettlements_args()
4927 
    args.mapAWBAndAmount = mapAWBAndAmount
4928 
    args.write(self._oprot)
4929 
    self._oprot.writeMessageEnd()
4930 
    self._oprot.trans.flush()
4931 
 
4932 
  def recv_saveBluedartSettlements(self, ):
4933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4934 
    if mtype == TMessageType.EXCEPTION:
4935 
      x = TApplicationException()
4936 
      x.read(self._iprot)
4937 
      self._iprot.readMessageEnd()
4938 
      raise x
4939 
    result = saveBluedartSettlements_result()
4940 
    result.read(self._iprot)
4941 
    self._iprot.readMessageEnd()
4942 
    if result.ex is not None:
4943 
      raise result.ex
4944 
    return
4945 
 
4905 varun.gupt 4946 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4947 
    """
4948 
    Parameters:
4949 
     - settlementDate
4950 
     - paymentGatewayId
4905 varun.gupt 4951 
     - referenceId
4600 varun.gupt 4952 
     - serviceTax
4953 
     - otherCharges
4954 
     - netCollection
4955 
    """
4905 varun.gupt 4956 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4957 
    self.recv_savePaymentSettlements()
4958 
 
4905 varun.gupt 4959 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4960 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4961 
    args = savePaymentSettlements_args()
4962 
    args.settlementDate = settlementDate
4963 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4964 
    args.referenceId = referenceId
4600 varun.gupt 4965 
    args.serviceTax = serviceTax
4966 
    args.otherCharges = otherCharges
4967 
    args.netCollection = netCollection
4968 
    args.write(self._oprot)
4969 
    self._oprot.writeMessageEnd()
4970 
    self._oprot.trans.flush()
4971 
 
4972 
  def recv_savePaymentSettlements(self, ):
4973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4974 
    if mtype == TMessageType.EXCEPTION:
4975 
      x = TApplicationException()
4976 
      x.read(self._iprot)
4977 
      self._iprot.readMessageEnd()
4978 
      raise x
4979 
    result = savePaymentSettlements_result()
4980 
    result.read(self._iprot)
4981 
    self._iprot.readMessageEnd()
4982 
    if result.ex is not None:
4983 
      raise result.ex
4984 
    return
4985 
 
4986 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4987 
    """
4988 
    Parameters:
4989 
     - settlementId
4990 
     - settlementDate
4991 
     - transactionDateFrom
4992 
     - transactionDateTo
4993 
     - amount
4994 
    """
4995 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4996 
    self.recv_saveEBSSettlementSummary()
4997 
 
4998 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4999 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5000 
    args = saveEBSSettlementSummary_args()
5001 
    args.settlementId = settlementId
5002 
    args.settlementDate = settlementDate
5003 
    args.transactionDateFrom = transactionDateFrom
5004 
    args.transactionDateTo = transactionDateTo
5005 
    args.amount = amount
5006 
    args.write(self._oprot)
5007 
    self._oprot.writeMessageEnd()
5008 
    self._oprot.trans.flush()
5009 
 
5010 
  def recv_saveEBSSettlementSummary(self, ):
5011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5012 
    if mtype == TMessageType.EXCEPTION:
5013 
      x = TApplicationException()
5014 
      x.read(self._iprot)
5015 
      self._iprot.readMessageEnd()
5016 
      raise x
5017 
    result = saveEBSSettlementSummary_result()
5018 
    result.read(self._iprot)
5019 
    self._iprot.readMessageEnd()
5020 
    if result.ex is not None:
5021 
      raise result.ex
5022 
    return
5023 
 
5386 phani.kuma 5024 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5025 
    """
5026 
    Parameters:
5189 varun.gupt 5027 
     - referenceId
5028 
     - isRefund
4600 varun.gupt 5029 
    """
5386 phani.kuma 5030 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5031 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5032 
 
5386 phani.kuma 5033 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5034 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5035 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5036 
    args.referenceId = referenceId
5037 
    args.isRefund = isRefund
4600 varun.gupt 5038 
    args.write(self._oprot)
5039 
    self._oprot.writeMessageEnd()
5040 
    self._oprot.trans.flush()
5041 
 
5386 phani.kuma 5042 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5044 
    if mtype == TMessageType.EXCEPTION:
5045 
      x = TApplicationException()
5046 
      x.read(self._iprot)
5047 
      self._iprot.readMessageEnd()
5048 
      raise x
5386 phani.kuma 5049 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5050 
    result.read(self._iprot)
5051 
    self._iprot.readMessageEnd()
5052 
    if result.success is not None:
5053 
      return result.success
5054 
    if result.ex is not None:
5055 
      raise result.ex
5386 phani.kuma 5056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5057 
 
5386 phani.kuma 5058 
  def getSettlementForCod(self, orderId, isRefund):
5059 
    """
5060 
    Parameters:
5061 
     - orderId
5062 
     - isRefund
5063 
    """
5064 
    self.send_getSettlementForCod(orderId, isRefund)
5065 
    return self.recv_getSettlementForCod()
5066 
 
5067 
  def send_getSettlementForCod(self, orderId, isRefund):
5068 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5069 
    args = getSettlementForCod_args()
5070 
    args.orderId = orderId
5071 
    args.isRefund = isRefund
5072 
    args.write(self._oprot)
5073 
    self._oprot.writeMessageEnd()
5074 
    self._oprot.trans.flush()
5075 
 
5076 
  def recv_getSettlementForCod(self, ):
5077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5078 
    if mtype == TMessageType.EXCEPTION:
5079 
      x = TApplicationException()
5080 
      x.read(self._iprot)
5081 
      self._iprot.readMessageEnd()
5082 
      raise x
5083 
    result = getSettlementForCod_result()
5084 
    result.read(self._iprot)
5085 
    self._iprot.readMessageEnd()
5086 
    if result.success is not None:
5087 
      return result.success
5088 
    if result.ex is not None:
5089 
      raise result.ex
5090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5091 
 
4600 varun.gupt 5092 
  def getEBSSettlementSummaries(self, ):
5093 
    self.send_getEBSSettlementSummaries()
5094 
    return self.recv_getEBSSettlementSummaries()
5095 
 
5096 
  def send_getEBSSettlementSummaries(self, ):
5097 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5098 
    args = getEBSSettlementSummaries_args()
5099 
    args.write(self._oprot)
5100 
    self._oprot.writeMessageEnd()
5101 
    self._oprot.trans.flush()
5102 
 
5103 
  def recv_getEBSSettlementSummaries(self, ):
5104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5105 
    if mtype == TMessageType.EXCEPTION:
5106 
      x = TApplicationException()
5107 
      x.read(self._iprot)
5108 
      self._iprot.readMessageEnd()
5109 
      raise x
5110 
    result = getEBSSettlementSummaries_result()
5111 
    result.read(self._iprot)
5112 
    self._iprot.readMessageEnd()
5113 
    if result.success is not None:
5114 
      return result.success
5115 
    if result.ex is not None:
5116 
      raise result.ex
5117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5118 
 
5119 
  def markEBSSettlementUploaded(self, settlementId):
5120 
    """
5121 
    Parameters:
5122 
     - settlementId
5123 
    """
5124 
    self.send_markEBSSettlementUploaded(settlementId)
5125 
    self.recv_markEBSSettlementUploaded()
5126 
 
5127 
  def send_markEBSSettlementUploaded(self, settlementId):
5128 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5129 
    args = markEBSSettlementUploaded_args()
5130 
    args.settlementId = settlementId
5131 
    args.write(self._oprot)
5132 
    self._oprot.writeMessageEnd()
5133 
    self._oprot.trans.flush()
5134 
 
5135 
  def recv_markEBSSettlementUploaded(self, ):
5136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5137 
    if mtype == TMessageType.EXCEPTION:
5138 
      x = TApplicationException()
5139 
      x.read(self._iprot)
5140 
      self._iprot.readMessageEnd()
5141 
      raise x
5142 
    result = markEBSSettlementUploaded_result()
5143 
    result.read(self._iprot)
5144 
    self._iprot.readMessageEnd()
5145 
    if result.ex is not None:
5146 
      raise result.ex
5147 
    return
5148 
 
5149 
  def getEBSSettlementDate(self, settlementId):
5150 
    """
5151 
    Parameters:
5152 
     - settlementId
5153 
    """
5154 
    self.send_getEBSSettlementDate(settlementId)
5155 
    return self.recv_getEBSSettlementDate()
5156 
 
5157 
  def send_getEBSSettlementDate(self, settlementId):
5158 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5159 
    args = getEBSSettlementDate_args()
5160 
    args.settlementId = settlementId
5161 
    args.write(self._oprot)
5162 
    self._oprot.writeMessageEnd()
5163 
    self._oprot.trans.flush()
5164 
 
5165 
  def recv_getEBSSettlementDate(self, ):
5166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5167 
    if mtype == TMessageType.EXCEPTION:
5168 
      x = TApplicationException()
5169 
      x.read(self._iprot)
5170 
      self._iprot.readMessageEnd()
5171 
      raise x
5172 
    result = getEBSSettlementDate_result()
5173 
    result.read(self._iprot)
5174 
    self._iprot.readMessageEnd()
5175 
    if result.success is not None:
5176 
      return result.success
5177 
    if result.ex is not None:
5178 
      raise result.ex
5179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5180 
 
4715 varun.gupt 5181 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5182 
    """
5183 
    Parameters:
5184 
     - settlementDateFrom
5185 
     - settlementDateTo
5186 
     - isRefund
5187 
    """
5188 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5189 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5190 
 
4715 varun.gupt 5191 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5192 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5193 
    args = getSettlementsByDate_args()
5194 
    args.settlementDateFrom = settlementDateFrom
5195 
    args.settlementDateTo = settlementDateTo
5196 
    args.isRefund = isRefund
5197 
    args.write(self._oprot)
5198 
    self._oprot.writeMessageEnd()
5199 
    self._oprot.trans.flush()
5200 
 
5201 
  def recv_getSettlementsByDate(self, ):
5202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5203 
    if mtype == TMessageType.EXCEPTION:
5204 
      x = TApplicationException()
5205 
      x.read(self._iprot)
5206 
      self._iprot.readMessageEnd()
5207 
      raise x
5208 
    result = getSettlementsByDate_result()
5209 
    result.read(self._iprot)
5210 
    self._iprot.readMessageEnd()
5211 
    if result.success is not None:
5212 
      return result.success
5213 
    if result.ex is not None:
5214 
      raise result.ex
5215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5216 
 
5217 
  def getReshippedOrderIds(self, orderIds):
5218 
    """
5219 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5220 
 
5221 
    Parameters:
5222 
     - orderIds
5223 
    """
5224 
    self.send_getReshippedOrderIds(orderIds)
5225 
    return self.recv_getReshippedOrderIds()
5226 
 
5227 
  def send_getReshippedOrderIds(self, orderIds):
5228 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5229 
    args = getReshippedOrderIds_args()
5230 
    args.orderIds = orderIds
5231 
    args.write(self._oprot)
5232 
    self._oprot.writeMessageEnd()
5233 
    self._oprot.trans.flush()
5234 
 
5235 
  def recv_getReshippedOrderIds(self, ):
5236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5237 
    if mtype == TMessageType.EXCEPTION:
5238 
      x = TApplicationException()
5239 
      x.read(self._iprot)
5240 
      self._iprot.readMessageEnd()
5241 
      raise x
5242 
    result = getReshippedOrderIds_result()
5243 
    result.read(self._iprot)
5244 
    self._iprot.readMessageEnd()
5245 
    if result.success is not None:
5246 
      return result.success
5247 
    if result.ex is not None:
5248 
      raise result.ex
5249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5250 
 
5481 phani.kuma 5251 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5252 
    """
5253 
    Parameters:
5254 
     - vendorId
5481 phani.kuma 5255 
     - onlyVendorNotPaid
5256 
     - billingDateFrom
5257 
     - billingDateTo
4875 varun.gupt 5258 
    """
5481 phani.kuma 5259 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5260 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5261 
 
5481 phani.kuma 5262 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5263 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5264 
    args = getBilledOrders_args()
4875 varun.gupt 5265 
    args.vendorId = vendorId
5481 phani.kuma 5266 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5267 
    args.billingDateFrom = billingDateFrom
5268 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5269 
    args.write(self._oprot)
5270 
    self._oprot.writeMessageEnd()
5271 
    self._oprot.trans.flush()
5272 
 
5481 phani.kuma 5273 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5275 
    if mtype == TMessageType.EXCEPTION:
5276 
      x = TApplicationException()
5277 
      x.read(self._iprot)
5278 
      self._iprot.readMessageEnd()
5279 
      raise x
5481 phani.kuma 5280 
    result = getBilledOrders_result()
4875 varun.gupt 5281 
    result.read(self._iprot)
5282 
    self._iprot.readMessageEnd()
5283 
    if result.success is not None:
5284 
      return result.success
5285 
    if result.ex is not None:
5286 
      raise result.ex
5481 phani.kuma 5287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5288 
 
5031 varun.gupt 5289 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5290 
    """
5291 
    Parameters:
5292 
     - startDate
5293 
     - endDate
5294 
    """
5295 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5296 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5297 
 
5031 varun.gupt 5298 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5299 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5300 
    args = getStatusDistributionOfOrders_args()
5301 
    args.startDate = startDate
5302 
    args.endDate = endDate
5303 
    args.write(self._oprot)
5304 
    self._oprot.writeMessageEnd()
5305 
    self._oprot.trans.flush()
5306 
 
5307 
  def recv_getStatusDistributionOfOrders(self, ):
5308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5309 
    if mtype == TMessageType.EXCEPTION:
5310 
      x = TApplicationException()
5311 
      x.read(self._iprot)
5312 
      self._iprot.readMessageEnd()
5313 
      raise x
5314 
    result = getStatusDistributionOfOrders_result()
5315 
    result.read(self._iprot)
5316 
    self._iprot.readMessageEnd()
5317 
    if result.success is not None:
5318 
      return result.success
5319 
    if result.ex is not None:
5320 
      raise result.ex
5321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5322 
 
5067 varun.gupt 5323 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5324 
    """
5325 
    Parameters:
5326 
     - status
5327 
     - startDatetime
5328 
     - endDatetime
5329 
    """
5330 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5331 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5332 
 
5067 varun.gupt 5333 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5334 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5335 
    args = getOrderIdsForStatus_args()
5336 
    args.status = status
5337 
    args.startDatetime = startDatetime
5338 
    args.endDatetime = endDatetime
5339 
    args.write(self._oprot)
5340 
    self._oprot.writeMessageEnd()
5341 
    self._oprot.trans.flush()
5342 
 
5343 
  def recv_getOrderIdsForStatus(self, ):
5344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5345 
    if mtype == TMessageType.EXCEPTION:
5346 
      x = TApplicationException()
5347 
      x.read(self._iprot)
5348 
      self._iprot.readMessageEnd()
5349 
      raise x
5350 
    result = getOrderIdsForStatus_result()
5351 
    result.read(self._iprot)
5352 
    self._iprot.readMessageEnd()
5353 
    if result.success is not None:
5354 
      return result.success
5355 
    if result.ex is not None:
5356 
      raise result.ex
5357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5358 
 
5348 anupam.sin 5359 
  def updateCODAgent(self, agent, orderId):
5360 
    """
5361 
    Updates the agent who handled the COD verification call
5362 
 
5363 
    Parameters:
5364 
     - agent
5365 
     - orderId
5366 
    """
5367 
    self.send_updateCODAgent(agent, orderId)
5368 
    self.recv_updateCODAgent()
5369 
 
5370 
  def send_updateCODAgent(self, agent, orderId):
5371 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5372 
    args = updateCODAgent_args()
5373 
    args.agent = agent
5374 
    args.orderId = orderId
5375 
    args.write(self._oprot)
5376 
    self._oprot.writeMessageEnd()
5377 
    self._oprot.trans.flush()
5378 
 
5379 
  def recv_updateCODAgent(self, ):
5380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5381 
    if mtype == TMessageType.EXCEPTION:
5382 
      x = TApplicationException()
5383 
      x.read(self._iprot)
5384 
      self._iprot.readMessageEnd()
5385 
      raise x
5386 
    result = updateCODAgent_result()
5387 
    result.read(self._iprot)
5388 
    self._iprot.readMessageEnd()
5389 
    if result.ex is not None:
5390 
      raise result.ex
5391 
    return
5392 
 
5099 varun.gupt 5393 
  def updateOrderAsPaidToVendor(self, orderId):
5394 
    """
5395 
    Parameters:
5396 
     - orderId
5397 
    """
5398 
    self.send_updateOrderAsPaidToVendor(orderId)
5399 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5400 
 
5099 varun.gupt 5401 
  def send_updateOrderAsPaidToVendor(self, orderId):
5402 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5403 
    args = updateOrderAsPaidToVendor_args()
5404 
    args.orderId = orderId
5405 
    args.write(self._oprot)
5406 
    self._oprot.writeMessageEnd()
5407 
    self._oprot.trans.flush()
5408 
 
5409 
  def recv_updateOrderAsPaidToVendor(self, ):
5410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5411 
    if mtype == TMessageType.EXCEPTION:
5412 
      x = TApplicationException()
5413 
      x.read(self._iprot)
5414 
      self._iprot.readMessageEnd()
5415 
      raise x
5416 
    result = updateOrderAsPaidToVendor_result()
5417 
    result.read(self._iprot)
5418 
    self._iprot.readMessageEnd()
5419 
    if result.ex is not None:
5420 
      raise result.ex
5421 
    return
5422 
 
5386 phani.kuma 5423 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5424 
    """
5425 
    Parameters:
5426 
     - orderId
5427 
    """
5428 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5429 
    self.recv_updateOrderOnlyAsPaidToVendor()
5430 
 
5431 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5432 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5433 
    args = updateOrderOnlyAsPaidToVendor_args()
5434 
    args.orderId = orderId
5435 
    args.write(self._oprot)
5436 
    self._oprot.writeMessageEnd()
5437 
    self._oprot.trans.flush()
5438 
 
5439 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5441 
    if mtype == TMessageType.EXCEPTION:
5442 
      x = TApplicationException()
5443 
      x.read(self._iprot)
5444 
      self._iprot.readMessageEnd()
5445 
      raise x
5446 
    result = updateOrderOnlyAsPaidToVendor_result()
5447 
    result.read(self._iprot)
5448 
    self._iprot.readMessageEnd()
5449 
    if result.ex is not None:
5450 
      raise result.ex
5451 
    return
5452 
 
5208 varun.gupt 5453 
  def getRefundedOrdersMarkedPaid(self, ):
5454 
    self.send_getRefundedOrdersMarkedPaid()
5455 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5456 
 
5208 varun.gupt 5457 
  def send_getRefundedOrdersMarkedPaid(self, ):
5458 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5459 
    args = getRefundedOrdersMarkedPaid_args()
5460 
    args.write(self._oprot)
5461 
    self._oprot.writeMessageEnd()
5462 
    self._oprot.trans.flush()
5463 
 
5464 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5466 
    if mtype == TMessageType.EXCEPTION:
5467 
      x = TApplicationException()
5468 
      x.read(self._iprot)
5469 
      self._iprot.readMessageEnd()
5470 
      raise x
5471 
    result = getRefundedOrdersMarkedPaid_result()
5472 
    result.read(self._iprot)
5473 
    self._iprot.readMessageEnd()
5474 
    if result.success is not None:
5475 
      return result.success
5476 
    if result.ex is not None:
5477 
      raise result.ex
5478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5479 
 
5447 anupam.sin 5480 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5481 
    """
5482 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5483 
 
5447 anupam.sin 5484 
 
5485 
    Parameters:
5486 
     - minOrderId
5487 
     - maxOrderId
5488 
    """
5489 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5490 
    return self.recv_getAllVerificationAgents()
5491 
 
5492 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5493 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5494 
    args = getAllVerificationAgents_args()
5495 
    args.minOrderId = minOrderId
5496 
    args.maxOrderId = maxOrderId
5497 
    args.write(self._oprot)
5498 
    self._oprot.writeMessageEnd()
5499 
    self._oprot.trans.flush()
5500 
 
5501 
  def recv_getAllVerificationAgents(self, ):
5502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5503 
    if mtype == TMessageType.EXCEPTION:
5504 
      x = TApplicationException()
5505 
      x.read(self._iprot)
5506 
      self._iprot.readMessageEnd()
5507 
      raise x
5508 
    result = getAllVerificationAgents_result()
5509 
    result.read(self._iprot)
5510 
    self._iprot.readMessageEnd()
5511 
    if result.success is not None:
5512 
      return result.success
5513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5514 
 
5527 anupam.sin 5515 
  def getAllAttributesForOrderId(self, orderId):
5516 
    """
5517 
    gets all attributes for a given orderId
5447 anupam.sin 5518 
 
5527 anupam.sin 5519 
    Parameters:
5520 
     - orderId
5521 
    """
5522 
    self.send_getAllAttributesForOrderId(orderId)
5523 
    return self.recv_getAllAttributesForOrderId()
5524 
 
5525 
  def send_getAllAttributesForOrderId(self, orderId):
5526 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5527 
    args = getAllAttributesForOrderId_args()
5528 
    args.orderId = orderId
5529 
    args.write(self._oprot)
5530 
    self._oprot.writeMessageEnd()
5531 
    self._oprot.trans.flush()
5532 
 
5533 
  def recv_getAllAttributesForOrderId(self, ):
5534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5535 
    if mtype == TMessageType.EXCEPTION:
5536 
      x = TApplicationException()
5537 
      x.read(self._iprot)
5538 
      self._iprot.readMessageEnd()
5539 
      raise x
5540 
    result = getAllAttributesForOrderId_result()
5541 
    result.read(self._iprot)
5542 
    self._iprot.readMessageEnd()
5543 
    if result.success is not None:
5544 
      return result.success
5545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5546 
 
5676 rajveer 5547 
  def setOrderAttributes(self, orderId, attributes):
5548 
    """
5549 
    sets attributes for an order
5550 
 
5551 
    Parameters:
5552 
     - orderId
5553 
     - attributes
5554 
    """
5555 
    self.send_setOrderAttributes(orderId, attributes)
5556 
    self.recv_setOrderAttributes()
5557 
 
5558 
  def send_setOrderAttributes(self, orderId, attributes):
5559 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5560 
    args = setOrderAttributes_args()
5561 
    args.orderId = orderId
5562 
    args.attributes = attributes
5563 
    args.write(self._oprot)
5564 
    self._oprot.writeMessageEnd()
5565 
    self._oprot.trans.flush()
5566 
 
5567 
  def recv_setOrderAttributes(self, ):
5568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5569 
    if mtype == TMessageType.EXCEPTION:
5570 
      x = TApplicationException()
5571 
      x.read(self._iprot)
5572 
      self._iprot.readMessageEnd()
5573 
      raise x
5574 
    result = setOrderAttributes_result()
5575 
    result.read(self._iprot)
5576 
    self._iprot.readMessageEnd()
5577 
    return
5578 
 
5527 anupam.sin 5579 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5580 
    """
5581 
    sets attributes for all orders in a transaction
5582 
 
5583 
    Parameters:
5584 
     - transactionId
5585 
     - attribute
5586 
    """
5587 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5588 
    self.recv_setOrderAttributeForTransaction()
5589 
 
5590 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5591 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5592 
    args = setOrderAttributeForTransaction_args()
5593 
    args.transactionId = transactionId
5594 
    args.attribute = attribute
5595 
    args.write(self._oprot)
5596 
    self._oprot.writeMessageEnd()
5597 
    self._oprot.trans.flush()
5598 
 
5599 
  def recv_setOrderAttributeForTransaction(self, ):
5600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5601 
    if mtype == TMessageType.EXCEPTION:
5602 
      x = TApplicationException()
5603 
      x.read(self._iprot)
5604 
      self._iprot.readMessageEnd()
5605 
      raise x
5606 
    result = setOrderAttributeForTransaction_result()
5607 
    result.read(self._iprot)
5608 
    self._iprot.readMessageEnd()
5609 
    return
5610 
 
5553 rajveer 5611 
  def getReceivePendingOrders(self, storeId):
5612 
    """
5613 
    Parameters:
5614 
     - storeId
5615 
    """
5616 
    self.send_getReceivePendingOrders(storeId)
5617 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5618 
 
5553 rajveer 5619 
  def send_getReceivePendingOrders(self, storeId):
5620 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5621 
    args = getReceivePendingOrders_args()
5622 
    args.storeId = storeId
5623 
    args.write(self._oprot)
5624 
    self._oprot.writeMessageEnd()
5625 
    self._oprot.trans.flush()
5626 
 
5627 
  def recv_getReceivePendingOrders(self, ):
5628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5629 
    if mtype == TMessageType.EXCEPTION:
5630 
      x = TApplicationException()
5631 
      x.read(self._iprot)
5632 
      self._iprot.readMessageEnd()
5633 
      raise x
5634 
    result = getReceivePendingOrders_result()
5635 
    result.read(self._iprot)
5636 
    self._iprot.readMessageEnd()
5637 
    if result.success is not None:
5638 
      return result.success
5639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5640 
 
5641 
  def getReceivedAtStoreOrders(self, storeId):
5642 
    """
5643 
    Parameters:
5644 
     - storeId
5645 
    """
5646 
    self.send_getReceivedAtStoreOrders(storeId)
5647 
    return self.recv_getReceivedAtStoreOrders()
5648 
 
5649 
  def send_getReceivedAtStoreOrders(self, storeId):
5650 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5651 
    args = getReceivedAtStoreOrders_args()
5652 
    args.storeId = storeId
5653 
    args.write(self._oprot)
5654 
    self._oprot.writeMessageEnd()
5655 
    self._oprot.trans.flush()
5656 
 
5657 
  def recv_getReceivedAtStoreOrders(self, ):
5658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5659 
    if mtype == TMessageType.EXCEPTION:
5660 
      x = TApplicationException()
5661 
      x.read(self._iprot)
5662 
      self._iprot.readMessageEnd()
5663 
      raise x
5664 
    result = getReceivedAtStoreOrders_result()
5665 
    result.read(self._iprot)
5666 
    self._iprot.readMessageEnd()
5667 
    if result.success is not None:
5668 
      return result.success
5669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5670 
 
5713 rajveer 5671 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5672 
    """
5673 
    Parameters:
5674 
     - storeId
5675 
     - fromDate
5676 
     - toDate
5677 
     - onlyCod
5678 
    """
5679 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5680 
    return self.recv_getOrdersCollectionAtStore()
5681 
 
5682 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5683 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5684 
    args = getOrdersCollectionAtStore_args()
5685 
    args.storeId = storeId
5686 
    args.fromDate = fromDate
5687 
    args.toDate = toDate
5688 
    args.onlyCod = onlyCod
5689 
    args.write(self._oprot)
5690 
    self._oprot.writeMessageEnd()
5691 
    self._oprot.trans.flush()
5692 
 
5693 
  def recv_getOrdersCollectionAtStore(self, ):
5694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5695 
    if mtype == TMessageType.EXCEPTION:
5696 
      x = TApplicationException()
5697 
      x.read(self._iprot)
5698 
      self._iprot.readMessageEnd()
5699 
      raise x
5700 
    result = getOrdersCollectionAtStore_result()
5701 
    result.read(self._iprot)
5702 
    self._iprot.readMessageEnd()
5703 
    if result.success is not None:
5704 
      return result.success
5705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5706 
 
5833 rajveer 5707 
  def getOrderAttributeValue(self, orderId, attributeName):
5708 
    """
5709 
    Parameters:
5710 
     - orderId
5711 
     - attributeName
5712 
    """
5713 
    self.send_getOrderAttributeValue(orderId, attributeName)
5714 
    return self.recv_getOrderAttributeValue()
5715 
 
5716 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5717 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5718 
    args = getOrderAttributeValue_args()
5719 
    args.orderId = orderId
5720 
    args.attributeName = attributeName
5721 
    args.write(self._oprot)
5722 
    self._oprot.writeMessageEnd()
5723 
    self._oprot.trans.flush()
5724 
 
5725 
  def recv_getOrderAttributeValue(self, ):
5726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5727 
    if mtype == TMessageType.EXCEPTION:
5728 
      x = TApplicationException()
5729 
      x.read(self._iprot)
5730 
      self._iprot.readMessageEnd()
5731 
      raise x
5732 
    result = getOrderAttributeValue_result()
5733 
    result.read(self._iprot)
5734 
    self._iprot.readMessageEnd()
5735 
    if result.success is not None:
5736 
      return result.success
5737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5738 
 
6019 rajveer 5739 
  def changeJacketNumber(self, orderId, jacketNumber):
5740 
    """
5741 
    Parameters:
5742 
     - orderId
5743 
     - jacketNumber
5744 
    """
5745 
    self.send_changeJacketNumber(orderId, jacketNumber)
5746 
    return self.recv_changeJacketNumber()
5747 
 
5748 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5749 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5750 
    args = changeJacketNumber_args()
5751 
    args.orderId = orderId
5752 
    args.jacketNumber = jacketNumber
5753 
    args.write(self._oprot)
5754 
    self._oprot.writeMessageEnd()
5755 
    self._oprot.trans.flush()
5756 
 
5757 
  def recv_changeJacketNumber(self, ):
5758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5759 
    if mtype == TMessageType.EXCEPTION:
5760 
      x = TApplicationException()
5761 
      x.read(self._iprot)
5762 
      self._iprot.readMessageEnd()
5763 
      raise x
5764 
    result = changeJacketNumber_result()
5765 
    result.read(self._iprot)
5766 
    self._iprot.readMessageEnd()
5767 
    if result.success is not None:
5768 
      return result.success
5769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5770 
 
5771 
  def markOrderAsRtoInTransit(self, orderId):
5772 
    """
5773 
    Parameters:
5774 
     - orderId
5775 
    """
5776 
    self.send_markOrderAsRtoInTransit(orderId)
5777 
    return self.recv_markOrderAsRtoInTransit()
5778 
 
5779 
  def send_markOrderAsRtoInTransit(self, orderId):
5780 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5781 
    args = markOrderAsRtoInTransit_args()
5782 
    args.orderId = orderId
5783 
    args.write(self._oprot)
5784 
    self._oprot.writeMessageEnd()
5785 
    self._oprot.trans.flush()
5786 
 
5787 
  def recv_markOrderAsRtoInTransit(self, ):
5788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5789 
    if mtype == TMessageType.EXCEPTION:
5790 
      x = TApplicationException()
5791 
      x.read(self._iprot)
5792 
      self._iprot.readMessageEnd()
5793 
      raise x
5794 
    result = markOrderAsRtoInTransit_result()
5795 
    result.read(self._iprot)
5796 
    self._iprot.readMessageEnd()
5797 
    if result.success is not None:
5798 
      return result.success
5799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5800 
 
5593 mandeep.dh 5801 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5802 
    """
5803 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5804 
    invoked while scanning IN of items.
5553 rajveer 5805 
 
5593 mandeep.dh 5806 
    Parameters:
5807 
     - itemId
5808 
     - quantity
5809 
     - fulfilmentWarehouseId
5810 
     - billingWarehouseId
5811 
    """
5812 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5813 
    self.recv_acceptOrderForItem()
5814 
 
5815 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5816 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5817 
    args = acceptOrderForItem_args()
5818 
    args.itemId = itemId
5819 
    args.quantity = quantity
5820 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5821 
    args.billingWarehouseId = billingWarehouseId
5822 
    args.write(self._oprot)
5823 
    self._oprot.writeMessageEnd()
5824 
    self._oprot.trans.flush()
5825 
 
5826 
  def recv_acceptOrderForItem(self, ):
5827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5828 
    if mtype == TMessageType.EXCEPTION:
5829 
      x = TApplicationException()
5830 
      x.read(self._iprot)
5831 
      self._iprot.readMessageEnd()
5832 
      raise x
5833 
    result = acceptOrderForItem_result()
5834 
    result.read(self._iprot)
5835 
    self._iprot.readMessageEnd()
5836 
    return
5837 
 
6000 mandeep.dh 5838 
  def createRechargeOrder(self, rechargeOrder):
5839 
    """
5840 
    Parameters:
5841 
     - rechargeOrder
5842 
    """
5843 
    self.send_createRechargeOrder(rechargeOrder)
5844 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5845 
 
6000 mandeep.dh 5846 
  def send_createRechargeOrder(self, rechargeOrder):
5847 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5848 
    args = createRechargeOrder_args()
5849 
    args.rechargeOrder = rechargeOrder
5850 
    args.write(self._oprot)
5851 
    self._oprot.writeMessageEnd()
5852 
    self._oprot.trans.flush()
5853 
 
5854 
  def recv_createRechargeOrder(self, ):
5855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5856 
    if mtype == TMessageType.EXCEPTION:
5857 
      x = TApplicationException()
5858 
      x.read(self._iprot)
5859 
      self._iprot.readMessageEnd()
5860 
      raise x
5861 
    result = createRechargeOrder_result()
5862 
    result.read(self._iprot)
5863 
    self._iprot.readMessageEnd()
5864 
    if result.success is not None:
5865 
      return result.success
5866 
    if result.ex is not None:
5867 
      raise result.ex
5868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5869 
 
6031 rajveer 5870 
  def getRechargeOrder(self, rechargeRrderId):
5871 
    """
5872 
    Parameters:
5873 
     - rechargeRrderId
5874 
    """
5875 
    self.send_getRechargeOrder(rechargeRrderId)
5876 
    return self.recv_getRechargeOrder()
5877 
 
5878 
  def send_getRechargeOrder(self, rechargeRrderId):
5879 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5880 
    args = getRechargeOrder_args()
5881 
    args.rechargeRrderId = rechargeRrderId
5882 
    args.write(self._oprot)
5883 
    self._oprot.writeMessageEnd()
5884 
    self._oprot.trans.flush()
5885 
 
5886 
  def recv_getRechargeOrder(self, ):
5887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5888 
    if mtype == TMessageType.EXCEPTION:
5889 
      x = TApplicationException()
5890 
      x.read(self._iprot)
5891 
      self._iprot.readMessageEnd()
5892 
      raise x
5893 
    result = getRechargeOrder_result()
5894 
    result.read(self._iprot)
5895 
    self._iprot.readMessageEnd()
5896 
    if result.success is not None:
5897 
      return result.success
5898 
    if result.ex is not None:
5899 
      raise result.ex
5900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5901 
 
5902 
  def getRechargeOrders(self, userId):
5903 
    """
5904 
    Parameters:
5905 
     - userId
5906 
    """
5907 
    self.send_getRechargeOrders(userId)
5908 
    return self.recv_getRechargeOrders()
5909 
 
5910 
  def send_getRechargeOrders(self, userId):
5911 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5912 
    args = getRechargeOrders_args()
5913 
    args.userId = userId
5914 
    args.write(self._oprot)
5915 
    self._oprot.writeMessageEnd()
5916 
    self._oprot.trans.flush()
5917 
 
5918 
  def recv_getRechargeOrders(self, ):
5919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5920 
    if mtype == TMessageType.EXCEPTION:
5921 
      x = TApplicationException()
5922 
      x.read(self._iprot)
5923 
      self._iprot.readMessageEnd()
5924 
      raise x
5925 
    result = getRechargeOrders_result()
5926 
    result.read(self._iprot)
5927 
    self._iprot.readMessageEnd()
5928 
    if result.success is not None:
5929 
      return result.success
5930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5931 
 
6000 mandeep.dh 5932 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5933 
    """
5934 
    Parameters:
5935 
     - rechargeOrderId
5936 
     - rechargeOrderStatus
5937 
    """
5938 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5939 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5940 
 
5941 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5942 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5943 
    args = updateRechargeOrderStatus_args()
5944 
    args.rechargeOrderId = rechargeOrderId
5945 
    args.rechargeOrderStatus = rechargeOrderStatus
5946 
    args.write(self._oprot)
5947 
    self._oprot.writeMessageEnd()
5948 
    self._oprot.trans.flush()
5949 
 
5950 
  def recv_updateRechargeOrderStatus(self, ):
5951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5952 
    if mtype == TMessageType.EXCEPTION:
5953 
      x = TApplicationException()
5954 
      x.read(self._iprot)
5955 
      self._iprot.readMessageEnd()
5956 
      raise x
5957 
    result = updateRechargeOrderStatus_result()
5958 
    result.read(self._iprot)
5959 
    self._iprot.readMessageEnd()
6031 rajveer 5960 
    if result.success is not None:
5961 
      return result.success
6000 mandeep.dh 5962 
    if result.ex is not None:
5963 
      raise result.ex
6031 rajveer 5964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5965 
 
6031 rajveer 5966 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5967 
    """
5968 
    Parameters:
6031 rajveer 5969 
     - rechargeOrderId
6000 mandeep.dh 5970 
    """
6031 rajveer 5971 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5972 
    return self.recv_activateRechargeTxn()
5973 
 
6031 rajveer 5974 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5975 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5976 
    args = activateRechargeTxn_args()
6031 rajveer 5977 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5978 
    args.write(self._oprot)
5979 
    self._oprot.writeMessageEnd()
5980 
    self._oprot.trans.flush()
5981 
 
5982 
  def recv_activateRechargeTxn(self, ):
5983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5984 
    if mtype == TMessageType.EXCEPTION:
5985 
      x = TApplicationException()
5986 
      x.read(self._iprot)
5987 
      self._iprot.readMessageEnd()
5988 
      raise x
5989 
    result = activateRechargeTxn_result()
5990 
    result.read(self._iprot)
5991 
    self._iprot.readMessageEnd()
5992 
    if result.success is not None:
5993 
      return result.success
5994 
    if result.ex is not None:
5995 
      raise result.ex
5996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5997 
 
6031 rajveer 5998 
  def getUserWallet(self, userId):
6000 mandeep.dh 5999 
    """
6000 
    Parameters:
6031 rajveer 6001 
     - userId
6000 mandeep.dh 6002 
    """
6031 rajveer 6003 
    self.send_getUserWallet(userId)
6004 
    return self.recv_getUserWallet()
6000 mandeep.dh 6005 
 
6031 rajveer 6006 
  def send_getUserWallet(self, userId):
6007 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6008 
    args = getUserWallet_args()
6009 
    args.userId = userId
6000 mandeep.dh 6010 
    args.write(self._oprot)
6011 
    self._oprot.writeMessageEnd()
6012 
    self._oprot.trans.flush()
6013 
 
6031 rajveer 6014 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6016 
    if mtype == TMessageType.EXCEPTION:
6017 
      x = TApplicationException()
6018 
      x.read(self._iprot)
6019 
      self._iprot.readMessageEnd()
6020 
      raise x
6031 rajveer 6021 
    result = getUserWallet_result()
6000 mandeep.dh 6022 
    result.read(self._iprot)
6023 
    self._iprot.readMessageEnd()
6024 
    if result.success is not None:
6025 
      return result.success
6031 rajveer 6026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6027 
 
6031 rajveer 6028 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6029 
    """
6030 
    Parameters:
6031 rajveer 6031 
     - userId
6000 mandeep.dh 6032 
    """
6031 rajveer 6033 
    self.send_getUserWalletHistory(userId)
6034 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6035 
 
6031 rajveer 6036 
  def send_getUserWalletHistory(self, userId):
6037 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6038 
    args = getUserWalletHistory_args()
6039 
    args.userId = userId
6000 mandeep.dh 6040 
    args.write(self._oprot)
6041 
    self._oprot.writeMessageEnd()
6042 
    self._oprot.trans.flush()
6043 
 
6031 rajveer 6044 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6046 
    if mtype == TMessageType.EXCEPTION:
6047 
      x = TApplicationException()
6048 
      x.read(self._iprot)
6049 
      self._iprot.readMessageEnd()
6050 
      raise x
6031 rajveer 6051 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6052 
    result.read(self._iprot)
6053 
    self._iprot.readMessageEnd()
6054 
    if result.success is not None:
6055 
      return result.success
6031 rajveer 6056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6057 
 
6050 anupam.sin 6058 
  def getRechargeOrdersForTransaction(self, txnId):
6059 
    """
6060 
    Returns a recharge order for a given transactionId
6061 
 
6062 
    Parameters:
6063 
     - txnId
6064 
    """
6065 
    self.send_getRechargeOrdersForTransaction(txnId)
6066 
    return self.recv_getRechargeOrdersForTransaction()
6067 
 
6068 
  def send_getRechargeOrdersForTransaction(self, txnId):
6069 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6070 
    args = getRechargeOrdersForTransaction_args()
6071 
    args.txnId = txnId
6072 
    args.write(self._oprot)
6073 
    self._oprot.writeMessageEnd()
6074 
    self._oprot.trans.flush()
6075 
 
6076 
  def recv_getRechargeOrdersForTransaction(self, ):
6077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6078 
    if mtype == TMessageType.EXCEPTION:
6079 
      x = TApplicationException()
6080 
      x.read(self._iprot)
6081 
      self._iprot.readMessageEnd()
6082 
      raise x
6083 
    result = getRechargeOrdersForTransaction_result()
6084 
    result.read(self._iprot)
6085 
    self._iprot.readMessageEnd()
6086 
    if result.success is not None:
6087 
      return result.success
6088 
    if result.ex is not None:
6089 
      raise result.ex
6090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6091 
 
6206 rajveer 6092 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6093 
    """
6094 
    Parameters:
6095 
     - rechargeType
6206 rajveer 6096 
     - onlyActive
6048 rajveer 6097 
    """
6206 rajveer 6098 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6099 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6100 
 
6206 rajveer 6101 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6102 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6103 
    args = getServiceProviders_args()
6104 
    args.rechargeType = rechargeType
6206 rajveer 6105 
    args.onlyActive = onlyActive
6048 rajveer 6106 
    args.write(self._oprot)
6107 
    self._oprot.writeMessageEnd()
6108 
    self._oprot.trans.flush()
6109 
 
6110 
  def recv_getServiceProviders(self, ):
6111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6112 
    if mtype == TMessageType.EXCEPTION:
6113 
      x = TApplicationException()
6114 
      x.read(self._iprot)
6115 
      self._iprot.readMessageEnd()
6116 
      raise x
6117 
    result = getServiceProviders_result()
6118 
    result.read(self._iprot)
6119 
    self._iprot.readMessageEnd()
6120 
    if result.success is not None:
6121 
      return result.success
6122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6123 
 
6049 rajveer 6124 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6125 
    """
6126 
    Parameters:
6049 rajveer 6127 
     - rechargeType
6048 rajveer 6128 
     - deviceNumber
6129 
    """
6049 rajveer 6130 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6131 
    return self.recv_getServiceProviderForDevice()
6132 
 
6049 rajveer 6133 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6134 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6135 
    args = getServiceProviderForDevice_args()
6049 rajveer 6136 
    args.rechargeType = rechargeType
6048 rajveer 6137 
    args.deviceNumber = deviceNumber
6138 
    args.write(self._oprot)
6139 
    self._oprot.writeMessageEnd()
6140 
    self._oprot.trans.flush()
6141 
 
6142 
  def recv_getServiceProviderForDevice(self, ):
6143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6144 
    if mtype == TMessageType.EXCEPTION:
6145 
      x = TApplicationException()
6146 
      x.read(self._iprot)
6147 
      self._iprot.readMessageEnd()
6148 
      raise x
6149 
    result = getServiceProviderForDevice_result()
6150 
    result.read(self._iprot)
6151 
    self._iprot.readMessageEnd()
6152 
    if result.success is not None:
6153 
      return result.success
6154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6155 
 
6094 rajveer 6156 
  def getRechargeOrdersForDevice(self, deviceNumber):
6157 
    """
6158 
    Parameters:
6159 
     - deviceNumber
6160 
    """
6161 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6162 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6163 
 
6094 rajveer 6164 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6165 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6166 
    args = getRechargeOrdersForDevice_args()
6167 
    args.deviceNumber = deviceNumber
6168 
    args.write(self._oprot)
6169 
    self._oprot.writeMessageEnd()
6170 
    self._oprot.trans.flush()
6171 
 
6172 
  def recv_getRechargeOrdersForDevice(self, ):
6173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6174 
    if mtype == TMessageType.EXCEPTION:
6175 
      x = TApplicationException()
6176 
      x.read(self._iprot)
6177 
      self._iprot.readMessageEnd()
6178 
      raise x
6179 
    result = getRechargeOrdersForDevice_result()
6180 
    result.read(self._iprot)
6181 
    self._iprot.readMessageEnd()
6182 
    if result.success is not None:
6183 
      return result.success
6184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6185 
 
6186 
  def addAmountToWallet(self, userId, orderId, amount):
6187 
    """
6188 
    Parameters:
6189 
     - userId
6190 
     - orderId
6191 
     - amount
6192 
    """
6193 
    self.send_addAmountToWallet(userId, orderId, amount)
6194 
    self.recv_addAmountToWallet()
6195 
 
6196 
  def send_addAmountToWallet(self, userId, orderId, amount):
6197 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6198 
    args = addAmountToWallet_args()
6199 
    args.userId = userId
6200 
    args.orderId = orderId
6201 
    args.amount = amount
6202 
    args.write(self._oprot)
6203 
    self._oprot.writeMessageEnd()
6204 
    self._oprot.trans.flush()
6205 
 
6206 
  def recv_addAmountToWallet(self, ):
6207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6208 
    if mtype == TMessageType.EXCEPTION:
6209 
      x = TApplicationException()
6210 
      x.read(self._iprot)
6211 
      self._iprot.readMessageEnd()
6212 
      raise x
6213 
    result = addAmountToWallet_result()
6214 
    result.read(self._iprot)
6215 
    self._iprot.readMessageEnd()
6216 
    return
6217 
 
6188 rajveer 6218 
  def getRechargeStatistics(self, ):
6219 
    self.send_getRechargeStatistics()
6220 
    return self.recv_getRechargeStatistics()
6221 
 
6222 
  def send_getRechargeStatistics(self, ):
6223 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6224 
    args = getRechargeStatistics_args()
6225 
    args.write(self._oprot)
6226 
    self._oprot.writeMessageEnd()
6227 
    self._oprot.trans.flush()
6228 
 
6229 
  def recv_getRechargeStatistics(self, ):
6230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6231 
    if mtype == TMessageType.EXCEPTION:
6232 
      x = TApplicationException()
6233 
      x.read(self._iprot)
6234 
      self._iprot.readMessageEnd()
6235 
      raise x
6236 
    result = getRechargeStatistics_result()
6237 
    result.read(self._iprot)
6238 
    self._iprot.readMessageEnd()
6239 
    if result.success is not None:
6240 
      return result.success
6241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6242 
 
6154 rajveer 6243 
  def getRechargeOrdersForStatus(self, status):
6244 
    """
6245 
    Parameters:
6246 
     - status
6247 
    """
6248 
    self.send_getRechargeOrdersForStatus(status)
6249 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6250 
 
6154 rajveer 6251 
  def send_getRechargeOrdersForStatus(self, status):
6252 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6253 
    args = getRechargeOrdersForStatus_args()
6254 
    args.status = status
6255 
    args.write(self._oprot)
6256 
    self._oprot.writeMessageEnd()
6257 
    self._oprot.trans.flush()
6258 
 
6259 
  def recv_getRechargeOrdersForStatus(self, ):
6260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6261 
    if mtype == TMessageType.EXCEPTION:
6262 
      x = TApplicationException()
6263 
      x.read(self._iprot)
6264 
      self._iprot.readMessageEnd()
6265 
      raise x
6266 
    result = getRechargeOrdersForStatus_result()
6267 
    result.read(self._iprot)
6268 
    self._iprot.readMessageEnd()
6269 
    if result.success is not None:
6270 
      return result.success
6271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6272 
 
6159 rajveer 6273 
  def getPlansForOperator(self, operatorId):
6274 
    """
6275 
    Parameters:
6276 
     - operatorId
6277 
    """
6278 
    self.send_getPlansForOperator(operatorId)
6279 
    return self.recv_getPlansForOperator()
6154 rajveer 6280 
 
6159 rajveer 6281 
  def send_getPlansForOperator(self, operatorId):
6282 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6283 
    args = getPlansForOperator_args()
6284 
    args.operatorId = operatorId
6285 
    args.write(self._oprot)
6286 
    self._oprot.writeMessageEnd()
6287 
    self._oprot.trans.flush()
6288 
 
6289 
  def recv_getPlansForOperator(self, ):
6290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6291 
    if mtype == TMessageType.EXCEPTION:
6292 
      x = TApplicationException()
6293 
      x.read(self._iprot)
6294 
      self._iprot.readMessageEnd()
6295 
      raise x
6296 
    result = getPlansForOperator_result()
6297 
    result.read(self._iprot)
6298 
    self._iprot.readMessageEnd()
6299 
    if result.success is not None:
6300 
      return result.success
6301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6302 
 
6303 
 
3376 rajveer 6304 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6305 
  def __init__(self, handler):
3376 rajveer 6306 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6307 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6308 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6309 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6310 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6311 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6312 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6313 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6314 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6315 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6316 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6317 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6318 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6319 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6320 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6321 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6322 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6323 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6324 
    self._processMap["createOrder"] = Processor.process_createOrder
6325 
    self._processMap["getOrder"] = Processor.process_getOrder
6326 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6327 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6328 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6329 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6330 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6331 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6332 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6333 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6334 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6335 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6336 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6337 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6338 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6339 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6340 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6341 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6342 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6343 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6344 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6345 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6346 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6347 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6348 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6349 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6350 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6351 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6352 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6353 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6354 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6355 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6356 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6357 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6358 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6359 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6360 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6361 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6362 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6363 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6364 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6365 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6366 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6367 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6368 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6369 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6370 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6371 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6372 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6373 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6374 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6375 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6376 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6377 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6378 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6379 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6380 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6381 
    self._processMap["changeItem"] = Processor.process_changeItem
6382 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6383 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6384 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6385 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6386 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6387 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6388 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6389 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6390 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6391 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6392 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6393 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6394 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6395 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6396 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6397 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6398 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6399 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6400 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6401 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6402 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6403 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6404 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6405 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6406 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6407 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6408 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6409 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6410 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6411 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6412 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6413 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6414 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6415 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6416 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6417 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6418 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6419 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6420 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6421 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6422 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6423 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6424 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6425 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6426 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6427 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6428 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6429 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6430 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6431 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6432 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6433 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6434 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6435 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6436 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6437 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6438 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6439 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6440 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6441 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6442 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6443 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6094 rajveer 6444 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6445 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6446 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6447 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6448 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
94 ashish 6449 
 
6450 
  def process(self, iprot, oprot):
6451 
    (name, type, seqid) = iprot.readMessageBegin()
6452 
    if name not in self._processMap:
6453 
      iprot.skip(TType.STRUCT)
6454 
      iprot.readMessageEnd()
6455 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6456 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6457 
      x.write(oprot)
6458 
      oprot.writeMessageEnd()
6459 
      oprot.trans.flush()
6460 
      return
6461 
    else:
6462 
      self._processMap[name](self, seqid, iprot, oprot)
6463 
    return True
6464 
 
6465 
  def process_createTransaction(self, seqid, iprot, oprot):
6466 
    args = createTransaction_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = createTransaction_result()
6470 
    try:
132 ashish 6471 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6472 
    except TransactionServiceException, ex:
6473 
      result.ex = ex
6474 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6475 
    result.write(oprot)
6476 
    oprot.writeMessageEnd()
6477 
    oprot.trans.flush()
6478 
 
6479 
  def process_getTransaction(self, seqid, iprot, oprot):
6480 
    args = getTransaction_args()
6481 
    args.read(iprot)
6482 
    iprot.readMessageEnd()
6483 
    result = getTransaction_result()
6484 
    try:
6485 
      result.success = self._handler.getTransaction(args.id)
6486 
    except TransactionServiceException, ex:
6487 
      result.ex = ex
6488 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6489 
    result.write(oprot)
6490 
    oprot.writeMessageEnd()
6491 
    oprot.trans.flush()
6492 
 
6493 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6494 
    args = getTransactionsForCustomer_args()
6495 
    args.read(iprot)
6496 
    iprot.readMessageEnd()
6497 
    result = getTransactionsForCustomer_result()
6498 
    try:
6499 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6500 
    except TransactionServiceException, ex:
6501 
      result.ex = ex
6502 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
132 ashish 6507 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6508 
    args = getTransactionsForShoppingCartId_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = getTransactionsForShoppingCartId_result()
6512 
    try:
6513 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6514 
    except TransactionServiceException, ex:
6515 
      result.ex = ex
6516 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
94 ashish 6521 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6522 
    args = getTransactionStatus_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getTransactionStatus_result()
6526 
    try:
6527 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6528 
    except TransactionServiceException, ex:
6529 
      result.ex = ex
6530 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
6534 
 
6535 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6536 
    args = changeTransactionStatus_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = changeTransactionStatus_result()
6540 
    try:
5527 anupam.sin 6541 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
6548 
 
1398 varun.gupt 6549 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6550 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
1398 varun.gupt 6553 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6554 
    try:
1398 varun.gupt 6555 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6556 
    except TransactionServiceException, ex:
6557 
      result.ex = ex
1398 varun.gupt 6558 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6559 
    result.write(oprot)
6560 
    oprot.writeMessageEnd()
6561 
    oprot.trans.flush()
6562 
 
483 rajveer 6563 
  def process_getAllOrders(self, seqid, iprot, oprot):
6564 
    args = getAllOrders_args()
94 ashish 6565 
    args.read(iprot)
6566 
    iprot.readMessageEnd()
483 rajveer 6567 
    result = getAllOrders_result()
94 ashish 6568 
    try:
4801 anupam.sin 6569 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6570 
    except TransactionServiceException, ex:
6571 
      result.ex = ex
483 rajveer 6572 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6573 
    result.write(oprot)
6574 
    oprot.writeMessageEnd()
6575 
    oprot.trans.flush()
6576 
 
4133 chandransh 6577 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6578 
    args = getOrdersInBatch_args()
6579 
    args.read(iprot)
6580 
    iprot.readMessageEnd()
6581 
    result = getOrdersInBatch_result()
6582 
    try:
6583 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6584 
    except TransactionServiceException, ex:
6585 
      result.ex = ex
6586 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6587 
    result.write(oprot)
6588 
    oprot.writeMessageEnd()
6589 
    oprot.trans.flush()
6590 
 
6591 
  def process_getOrderCount(self, seqid, iprot, oprot):
6592 
    args = getOrderCount_args()
6593 
    args.read(iprot)
6594 
    iprot.readMessageEnd()
6595 
    result = getOrderCount_result()
6596 
    try:
6597 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6598 
    except TransactionServiceException, ex:
6599 
      result.ex = ex
6600 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6601 
    result.write(oprot)
6602 
    oprot.writeMessageEnd()
6603 
    oprot.trans.flush()
6604 
 
999 varun.gupt 6605 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6606 
    args = getOrdersByBillingDate_args()
6607 
    args.read(iprot)
6608 
    iprot.readMessageEnd()
6609 
    result = getOrdersByBillingDate_result()
6610 
    try:
6611 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6612 
    except TransactionServiceException, ex:
6613 
      result.ex = ex
6614 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6615 
    result.write(oprot)
6616 
    oprot.writeMessageEnd()
6617 
    oprot.trans.flush()
6618 
 
3427 chandransh 6619 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6620 
    args = getOrdersByShippingDate_args()
6621 
    args.read(iprot)
6622 
    iprot.readMessageEnd()
6623 
    result = getOrdersByShippingDate_result()
6624 
    try:
3451 chandransh 6625 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6626 
    except TransactionServiceException, ex:
6627 
      result.ex = ex
6628 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6629 
    result.write(oprot)
6630 
    oprot.writeMessageEnd()
6631 
    oprot.trans.flush()
6632 
 
1382 varun.gupt 6633 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6634 
    args = getReturnableOrdersForCustomer_args()
6635 
    args.read(iprot)
6636 
    iprot.readMessageEnd()
6637 
    result = getReturnableOrdersForCustomer_result()
6638 
    try:
6639 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6640 
    except TransactionServiceException, ex:
6641 
      result.ex = ex
6642 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6643 
    result.write(oprot)
6644 
    oprot.writeMessageEnd()
6645 
    oprot.trans.flush()
6646 
 
6647 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6648 
    args = getCancellableOrdersForCustomer_args()
6649 
    args.read(iprot)
6650 
    iprot.readMessageEnd()
6651 
    result = getCancellableOrdersForCustomer_result()
6652 
    try:
6653 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6654 
    except TransactionServiceException, ex:
6655 
      result.ex = ex
6656 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6657 
    result.write(oprot)
6658 
    oprot.writeMessageEnd()
6659 
    oprot.trans.flush()
6660 
 
483 rajveer 6661 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6662 
    args = changeOrderStatus_args()
94 ashish 6663 
    args.read(iprot)
6664 
    iprot.readMessageEnd()
483 rajveer 6665 
    result = changeOrderStatus_result()
94 ashish 6666 
    try:
483 rajveer 6667 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6668 
    except TransactionServiceException, ex:
6669 
      result.ex = ex
483 rajveer 6670 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
483 rajveer 6675 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6676 
    args = getOrdersForTransaction_args()
94 ashish 6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
483 rajveer 6679 
    result = getOrdersForTransaction_result()
94 ashish 6680 
    try:
1528 ankur.sing 6681 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6682 
    except TransactionServiceException, ex:
6683 
      result.ex = ex
483 rajveer 6684 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6685 
    result.write(oprot)
6686 
    oprot.writeMessageEnd()
6687 
    oprot.trans.flush()
6688 
 
483 rajveer 6689 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6690 
    args = getOrdersForCustomer_args()
94 ashish 6691 
    args.read(iprot)
6692 
    iprot.readMessageEnd()
483 rajveer 6693 
    result = getOrdersForCustomer_result()
94 ashish 6694 
    try:
3014 chandransh 6695 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6696 
    except TransactionServiceException, ex:
6697 
      result.ex = ex
483 rajveer 6698 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6699 
    result.write(oprot)
6700 
    oprot.writeMessageEnd()
6701 
    oprot.trans.flush()
6702 
 
483 rajveer 6703 
  def process_createOrder(self, seqid, iprot, oprot):
6704 
    args = createOrder_args()
94 ashish 6705 
    args.read(iprot)
6706 
    iprot.readMessageEnd()
483 rajveer 6707 
    result = createOrder_result()
94 ashish 6708 
    try:
483 rajveer 6709 
      result.success = self._handler.createOrder(args.order)
94 ashish 6710 
    except TransactionServiceException, ex:
6711 
      result.ex = ex
483 rajveer 6712 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6713 
    result.write(oprot)
6714 
    oprot.writeMessageEnd()
6715 
    oprot.trans.flush()
6716 
 
483 rajveer 6717 
  def process_getOrder(self, seqid, iprot, oprot):
6718 
    args = getOrder_args()
94 ashish 6719 
    args.read(iprot)
6720 
    iprot.readMessageEnd()
483 rajveer 6721 
    result = getOrder_result()
94 ashish 6722 
    try:
483 rajveer 6723 
      result.success = self._handler.getOrder(args.id)
94 ashish 6724 
    except TransactionServiceException, ex:
6725 
      result.ex = ex
483 rajveer 6726 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6727 
    result.write(oprot)
6728 
    oprot.writeMessageEnd()
6729 
    oprot.trans.flush()
6730 
 
483 rajveer 6731 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6732 
    args = getLineItemsForOrder_args()
94 ashish 6733 
    args.read(iprot)
6734 
    iprot.readMessageEnd()
483 rajveer 6735 
    result = getLineItemsForOrder_result()
94 ashish 6736 
    try:
483 rajveer 6737 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6738 
    except TransactionServiceException, ex:
6739 
      result.ex = ex
483 rajveer 6740 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6741 
    result.write(oprot)
6742 
    oprot.writeMessageEnd()
6743 
    oprot.trans.flush()
6744 
 
4999 phani.kuma 6745 
  def process_getOrderList(self, seqid, iprot, oprot):
6746 
    args = getOrderList_args()
6747 
    args.read(iprot)
6748 
    iprot.readMessageEnd()
6749 
    result = getOrderList_result()
6750 
    result.success = self._handler.getOrderList(args.order_ids)
6751 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6752 
    result.write(oprot)
6753 
    oprot.writeMessageEnd()
6754 
    oprot.trans.flush()
6755 
 
5386 phani.kuma 6756 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6757 
    args = getOrderListForVendor_args()
6758 
    args.read(iprot)
6759 
    iprot.readMessageEnd()
6760 
    result = getOrderListForVendor_result()
6761 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6762 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6763 
    result.write(oprot)
6764 
    oprot.writeMessageEnd()
6765 
    oprot.trans.flush()
6766 
 
1528 ankur.sing 6767 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6768 
    args = getOrderForCustomer_args()
6769 
    args.read(iprot)
6770 
    iprot.readMessageEnd()
6771 
    result = getOrderForCustomer_result()
6772 
    try:
6773 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6774 
    except TransactionServiceException, ex:
6775 
      result.ex = ex
6776 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6777 
    result.write(oprot)
6778 
    oprot.writeMessageEnd()
6779 
    oprot.trans.flush()
6780 
 
3064 chandransh 6781 
  def process_getAlerts(self, seqid, iprot, oprot):
6782 
    args = getAlerts_args()
6783 
    args.read(iprot)
6784 
    iprot.readMessageEnd()
6785 
    result = getAlerts_result()
4444 rajveer 6786 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6787 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6788 
    result.write(oprot)
6789 
    oprot.writeMessageEnd()
6790 
    oprot.trans.flush()
6791 
 
4394 rajveer 6792 
  def process_addAlert(self, seqid, iprot, oprot):
6793 
    args = addAlert_args()
3064 chandransh 6794 
    args.read(iprot)
6795 
    iprot.readMessageEnd()
4394 rajveer 6796 
    result = addAlert_result()
4444 rajveer 6797 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6798 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6799 
    result.write(oprot)
6800 
    oprot.writeMessageEnd()
6801 
    oprot.trans.flush()
6802 
 
4444 rajveer 6803 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6804 
    args = markAlertsAsSeen_args()
6805 
    args.read(iprot)
6806 
    iprot.readMessageEnd()
6807 
    result = markAlertsAsSeen_result()
6808 
    self._handler.markAlertsAsSeen(args.warehouseId)
6809 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6810 
    result.write(oprot)
6811 
    oprot.writeMessageEnd()
6812 
    oprot.trans.flush()
6813 
 
3064 chandransh 6814 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6815 
    args = getValidOrderCount_args()
6816 
    args.read(iprot)
6817 
    iprot.readMessageEnd()
6818 
    result = getValidOrderCount_result()
6819 
    result.success = self._handler.getValidOrderCount()
6820 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6821 
    result.write(oprot)
6822 
    oprot.writeMessageEnd()
6823 
    oprot.trans.flush()
6824 
 
6825 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6826 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6827 
    args.read(iprot)
6828 
    iprot.readMessageEnd()
6829 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6830 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6831 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6832 
    result.write(oprot)
6833 
    oprot.writeMessageEnd()
6834 
    oprot.trans.flush()
6835 
 
6836 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6837 
    args = getValidOrdersAmountRange_args()
6838 
    args.read(iprot)
6839 
    iprot.readMessageEnd()
6840 
    result = getValidOrdersAmountRange_result()
6841 
    result.success = self._handler.getValidOrdersAmountRange()
6842 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6843 
    result.write(oprot)
6844 
    oprot.writeMessageEnd()
6845 
    oprot.trans.flush()
6846 
 
6847 
  def process_getValidOrders(self, seqid, iprot, oprot):
6848 
    args = getValidOrders_args()
6849 
    args.read(iprot)
6850 
    iprot.readMessageEnd()
6851 
    result = getValidOrders_result()
5874 rajveer 6852 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6853 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6854 
    result.write(oprot)
6855 
    oprot.writeMessageEnd()
6856 
    oprot.trans.flush()
6857 
 
1220 chandransh 6858 
  def process_batchOrders(self, seqid, iprot, oprot):
6859 
    args = batchOrders_args()
6860 
    args.read(iprot)
6861 
    iprot.readMessageEnd()
6862 
    result = batchOrders_result()
6863 
    try:
6864 
      result.success = self._handler.batchOrders(args.warehouseId)
6865 
    except TransactionServiceException, ex:
6866 
      result.ex = ex
6867 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6868 
    result.write(oprot)
6869 
    oprot.writeMessageEnd()
6870 
    oprot.trans.flush()
6871 
 
1208 chandransh 6872 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6873 
    args = markOrderAsOutOfStock_args()
6874 
    args.read(iprot)
6875 
    iprot.readMessageEnd()
6876 
    result = markOrderAsOutOfStock_result()
6877 
    try:
6878 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6879 
    except TransactionServiceException, ex:
6880 
      result.ex = ex
6881 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6882 
    result.write(oprot)
6883 
    oprot.writeMessageEnd()
6884 
    oprot.trans.flush()
6885 
 
3064 chandransh 6886 
  def process_verifyOrder(self, seqid, iprot, oprot):
6887 
    args = verifyOrder_args()
759 chandransh 6888 
    args.read(iprot)
6889 
    iprot.readMessageEnd()
3064 chandransh 6890 
    result = verifyOrder_result()
759 chandransh 6891 
    try:
3064 chandransh 6892 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6893 
    except TransactionServiceException, ex:
6894 
      result.ex = ex
3064 chandransh 6895 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6896 
    result.write(oprot)
6897 
    oprot.writeMessageEnd()
6898 
    oprot.trans.flush()
6899 
 
3064 chandransh 6900 
  def process_acceptOrder(self, seqid, iprot, oprot):
6901 
    args = acceptOrder_args()
1113 chandransh 6902 
    args.read(iprot)
6903 
    iprot.readMessageEnd()
3064 chandransh 6904 
    result = acceptOrder_result()
1113 chandransh 6905 
    try:
3064 chandransh 6906 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6907 
    except TransactionServiceException, ex:
6908 
      result.ex = ex
3064 chandransh 6909 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6910 
    result.write(oprot)
6911 
    oprot.writeMessageEnd()
6912 
    oprot.trans.flush()
6913 
 
3064 chandransh 6914 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6915 
    args = addBillingDetails_args()
1135 chandransh 6916 
    args.read(iprot)
6917 
    iprot.readMessageEnd()
3064 chandransh 6918 
    result = addBillingDetails_result()
1135 chandransh 6919 
    try:
5110 mandeep.dh 6920 
      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 6921 
    except TransactionServiceException, ex:
6922 
      result.ex = ex
3064 chandransh 6923 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6924 
    result.write(oprot)
6925 
    oprot.writeMessageEnd()
6926 
    oprot.trans.flush()
6927 
 
4579 rajveer 6928 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6929 
    args = addInvoiceNumber_args()
6930 
    args.read(iprot)
6931 
    iprot.readMessageEnd()
6932 
    result = addInvoiceNumber_result()
6933 
    try:
4763 rajveer 6934 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6935 
    except TransactionServiceException, ex:
6936 
      result.ex = ex
6937 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6938 
    result.write(oprot)
6939 
    oprot.writeMessageEnd()
6940 
    oprot.trans.flush()
6941 
 
4410 rajveer 6942 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6943 
    args = markOrdersAsShippedFromWarehouse_args()
6944 
    args.read(iprot)
6945 
    iprot.readMessageEnd()
6946 
    result = markOrdersAsShippedFromWarehouse_result()
6947 
    try:
4789 rajveer 6948 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6949 
    except TransactionServiceException, ex:
6950 
      result.ex = ex
6951 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6952 
    result.write(oprot)
6953 
    oprot.writeMessageEnd()
6954 
    oprot.trans.flush()
6955 
 
5676 rajveer 6956 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6957 
    args = markOrdersAsReturnedFromStore_args()
6958 
    args.read(iprot)
6959 
    iprot.readMessageEnd()
6960 
    result = markOrdersAsReturnedFromStore_result()
6961 
    try:
5713 rajveer 6962 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6963 
    except TransactionServiceException, ex:
6964 
      result.ex = ex
6965 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6966 
    result.write(oprot)
6967 
    oprot.writeMessageEnd()
6968 
    oprot.trans.flush()
6969 
 
3064 chandransh 6970 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6971 
    args = markOrdersAsPickedUp_args()
304 ashish 6972 
    args.read(iprot)
6973 
    iprot.readMessageEnd()
3064 chandransh 6974 
    result = markOrdersAsPickedUp_result()
6975 
    try:
4910 phani.kuma 6976 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6977 
    except TransactionServiceException, ex:
6978 
      result.ex = ex
6979 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6980 
    result.write(oprot)
6981 
    oprot.writeMessageEnd()
6982 
    oprot.trans.flush()
94 ashish 6983 
 
4910 phani.kuma 6984 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6985 
    args = getOrdersNotPickedUp_args()
6986 
    args.read(iprot)
6987 
    iprot.readMessageEnd()
6988 
    result = getOrdersNotPickedUp_result()
6989 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6990 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6991 
    result.write(oprot)
6992 
    oprot.writeMessageEnd()
6993 
    oprot.trans.flush()
6994 
 
3064 chandransh 6995 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6996 
    args = markOrdersAsDelivered_args()
304 ashish 6997 
    args.read(iprot)
6998 
    iprot.readMessageEnd()
3064 chandransh 6999 
    result = markOrdersAsDelivered_result()
7000 
    try:
7001 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7002 
    except TransactionServiceException, ex:
7003 
      result.ex = ex
7004 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7005 
    result.write(oprot)
7006 
    oprot.writeMessageEnd()
7007 
    oprot.trans.flush()
7008 
 
4910 phani.kuma 7009 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7010 
    args = markAsRTOrders_args()
1596 ankur.sing 7011 
    args.read(iprot)
7012 
    iprot.readMessageEnd()
4910 phani.kuma 7013 
    result = markAsRTOrders_result()
3064 chandransh 7014 
    try:
4910 phani.kuma 7015 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7016 
    except TransactionServiceException, ex:
7017 
      result.ex = ex
4910 phani.kuma 7018 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7019 
    result.write(oprot)
7020 
    oprot.writeMessageEnd()
7021 
    oprot.trans.flush()
304 ashish 7022 
 
4910 phani.kuma 7023 
  def process_getRTOrders(self, seqid, iprot, oprot):
7024 
    args = getRTOrders_args()
7025 
    args.read(iprot)
7026 
    iprot.readMessageEnd()
7027 
    result = getRTOrders_result()
7028 
    result.success = self._handler.getRTOrders(args.providerId)
7029 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7030 
    result.write(oprot)
7031 
    oprot.writeMessageEnd()
7032 
    oprot.trans.flush()
7033 
 
3064 chandransh 7034 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7035 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7036 
    args.read(iprot)
7037 
    iprot.readMessageEnd()
3064 chandransh 7038 
    result = updateNonDeliveryReason_result()
7039 
    try:
4910 phani.kuma 7040 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7041 
    except TransactionServiceException, ex:
7042 
      result.ex = ex
7043 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7044 
    result.write(oprot)
7045 
    oprot.writeMessageEnd()
7046 
    oprot.trans.flush()
1596 ankur.sing 7047 
 
4910 phani.kuma 7048 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7049 
    args = getNonDeliveredOrdersbyCourier_args()
7050 
    args.read(iprot)
7051 
    iprot.readMessageEnd()
7052 
    result = getNonDeliveredOrdersbyCourier_result()
7053 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7054 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7055 
    result.write(oprot)
7056 
    oprot.writeMessageEnd()
7057 
    oprot.trans.flush()
7058 
 
7059 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7060 
    args = markOrdersAsLocalConnected_args()
7061 
    args.read(iprot)
7062 
    iprot.readMessageEnd()
7063 
    result = markOrdersAsLocalConnected_result()
7064 
    try:
7065 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7066 
    except TransactionServiceException, ex:
7067 
      result.ex = ex
7068 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7069 
    result.write(oprot)
7070 
    oprot.writeMessageEnd()
7071 
    oprot.trans.flush()
7072 
 
7073 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7074 
    args = getOrdersNotLocalConnected_args()
7075 
    args.read(iprot)
7076 
    iprot.readMessageEnd()
7077 
    result = getOrdersNotLocalConnected_result()
7078 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7079 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7080 
    result.write(oprot)
7081 
    oprot.writeMessageEnd()
7082 
    oprot.trans.flush()
7083 
 
7084 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7085 
    args = markOrdersAsDestinationCityReached_args()
7086 
    args.read(iprot)
7087 
    iprot.readMessageEnd()
7088 
    result = markOrdersAsDestinationCityReached_result()
7089 
    try:
7090 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7091 
    except TransactionServiceException, ex:
7092 
      result.ex = ex
7093 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7094 
    result.write(oprot)
7095 
    oprot.writeMessageEnd()
7096 
    oprot.trans.flush()
7097 
 
7098 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7099 
    args = markOrdersAsFirstDeliveryAttempted_args()
7100 
    args.read(iprot)
7101 
    iprot.readMessageEnd()
7102 
    result = markOrdersAsFirstDeliveryAttempted_result()
7103 
    try:
7104 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7105 
    except TransactionServiceException, ex:
7106 
      result.ex = ex
7107 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7108 
    result.write(oprot)
7109 
    oprot.writeMessageEnd()
7110 
    oprot.trans.flush()
7111 
 
3064 chandransh 7112 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7113 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7114 
    args.read(iprot)
7115 
    iprot.readMessageEnd()
3064 chandransh 7116 
    result = getUndeliveredOrders_result()
7117 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7118 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7119 
    result.write(oprot)
7120 
    oprot.writeMessageEnd()
7121 
    oprot.trans.flush()
7122 
 
4783 phani.kuma 7123 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7124 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7125 
    args.read(iprot)
7126 
    iprot.readMessageEnd()
7127 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7128 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7129 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7130 
    result.write(oprot)
7131 
    oprot.writeMessageEnd()
7132 
    oprot.trans.flush()
7133 
 
2536 chandransh 7134 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7135 
    args = toggleDOAFlag_args()
7136 
    args.read(iprot)
7137 
    iprot.readMessageEnd()
7138 
    result = toggleDOAFlag_result()
7139 
    try:
7140 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7141 
    except TransactionServiceException, ex:
7142 
      result.ex = ex
7143 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7144 
    result.write(oprot)
7145 
    oprot.writeMessageEnd()
7146 
    oprot.trans.flush()
1886 ankur.sing 7147 
 
4712 rajveer 7148 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7149 
    args = markOrderAsDelivered_args()
7150 
    args.read(iprot)
7151 
    iprot.readMessageEnd()
7152 
    result = markOrderAsDelivered_result()
7153 
    try:
7154 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7155 
    except TransactionServiceException, ex:
7156 
      result.ex = ex
7157 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7158 
    result.write(oprot)
7159 
    oprot.writeMessageEnd()
7160 
    oprot.trans.flush()
7161 
 
5553 rajveer 7162 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7163 
    args = markOrderAsReceivedAtStore_args()
7164 
    args.read(iprot)
7165 
    iprot.readMessageEnd()
7166 
    result = markOrderAsReceivedAtStore_result()
7167 
    try:
7168 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7169 
    except TransactionServiceException, ex:
7170 
      result.ex = ex
7171 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7172 
    result.write(oprot)
7173 
    oprot.writeMessageEnd()
7174 
    oprot.trans.flush()
7175 
 
4454 rajveer 7176 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7177 
    args = markOrderDoaRequestReceived_args()
7178 
    args.read(iprot)
7179 
    iprot.readMessageEnd()
7180 
    result = markOrderDoaRequestReceived_result()
7181 
    try:
7182 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7183 
    except TransactionServiceException, ex:
7184 
      result.ex = ex
7185 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7186 
    result.write(oprot)
7187 
    oprot.writeMessageEnd()
7188 
    oprot.trans.flush()
7189 
 
7190 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7191 
    args = markOrderDoaRequestAuthorized_args()
7192 
    args.read(iprot)
7193 
    iprot.readMessageEnd()
7194 
    result = markOrderDoaRequestAuthorized_result()
7195 
    try:
7196 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7197 
    except TransactionServiceException, ex:
7198 
      result.ex = ex
7199 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7200 
    result.write(oprot)
7201 
    oprot.writeMessageEnd()
7202 
    oprot.trans.flush()
7203 
 
4488 rajveer 7204 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7205 
    args = markOrderReturnRequestReceived_args()
7206 
    args.read(iprot)
7207 
    iprot.readMessageEnd()
7208 
    result = markOrderReturnRequestReceived_result()
7209 
    try:
7210 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7211 
    except TransactionServiceException, ex:
7212 
      result.ex = ex
7213 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7214 
    result.write(oprot)
7215 
    oprot.writeMessageEnd()
7216 
    oprot.trans.flush()
7217 
 
7218 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7219 
    args = markOrderReturnRequestAuthorized_args()
7220 
    args.read(iprot)
7221 
    iprot.readMessageEnd()
7222 
    result = markOrderReturnRequestAuthorized_result()
7223 
    try:
7224 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7225 
    except TransactionServiceException, ex:
7226 
      result.ex = ex
7227 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7228 
    result.write(oprot)
7229 
    oprot.writeMessageEnd()
7230 
    oprot.trans.flush()
7231 
 
2536 chandransh 7232 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7233 
    args = requestPickupNumber_args()
7234 
    args.read(iprot)
7235 
    iprot.readMessageEnd()
7236 
    result = requestPickupNumber_result()
7237 
    try:
4579 rajveer 7238 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7239 
    except TransactionServiceException, ex:
7240 
      result.ex = ex
7241 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7242 
    result.write(oprot)
7243 
    oprot.writeMessageEnd()
7244 
    oprot.trans.flush()
7245 
 
7246 
  def process_authorizePickup(self, seqid, iprot, oprot):
7247 
    args = authorizePickup_args()
7248 
    args.read(iprot)
7249 
    iprot.readMessageEnd()
7250 
    result = authorizePickup_result()
7251 
    try:
4602 rajveer 7252 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7253 
    except TransactionServiceException, ex:
7254 
      result.ex = ex
7255 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7256 
    result.write(oprot)
7257 
    oprot.writeMessageEnd()
7258 
    oprot.trans.flush()
7259 
 
2764 chandransh 7260 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7261 
    args = markDoasAsPickedUp_args()
7262 
    args.read(iprot)
7263 
    iprot.readMessageEnd()
7264 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7265 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7266 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7267 
    result.write(oprot)
7268 
    oprot.writeMessageEnd()
7269 
    oprot.trans.flush()
7270 
 
4910 phani.kuma 7271 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7272 
    args = getDoasNotPickedUp_args()
7273 
    args.read(iprot)
7274 
    iprot.readMessageEnd()
7275 
    result = getDoasNotPickedUp_result()
7276 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7277 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7278 
    result.write(oprot)
7279 
    oprot.writeMessageEnd()
7280 
    oprot.trans.flush()
7281 
 
4741 phani.kuma 7282 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7283 
    args = markReturnOrdersAsPickedUp_args()
7284 
    args.read(iprot)
7285 
    iprot.readMessageEnd()
7286 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7287 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7288 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7289 
    result.write(oprot)
7290 
    oprot.writeMessageEnd()
7291 
    oprot.trans.flush()
7292 
 
4910 phani.kuma 7293 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7294 
    args = getReturnOrdersNotPickedUp_args()
7295 
    args.read(iprot)
7296 
    iprot.readMessageEnd()
7297 
    result = getReturnOrdersNotPickedUp_result()
7298 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7299 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
2616 chandransh 7304 
  def process_receiveReturn(self, seqid, iprot, oprot):
7305 
    args = receiveReturn_args()
2591 chandransh 7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
2616 chandransh 7308 
    result = receiveReturn_result()
2591 chandransh 7309 
    try:
4479 rajveer 7310 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7311 
    except TransactionServiceException, ex:
7312 
      result.ex = ex
2616 chandransh 7313 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
2536 chandransh 7317 
 
2591 chandransh 7318 
  def process_validateDoa(self, seqid, iprot, oprot):
7319 
    args = validateDoa_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = validateDoa_result()
7323 
    try:
7324 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7325 
    except TransactionServiceException, ex:
7326 
      result.ex = ex
7327 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7328 
    result.write(oprot)
7329 
    oprot.writeMessageEnd()
7330 
    oprot.trans.flush()
7331 
 
4495 rajveer 7332 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7333 
    args = validateReturnProduct_args()
7334 
    args.read(iprot)
7335 
    iprot.readMessageEnd()
7336 
    result = validateReturnProduct_result()
7337 
    try:
7338 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7339 
    except TransactionServiceException, ex:
7340 
      result.ex = ex
7341 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7342 
    result.write(oprot)
7343 
    oprot.writeMessageEnd()
7344 
    oprot.trans.flush()
7345 
 
2616 chandransh 7346 
  def process_reshipOrder(self, seqid, iprot, oprot):
7347 
    args = reshipOrder_args()
7348 
    args.read(iprot)
7349 
    iprot.readMessageEnd()
7350 
    result = reshipOrder_result()
7351 
    try:
7352 
      result.success = self._handler.reshipOrder(args.orderId)
7353 
    except TransactionServiceException, ex:
7354 
      result.ex = ex
7355 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7356 
    result.write(oprot)
7357 
    oprot.writeMessageEnd()
7358 
    oprot.trans.flush()
2591 chandransh 7359 
 
2616 chandransh 7360 
  def process_refundOrder(self, seqid, iprot, oprot):
7361 
    args = refundOrder_args()
7362 
    args.read(iprot)
7363 
    iprot.readMessageEnd()
7364 
    result = refundOrder_result()
7365 
    try:
3226 chandransh 7366 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7367 
    except TransactionServiceException, ex:
7368 
      result.ex = ex
7369 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7370 
    result.write(oprot)
7371 
    oprot.writeMessageEnd()
7372 
    oprot.trans.flush()
7373 
 
2690 chandransh 7374 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7375 
    args = getReturnOrders_args()
7376 
    args.read(iprot)
7377 
    iprot.readMessageEnd()
7378 
    result = getReturnOrders_result()
7379 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7380 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7381 
    result.write(oprot)
7382 
    oprot.writeMessageEnd()
7383 
    oprot.trans.flush()
2616 chandransh 7384 
 
5481 phani.kuma 7385 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7386 
    args = getAllReturnOrders_args()
7387 
    args.read(iprot)
7388 
    iprot.readMessageEnd()
7389 
    result = getAllReturnOrders_result()
7390 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7391 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7392 
    result.write(oprot)
7393 
    oprot.writeMessageEnd()
7394 
    oprot.trans.flush()
7395 
 
2700 chandransh 7396 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7397 
    args = getReturnOrder_args()
7398 
    args.read(iprot)
7399 
    iprot.readMessageEnd()
7400 
    result = getReturnOrder_result()
7401 
    try:
7402 
      result.success = self._handler.getReturnOrder(args.id)
7403 
    except TransactionServiceException, ex:
7404 
      result.ex = ex
7405 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7406 
    result.write(oprot)
7407 
    oprot.writeMessageEnd()
7408 
    oprot.trans.flush()
7409 
 
2690 chandransh 7410 
  def process_processReturn(self, seqid, iprot, oprot):
7411 
    args = processReturn_args()
7412 
    args.read(iprot)
7413 
    iprot.readMessageEnd()
7414 
    result = processReturn_result()
7415 
    try:
7416 
      self._handler.processReturn(args.returnOrderId)
7417 
    except TransactionServiceException, ex:
7418 
      result.ex = ex
7419 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7420 
    result.write(oprot)
7421 
    oprot.writeMessageEnd()
7422 
    oprot.trans.flush()
7423 
 
3451 chandransh 7424 
  def process_updateWeight(self, seqid, iprot, oprot):
7425 
    args = updateWeight_args()
7426 
    args.read(iprot)
7427 
    iprot.readMessageEnd()
7428 
    result = updateWeight_result()
7429 
    try:
7430 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7431 
    except TransactionServiceException, ex:
7432 
      result.ex = ex
7433 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7434 
    result.write(oprot)
7435 
    oprot.writeMessageEnd()
7436 
    oprot.trans.flush()
2819 chandransh 7437 
 
3469 chandransh 7438 
  def process_changeItem(self, seqid, iprot, oprot):
7439 
    args = changeItem_args()
7440 
    args.read(iprot)
7441 
    iprot.readMessageEnd()
7442 
    result = changeItem_result()
7443 
    try:
7444 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7445 
    except TransactionServiceException, ex:
7446 
      result.ex = ex
7447 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7448 
    result.write(oprot)
7449 
    oprot.writeMessageEnd()
7450 
    oprot.trans.flush()
3451 chandransh 7451 
 
3469 chandransh 7452 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7453 
    args = shiftToWarehouse_args()
7454 
    args.read(iprot)
7455 
    iprot.readMessageEnd()
7456 
    result = shiftToWarehouse_result()
7457 
    try:
7458 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7459 
    except TransactionServiceException, ex:
7460 
      result.ex = ex
7461 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7462 
    result.write(oprot)
7463 
    oprot.writeMessageEnd()
7464 
    oprot.trans.flush()
7465 
 
3553 chandransh 7466 
  def process_addDelayReason(self, seqid, iprot, oprot):
7467 
    args = addDelayReason_args()
7468 
    args.read(iprot)
7469 
    iprot.readMessageEnd()
7470 
    result = addDelayReason_result()
7471 
    try:
4647 rajveer 7472 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7473 
    except TransactionServiceException, ex:
7474 
      result.ex = ex
7475 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7476 
    result.write(oprot)
7477 
    oprot.writeMessageEnd()
7478 
    oprot.trans.flush()
3469 chandransh 7479 
 
3956 chandransh 7480 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7481 
    args = reconcileCodCollection_args()
7482 
    args.read(iprot)
7483 
    iprot.readMessageEnd()
7484 
    result = reconcileCodCollection_result()
7485 
    try:
7486 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7487 
    except TransactionServiceException, ex:
7488 
      result.ex = ex
7489 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7490 
    result.write(oprot)
7491 
    oprot.writeMessageEnd()
7492 
    oprot.trans.flush()
3553 chandransh 7493 
 
4008 mandeep.dh 7494 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7495 
    args = getTransactionsRequiringExtraProcessing_args()
7496 
    args.read(iprot)
7497 
    iprot.readMessageEnd()
7498 
    result = getTransactionsRequiringExtraProcessing_result()
7499 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7500 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7501 
    result.write(oprot)
7502 
    oprot.writeMessageEnd()
7503 
    oprot.trans.flush()
3956 chandransh 7504 
 
4008 mandeep.dh 7505 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7506 
    args = markTransactionAsProcessed_args()
7507 
    args.read(iprot)
7508 
    iprot.readMessageEnd()
7509 
    result = markTransactionAsProcessed_result()
7510 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7511 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7512 
    result.write(oprot)
7513 
    oprot.writeMessageEnd()
7514 
    oprot.trans.flush()
7515 
 
4018 chandransh 7516 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7517 
    args = getItemWiseRiskyOrdersCount_args()
7518 
    args.read(iprot)
7519 
    iprot.readMessageEnd()
7520 
    result = getItemWiseRiskyOrdersCount_result()
7521 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7522 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7523 
    result.write(oprot)
7524 
    oprot.writeMessageEnd()
7525 
    oprot.trans.flush()
4008 mandeep.dh 7526 
 
4295 varun.gupt 7527 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7528 
    args = getOrdersForItemIds_args()
7529 
    args.read(iprot)
7530 
    iprot.readMessageEnd()
7531 
    result = getOrdersForItemIds_result()
7532 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7533 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
7537 
 
4247 rajveer 7538 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7539 
    args = markOrderCancellationRequestReceived_args()
7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
7542 
    result = markOrderCancellationRequestReceived_result()
7543 
    try:
7544 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7545 
    except TransactionServiceException, ex:
7546 
      result.ex = ex
7547 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7548 
    result.write(oprot)
7549 
    oprot.writeMessageEnd()
7550 
    oprot.trans.flush()
4018 chandransh 7551 
 
4247 rajveer 7552 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7553 
    args = markOrderCancellationRequestConfirmed_args()
7554 
    args.read(iprot)
7555 
    iprot.readMessageEnd()
7556 
    result = markOrderCancellationRequestConfirmed_result()
7557 
    try:
7558 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7559 
    except TransactionServiceException, ex:
7560 
      result.ex = ex
7561 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
7565 
 
7566 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7567 
    args = markOrderCancellationRequestDenied_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = markOrderCancellationRequestDenied_result()
7571 
    try:
7572 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7573 
    except TransactionServiceException, ex:
7574 
      result.ex = ex
7575 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
4258 rajveer 7580 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7581 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
4258 rajveer 7584 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7585 
    try:
4258 rajveer 7586 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7587 
    except TransactionServiceException, ex:
7588 
      result.ex = ex
4258 rajveer 7589 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7590 
    result.write(oprot)
7591 
    oprot.writeMessageEnd()
7592 
    oprot.trans.flush()
7593 
 
4259 anupam.sin 7594 
  def process_refundTransaction(self, seqid, iprot, oprot):
7595 
    args = refundTransaction_args()
7596 
    args.read(iprot)
7597 
    iprot.readMessageEnd()
7598 
    result = refundTransaction_result()
7599 
    try:
7600 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7601 
    except TransactionServiceException, ex:
7602 
      result.ex = ex
7603 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7604 
    result.write(oprot)
7605 
    oprot.writeMessageEnd()
7606 
    oprot.trans.flush()
4247 rajveer 7607 
 
4324 mandeep.dh 7608 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7609 
    args = updateShipmentAddress_args()
7610 
    args.read(iprot)
7611 
    iprot.readMessageEnd()
7612 
    result = updateShipmentAddress_result()
7613 
    try:
7614 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7615 
    except TransactionServiceException, ex:
7616 
      result.ex = ex
7617 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7618 
    result.write(oprot)
7619 
    oprot.writeMessageEnd()
7620 
    oprot.trans.flush()
7621 
 
4285 rajveer 7622 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7623 
    args = acceptOrdersForItemId_args()
7624 
    args.read(iprot)
7625 
    iprot.readMessageEnd()
7626 
    result = acceptOrdersForItemId_result()
7627 
    try:
7628 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7629 
    except TransactionServiceException, ex:
7630 
      result.ex = ex
7631 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7632 
    result.write(oprot)
7633 
    oprot.writeMessageEnd()
7634 
    oprot.trans.flush()
4259 anupam.sin 7635 
 
4303 rajveer 7636 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7637 
    args = markOrdersAsPORaised_args()
7638 
    args.read(iprot)
7639 
    iprot.readMessageEnd()
7640 
    result = markOrdersAsPORaised_result()
7641 
    try:
4369 rajveer 7642 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7643 
    except TransactionServiceException, ex:
7644 
      result.ex = ex
7645 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7646 
    result.write(oprot)
7647 
    oprot.writeMessageEnd()
7648 
    oprot.trans.flush()
4285 rajveer 7649 
 
4303 rajveer 7650 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7651 
    args = markOrdersAsReversalInitiated_args()
7652 
    args.read(iprot)
7653 
    iprot.readMessageEnd()
7654 
    result = markOrdersAsReversalInitiated_result()
7655 
    try:
4369 rajveer 7656 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7657 
    except TransactionServiceException, ex:
7658 
      result.ex = ex
7659 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7660 
    result.write(oprot)
7661 
    oprot.writeMessageEnd()
7662 
    oprot.trans.flush()
7663 
 
7664 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7665 
    args = markOrdersAsNotAvailabke_args()
7666 
    args.read(iprot)
7667 
    iprot.readMessageEnd()
7668 
    result = markOrdersAsNotAvailabke_result()
7669 
    try:
4369 rajveer 7670 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7671 
    except TransactionServiceException, ex:
7672 
      result.ex = ex
7673 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7674 
    result.write(oprot)
7675 
    oprot.writeMessageEnd()
7676 
    oprot.trans.flush()
7677 
 
4369 rajveer 7678 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7679 
    args = markOrdersAsTimeout_args()
7680 
    args.read(iprot)
7681 
    iprot.readMessageEnd()
7682 
    result = markOrdersAsTimeout_result()
7683 
    try:
7684 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7685 
    except TransactionServiceException, ex:
7686 
      result.ex = ex
7687 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7688 
    result.write(oprot)
7689 
    oprot.writeMessageEnd()
7690 
    oprot.trans.flush()
4303 rajveer 7691 
 
4662 rajveer 7692 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7693 
    args = markOrderAsLostInTransit_args()
7694 
    args.read(iprot)
7695 
    iprot.readMessageEnd()
7696 
    result = markOrderAsLostInTransit_result()
7697 
    try:
7698 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7699 
    except TransactionServiceException, ex:
7700 
      result.ex = ex
7701 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7702 
    result.write(oprot)
7703 
    oprot.writeMessageEnd()
7704 
    oprot.trans.flush()
7705 
 
4386 anupam.sin 7706 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7707 
    args = getOrderForAwb_args()
7708 
    args.read(iprot)
7709 
    iprot.readMessageEnd()
7710 
    result = getOrderForAwb_result()
7711 
    try:
7712 
      result.success = self._handler.getOrderForAwb(args.awb)
7713 
    except TransactionServiceException, ex:
7714 
      result.ex = ex
7715 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7716 
    result.write(oprot)
7717 
    oprot.writeMessageEnd()
7718 
    oprot.trans.flush()
4369 rajveer 7719 
 
4506 phani.kuma 7720 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7721 
    args = getOrdersForProviderForStatus_args()
7722 
    args.read(iprot)
7723 
    iprot.readMessageEnd()
7724 
    result = getOrdersForProviderForStatus_result()
7725 
    try:
4910 phani.kuma 7726 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7727 
    except TransactionServiceException, ex:
7728 
      result.ex = ex
7729 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7730 
    result.write(oprot)
7731 
    oprot.writeMessageEnd()
7732 
    oprot.trans.flush()
4386 anupam.sin 7733 
 
4600 varun.gupt 7734 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7735 
    args = getBilledOrdersForVendor_args()
7736 
    args.read(iprot)
7737 
    iprot.readMessageEnd()
7738 
    result = getBilledOrdersForVendor_result()
7739 
    try:
7740 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7741 
    except TransactionServiceException, ex:
7742 
      result.ex = ex
7743 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7744 
    result.write(oprot)
7745 
    oprot.writeMessageEnd()
7746 
    oprot.trans.flush()
4506 phani.kuma 7747 
 
4607 rajveer 7748 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7749 
    args = getSlippedSippingDateOrders_args()
7750 
    args.read(iprot)
7751 
    iprot.readMessageEnd()
7752 
    result = getSlippedSippingDateOrders_result()
7753 
    try:
7754 
      result.success = self._handler.getSlippedSippingDateOrders()
7755 
    except TransactionServiceException, ex:
7756 
      result.ex = ex
7757 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7758 
    result.write(oprot)
7759 
    oprot.writeMessageEnd()
7760 
    oprot.trans.flush()
7761 
 
4709 rajveer 7762 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7763 
    args = getCancelledOrders_args()
7764 
    args.read(iprot)
7765 
    iprot.readMessageEnd()
7766 
    result = getCancelledOrders_result()
7767 
    try:
7768 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7769 
    except TransactionServiceException, ex:
7770 
      result.ex = ex
7771 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7772 
    result.write(oprot)
7773 
    oprot.writeMessageEnd()
7774 
    oprot.trans.flush()
7775 
 
4600 varun.gupt 7776 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7777 
    args = saveBluedartSettlements_args()
7778 
    args.read(iprot)
7779 
    iprot.readMessageEnd()
7780 
    result = saveBluedartSettlements_result()
7781 
    try:
7782 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7783 
    except TransactionServiceException, ex:
7784 
      result.ex = ex
7785 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7786 
    result.write(oprot)
7787 
    oprot.writeMessageEnd()
7788 
    oprot.trans.flush()
7789 
 
7790 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7791 
    args = savePaymentSettlements_args()
7792 
    args.read(iprot)
7793 
    iprot.readMessageEnd()
7794 
    result = savePaymentSettlements_result()
7795 
    try:
4905 varun.gupt 7796 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7797 
    except TransactionServiceException, ex:
7798 
      result.ex = ex
7799 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
7803 
 
7804 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7805 
    args = saveEBSSettlementSummary_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = saveEBSSettlementSummary_result()
7809 
    try:
7810 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7811 
    except TransactionServiceException, ex:
7812 
      result.ex = ex
7813 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7814 
    result.write(oprot)
7815 
    oprot.writeMessageEnd()
7816 
    oprot.trans.flush()
7817 
 
5386 phani.kuma 7818 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7819 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7820 
    args.read(iprot)
7821 
    iprot.readMessageEnd()
5386 phani.kuma 7822 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7823 
    try:
5386 phani.kuma 7824 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7825 
    except TransactionServiceException, ex:
7826 
      result.ex = ex
5386 phani.kuma 7827 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7828 
    result.write(oprot)
7829 
    oprot.writeMessageEnd()
7830 
    oprot.trans.flush()
7831 
 
5386 phani.kuma 7832 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7833 
    args = getSettlementForCod_args()
7834 
    args.read(iprot)
7835 
    iprot.readMessageEnd()
7836 
    result = getSettlementForCod_result()
7837 
    try:
7838 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7839 
    except TransactionServiceException, ex:
7840 
      result.ex = ex
7841 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7842 
    result.write(oprot)
7843 
    oprot.writeMessageEnd()
7844 
    oprot.trans.flush()
7845 
 
4600 varun.gupt 7846 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7847 
    args = getEBSSettlementSummaries_args()
7848 
    args.read(iprot)
7849 
    iprot.readMessageEnd()
7850 
    result = getEBSSettlementSummaries_result()
7851 
    try:
7852 
      result.success = self._handler.getEBSSettlementSummaries()
7853 
    except TransactionServiceException, ex:
7854 
      result.ex = ex
7855 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7856 
    result.write(oprot)
7857 
    oprot.writeMessageEnd()
7858 
    oprot.trans.flush()
7859 
 
7860 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7861 
    args = markEBSSettlementUploaded_args()
7862 
    args.read(iprot)
7863 
    iprot.readMessageEnd()
7864 
    result = markEBSSettlementUploaded_result()
7865 
    try:
7866 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7867 
    except TransactionServiceException, ex:
7868 
      result.ex = ex
7869 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7870 
    result.write(oprot)
7871 
    oprot.writeMessageEnd()
7872 
    oprot.trans.flush()
7873 
 
7874 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7875 
    args = getEBSSettlementDate_args()
7876 
    args.read(iprot)
7877 
    iprot.readMessageEnd()
7878 
    result = getEBSSettlementDate_result()
7879 
    try:
7880 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7881 
    except TransactionServiceException, ex:
7882 
      result.ex = ex
7883 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7884 
    result.write(oprot)
7885 
    oprot.writeMessageEnd()
7886 
    oprot.trans.flush()
7887 
 
4715 varun.gupt 7888 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7889 
    args = getSettlementsByDate_args()
7890 
    args.read(iprot)
7891 
    iprot.readMessageEnd()
7892 
    result = getSettlementsByDate_result()
7893 
    try:
7894 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7895 
    except TransactionServiceException, ex:
7896 
      result.ex = ex
7897 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7898 
    result.write(oprot)
7899 
    oprot.writeMessageEnd()
7900 
    oprot.trans.flush()
4600 varun.gupt 7901 
 
4715 varun.gupt 7902 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7903 
    args = getReshippedOrderIds_args()
7904 
    args.read(iprot)
7905 
    iprot.readMessageEnd()
7906 
    result = getReshippedOrderIds_result()
7907 
    try:
7908 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7909 
    except TransactionServiceException, ex:
7910 
      result.ex = ex
7911 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7912 
    result.write(oprot)
7913 
    oprot.writeMessageEnd()
7914 
    oprot.trans.flush()
7915 
 
5481 phani.kuma 7916 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7917 
    args = getBilledOrders_args()
4875 varun.gupt 7918 
    args.read(iprot)
7919 
    iprot.readMessageEnd()
5481 phani.kuma 7920 
    result = getBilledOrders_result()
4875 varun.gupt 7921 
    try:
5481 phani.kuma 7922 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7923 
    except TransactionServiceException, ex:
7924 
      result.ex = ex
5481 phani.kuma 7925 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7926 
    result.write(oprot)
7927 
    oprot.writeMessageEnd()
7928 
    oprot.trans.flush()
4757 mandeep.dh 7929 
 
5031 varun.gupt 7930 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7931 
    args = getStatusDistributionOfOrders_args()
7932 
    args.read(iprot)
7933 
    iprot.readMessageEnd()
7934 
    result = getStatusDistributionOfOrders_result()
7935 
    try:
7936 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7937 
    except TransactionServiceException, ex:
7938 
      result.ex = ex
7939 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7940 
    result.write(oprot)
7941 
    oprot.writeMessageEnd()
7942 
    oprot.trans.flush()
4875 varun.gupt 7943 
 
5067 varun.gupt 7944 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7945 
    args = getOrderIdsForStatus_args()
7946 
    args.read(iprot)
7947 
    iprot.readMessageEnd()
7948 
    result = getOrderIdsForStatus_result()
7949 
    try:
7950 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7951 
    except TransactionServiceException, ex:
7952 
      result.ex = ex
7953 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7954 
    result.write(oprot)
7955 
    oprot.writeMessageEnd()
7956 
    oprot.trans.flush()
5031 varun.gupt 7957 
 
5348 anupam.sin 7958 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7959 
    args = updateCODAgent_args()
7960 
    args.read(iprot)
7961 
    iprot.readMessageEnd()
7962 
    result = updateCODAgent_result()
7963 
    try:
7964 
      self._handler.updateCODAgent(args.agent, args.orderId)
7965 
    except TransactionServiceException, ex:
7966 
      result.ex = ex
7967 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7968 
    result.write(oprot)
7969 
    oprot.writeMessageEnd()
7970 
    oprot.trans.flush()
7971 
 
5099 varun.gupt 7972 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7973 
    args = updateOrderAsPaidToVendor_args()
7974 
    args.read(iprot)
7975 
    iprot.readMessageEnd()
7976 
    result = updateOrderAsPaidToVendor_result()
7977 
    try:
7978 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7979 
    except TransactionServiceException, ex:
7980 
      result.ex = ex
7981 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7982 
    result.write(oprot)
7983 
    oprot.writeMessageEnd()
7984 
    oprot.trans.flush()
5067 varun.gupt 7985 
 
5386 phani.kuma 7986 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7987 
    args = updateOrderOnlyAsPaidToVendor_args()
7988 
    args.read(iprot)
7989 
    iprot.readMessageEnd()
7990 
    result = updateOrderOnlyAsPaidToVendor_result()
7991 
    try:
7992 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7993 
    except TransactionServiceException, ex:
7994 
      result.ex = ex
7995 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7996 
    result.write(oprot)
7997 
    oprot.writeMessageEnd()
7998 
    oprot.trans.flush()
7999 
 
5208 varun.gupt 8000 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8001 
    args = getRefundedOrdersMarkedPaid_args()
8002 
    args.read(iprot)
8003 
    iprot.readMessageEnd()
8004 
    result = getRefundedOrdersMarkedPaid_result()
8005 
    try:
8006 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8007 
    except TransactionServiceException, ex:
8008 
      result.ex = ex
8009 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8010 
    result.write(oprot)
8011 
    oprot.writeMessageEnd()
8012 
    oprot.trans.flush()
5099 varun.gupt 8013 
 
5447 anupam.sin 8014 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8015 
    args = getAllVerificationAgents_args()
8016 
    args.read(iprot)
8017 
    iprot.readMessageEnd()
8018 
    result = getAllVerificationAgents_result()
8019 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8020 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8021 
    result.write(oprot)
8022 
    oprot.writeMessageEnd()
8023 
    oprot.trans.flush()
5208 varun.gupt 8024 
 
5527 anupam.sin 8025 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8026 
    args = getAllAttributesForOrderId_args()
8027 
    args.read(iprot)
8028 
    iprot.readMessageEnd()
8029 
    result = getAllAttributesForOrderId_result()
8030 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8031 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8032 
    result.write(oprot)
8033 
    oprot.writeMessageEnd()
8034 
    oprot.trans.flush()
5447 anupam.sin 8035 
 
5676 rajveer 8036 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8037 
    args = setOrderAttributes_args()
8038 
    args.read(iprot)
8039 
    iprot.readMessageEnd()
8040 
    result = setOrderAttributes_result()
8041 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8042 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8043 
    result.write(oprot)
8044 
    oprot.writeMessageEnd()
8045 
    oprot.trans.flush()
8046 
 
5527 anupam.sin 8047 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8048 
    args = setOrderAttributeForTransaction_args()
8049 
    args.read(iprot)
8050 
    iprot.readMessageEnd()
8051 
    result = setOrderAttributeForTransaction_result()
8052 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8053 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8054 
    result.write(oprot)
8055 
    oprot.writeMessageEnd()
8056 
    oprot.trans.flush()
8057 
 
5553 rajveer 8058 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8059 
    args = getReceivePendingOrders_args()
8060 
    args.read(iprot)
8061 
    iprot.readMessageEnd()
8062 
    result = getReceivePendingOrders_result()
8063 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8064 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8065 
    result.write(oprot)
8066 
    oprot.writeMessageEnd()
8067 
    oprot.trans.flush()
5527 anupam.sin 8068 
 
5553 rajveer 8069 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8070 
    args = getReceivedAtStoreOrders_args()
8071 
    args.read(iprot)
8072 
    iprot.readMessageEnd()
8073 
    result = getReceivedAtStoreOrders_result()
8074 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8075 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8076 
    result.write(oprot)
8077 
    oprot.writeMessageEnd()
8078 
    oprot.trans.flush()
8079 
 
5713 rajveer 8080 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8081 
    args = getOrdersCollectionAtStore_args()
8082 
    args.read(iprot)
8083 
    iprot.readMessageEnd()
8084 
    result = getOrdersCollectionAtStore_result()
8085 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8086 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8087 
    result.write(oprot)
8088 
    oprot.writeMessageEnd()
8089 
    oprot.trans.flush()
8090 
 
5833 rajveer 8091 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8092 
    args = getOrderAttributeValue_args()
8093 
    args.read(iprot)
8094 
    iprot.readMessageEnd()
8095 
    result = getOrderAttributeValue_result()
8096 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8097 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8098 
    result.write(oprot)
8099 
    oprot.writeMessageEnd()
8100 
    oprot.trans.flush()
8101 
 
6019 rajveer 8102 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8103 
    args = changeJacketNumber_args()
8104 
    args.read(iprot)
8105 
    iprot.readMessageEnd()
8106 
    result = changeJacketNumber_result()
8107 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8108 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8109 
    result.write(oprot)
8110 
    oprot.writeMessageEnd()
8111 
    oprot.trans.flush()
8112 
 
8113 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8114 
    args = markOrderAsRtoInTransit_args()
8115 
    args.read(iprot)
8116 
    iprot.readMessageEnd()
8117 
    result = markOrderAsRtoInTransit_result()
8118 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8119 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8120 
    result.write(oprot)
8121 
    oprot.writeMessageEnd()
8122 
    oprot.trans.flush()
8123 
 
5593 mandeep.dh 8124 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8125 
    args = acceptOrderForItem_args()
8126 
    args.read(iprot)
8127 
    iprot.readMessageEnd()
8128 
    result = acceptOrderForItem_result()
8129 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8130 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8131 
    result.write(oprot)
8132 
    oprot.writeMessageEnd()
8133 
    oprot.trans.flush()
5553 rajveer 8134 
 
6000 mandeep.dh 8135 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8136 
    args = createRechargeOrder_args()
8137 
    args.read(iprot)
8138 
    iprot.readMessageEnd()
8139 
    result = createRechargeOrder_result()
8140 
    try:
8141 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8142 
    except TransactionServiceException, ex:
8143 
      result.ex = ex
8144 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
5593 mandeep.dh 8148 
 
6031 rajveer 8149 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8150 
    args = getRechargeOrder_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = getRechargeOrder_result()
8154 
    try:
8155 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8156 
    except TransactionServiceException, ex:
8157 
      result.ex = ex
8158 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
8163 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8164 
    args = getRechargeOrders_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = getRechargeOrders_result()
8168 
    result.success = self._handler.getRechargeOrders(args.userId)
8169 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8170 
    result.write(oprot)
8171 
    oprot.writeMessageEnd()
8172 
    oprot.trans.flush()
8173 
 
6000 mandeep.dh 8174 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8175 
    args = updateRechargeOrderStatus_args()
8176 
    args.read(iprot)
8177 
    iprot.readMessageEnd()
8178 
    result = updateRechargeOrderStatus_result()
8179 
    try:
6031 rajveer 8180 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8181 
    except TransactionServiceException, ex:
8182 
      result.ex = ex
8183 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8184 
    result.write(oprot)
8185 
    oprot.writeMessageEnd()
8186 
    oprot.trans.flush()
8187 
 
8188 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8189 
    args = activateRechargeTxn_args()
8190 
    args.read(iprot)
8191 
    iprot.readMessageEnd()
8192 
    result = activateRechargeTxn_result()
8193 
    try:
6031 rajveer 8194 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8195 
    except TransactionServiceException, ex:
8196 
      result.ex = ex
8197 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8198 
    result.write(oprot)
8199 
    oprot.writeMessageEnd()
8200 
    oprot.trans.flush()
8201 
 
6031 rajveer 8202 
  def process_getUserWallet(self, seqid, iprot, oprot):
8203 
    args = getUserWallet_args()
6000 mandeep.dh 8204 
    args.read(iprot)
8205 
    iprot.readMessageEnd()
6031 rajveer 8206 
    result = getUserWallet_result()
8207 
    result.success = self._handler.getUserWallet(args.userId)
8208 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8209 
    result.write(oprot)
8210 
    oprot.writeMessageEnd()
8211 
    oprot.trans.flush()
8212 
 
6031 rajveer 8213 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8214 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8215 
    args.read(iprot)
8216 
    iprot.readMessageEnd()
6031 rajveer 8217 
    result = getUserWalletHistory_result()
8218 
    result.success = self._handler.getUserWalletHistory(args.userId)
8219 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8220 
    result.write(oprot)
8221 
    oprot.writeMessageEnd()
8222 
    oprot.trans.flush()
8223 
 
6050 anupam.sin 8224 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8225 
    args = getRechargeOrdersForTransaction_args()
8226 
    args.read(iprot)
8227 
    iprot.readMessageEnd()
8228 
    result = getRechargeOrdersForTransaction_result()
8229 
    try:
8230 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8231 
    except TransactionServiceException, ex:
8232 
      result.ex = ex
8233 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
8237 
 
6048 rajveer 8238 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8239 
    args = getServiceProviders_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = getServiceProviders_result()
6206 rajveer 8243 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8244 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8245 
    result.write(oprot)
8246 
    oprot.writeMessageEnd()
8247 
    oprot.trans.flush()
6000 mandeep.dh 8248 
 
6048 rajveer 8249 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8250 
    args = getServiceProviderForDevice_args()
8251 
    args.read(iprot)
8252 
    iprot.readMessageEnd()
8253 
    result = getServiceProviderForDevice_result()
6049 rajveer 8254 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8255 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8256 
    result.write(oprot)
8257 
    oprot.writeMessageEnd()
8258 
    oprot.trans.flush()
8259 
 
6094 rajveer 8260 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8261 
    args = getRechargeOrdersForDevice_args()
8262 
    args.read(iprot)
8263 
    iprot.readMessageEnd()
8264 
    result = getRechargeOrdersForDevice_result()
8265 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8266 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
6048 rajveer 8270 
 
6094 rajveer 8271 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8272 
    args = addAmountToWallet_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = addAmountToWallet_result()
8276 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8277 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8278 
    result.write(oprot)
8279 
    oprot.writeMessageEnd()
8280 
    oprot.trans.flush()
8281 
 
6188 rajveer 8282 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8283 
    args = getRechargeStatistics_args()
8284 
    args.read(iprot)
8285 
    iprot.readMessageEnd()
8286 
    result = getRechargeStatistics_result()
8287 
    result.success = self._handler.getRechargeStatistics()
8288 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
8292 
 
6154 rajveer 8293 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8294 
    args = getRechargeOrdersForStatus_args()
8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
8297 
    result = getRechargeOrdersForStatus_result()
8298 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8299 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8300 
    result.write(oprot)
8301 
    oprot.writeMessageEnd()
8302 
    oprot.trans.flush()
6094 rajveer 8303 
 
6159 rajveer 8304 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8305 
    args = getPlansForOperator_args()
8306 
    args.read(iprot)
8307 
    iprot.readMessageEnd()
8308 
    result = getPlansForOperator_result()
8309 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8310 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8311 
    result.write(oprot)
8312 
    oprot.writeMessageEnd()
8313 
    oprot.trans.flush()
6154 rajveer 8314 
 
6159 rajveer 8315 
 
94 ashish 8316 
# HELPER FUNCTIONS AND STRUCTURES
8317 
 
8318 
class createTransaction_args:
8319 
  """
8320 
  Attributes:
8321 
   - transaction
8322 
  """
8323 
 
8324 
  thrift_spec = (
8325 
    None, # 0
8326 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8327 
  )
8328 
 
8329 
  def __init__(self, transaction=None,):
8330 
    self.transaction = transaction
8331 
 
8332 
  def read(self, iprot):
8333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8335 
      return
8336 
    iprot.readStructBegin()
8337 
    while True:
8338 
      (fname, ftype, fid) = iprot.readFieldBegin()
8339 
      if ftype == TType.STOP:
8340 
        break
8341 
      if fid == 1:
8342 
        if ftype == TType.STRUCT:
8343 
          self.transaction = Transaction()
8344 
          self.transaction.read(iprot)
8345 
        else:
8346 
          iprot.skip(ftype)
8347 
      else:
8348 
        iprot.skip(ftype)
8349 
      iprot.readFieldEnd()
8350 
    iprot.readStructEnd()
8351 
 
8352 
  def write(self, oprot):
8353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8355 
      return
8356 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8357 
    if self.transaction is not None:
94 ashish 8358 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8359 
      self.transaction.write(oprot)
8360 
      oprot.writeFieldEnd()
8361 
    oprot.writeFieldStop()
8362 
    oprot.writeStructEnd()
8363 
 
3431 rajveer 8364 
  def validate(self):
8365 
    return
8366 
 
8367 
 
94 ashish 8368 
  def __repr__(self):
8369 
    L = ['%s=%r' % (key, value)
8370 
      for key, value in self.__dict__.iteritems()]
8371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8372 
 
8373 
  def __eq__(self, other):
8374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8375 
 
8376 
  def __ne__(self, other):
8377 
    return not (self == other)
8378 
 
8379 
class createTransaction_result:
8380 
  """
8381 
  Attributes:
132 ashish 8382 
   - success
94 ashish 8383 
   - ex
8384 
  """
8385 
 
8386 
  thrift_spec = (
132 ashish 8387 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8389 
  )
8390 
 
132 ashish 8391 
  def __init__(self, success=None, ex=None,):
8392 
    self.success = success
94 ashish 8393 
    self.ex = ex
8394 
 
8395 
  def read(self, iprot):
8396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8398 
      return
8399 
    iprot.readStructBegin()
8400 
    while True:
8401 
      (fname, ftype, fid) = iprot.readFieldBegin()
8402 
      if ftype == TType.STOP:
8403 
        break
132 ashish 8404 
      if fid == 0:
8405 
        if ftype == TType.I64:
8406 
          self.success = iprot.readI64();
8407 
        else:
8408 
          iprot.skip(ftype)
8409 
      elif fid == 1:
94 ashish 8410 
        if ftype == TType.STRUCT:
8411 
          self.ex = TransactionServiceException()
8412 
          self.ex.read(iprot)
8413 
        else:
8414 
          iprot.skip(ftype)
8415 
      else:
8416 
        iprot.skip(ftype)
8417 
      iprot.readFieldEnd()
8418 
    iprot.readStructEnd()
8419 
 
8420 
  def write(self, oprot):
8421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8423 
      return
8424 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8425 
    if self.success is not None:
132 ashish 8426 
      oprot.writeFieldBegin('success', TType.I64, 0)
8427 
      oprot.writeI64(self.success)
8428 
      oprot.writeFieldEnd()
3431 rajveer 8429 
    if self.ex is not None:
94 ashish 8430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8431 
      self.ex.write(oprot)
8432 
      oprot.writeFieldEnd()
8433 
    oprot.writeFieldStop()
8434 
    oprot.writeStructEnd()
8435 
 
3431 rajveer 8436 
  def validate(self):
8437 
    return
8438 
 
8439 
 
94 ashish 8440 
  def __repr__(self):
8441 
    L = ['%s=%r' % (key, value)
8442 
      for key, value in self.__dict__.iteritems()]
8443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8444 
 
8445 
  def __eq__(self, other):
8446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8447 
 
8448 
  def __ne__(self, other):
8449 
    return not (self == other)
8450 
 
8451 
class getTransaction_args:
8452 
  """
8453 
  Attributes:
8454 
   - id
8455 
  """
8456 
 
8457 
  thrift_spec = (
8458 
    None, # 0
8459 
    (1, TType.I64, 'id', None, None, ), # 1
8460 
  )
8461 
 
8462 
  def __init__(self, id=None,):
8463 
    self.id = id
8464 
 
8465 
  def read(self, iprot):
8466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8468 
      return
8469 
    iprot.readStructBegin()
8470 
    while True:
8471 
      (fname, ftype, fid) = iprot.readFieldBegin()
8472 
      if ftype == TType.STOP:
8473 
        break
8474 
      if fid == 1:
8475 
        if ftype == TType.I64:
8476 
          self.id = iprot.readI64();
8477 
        else:
8478 
          iprot.skip(ftype)
8479 
      else:
8480 
        iprot.skip(ftype)
8481 
      iprot.readFieldEnd()
8482 
    iprot.readStructEnd()
8483 
 
8484 
  def write(self, oprot):
8485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8487 
      return
8488 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8489 
    if self.id is not None:
94 ashish 8490 
      oprot.writeFieldBegin('id', TType.I64, 1)
8491 
      oprot.writeI64(self.id)
8492 
      oprot.writeFieldEnd()
8493 
    oprot.writeFieldStop()
8494 
    oprot.writeStructEnd()
8495 
 
3431 rajveer 8496 
  def validate(self):
8497 
    return
8498 
 
8499 
 
94 ashish 8500 
  def __repr__(self):
8501 
    L = ['%s=%r' % (key, value)
8502 
      for key, value in self.__dict__.iteritems()]
8503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8504 
 
8505 
  def __eq__(self, other):
8506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8507 
 
8508 
  def __ne__(self, other):
8509 
    return not (self == other)
8510 
 
8511 
class getTransaction_result:
8512 
  """
8513 
  Attributes:
8514 
   - success
8515 
   - ex
8516 
  """
8517 
 
8518 
  thrift_spec = (
8519 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8520 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8521 
  )
8522 
 
8523 
  def __init__(self, success=None, ex=None,):
8524 
    self.success = success
8525 
    self.ex = ex
8526 
 
8527 
  def read(self, iprot):
8528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8530 
      return
8531 
    iprot.readStructBegin()
8532 
    while True:
8533 
      (fname, ftype, fid) = iprot.readFieldBegin()
8534 
      if ftype == TType.STOP:
8535 
        break
8536 
      if fid == 0:
8537 
        if ftype == TType.STRUCT:
8538 
          self.success = Transaction()
8539 
          self.success.read(iprot)
8540 
        else:
8541 
          iprot.skip(ftype)
8542 
      elif fid == 1:
8543 
        if ftype == TType.STRUCT:
8544 
          self.ex = TransactionServiceException()
8545 
          self.ex.read(iprot)
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      else:
8549 
        iprot.skip(ftype)
8550 
      iprot.readFieldEnd()
8551 
    iprot.readStructEnd()
8552 
 
8553 
  def write(self, oprot):
8554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8556 
      return
8557 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8558 
    if self.success is not None:
94 ashish 8559 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8560 
      self.success.write(oprot)
8561 
      oprot.writeFieldEnd()
3431 rajveer 8562 
    if self.ex is not None:
94 ashish 8563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8564 
      self.ex.write(oprot)
8565 
      oprot.writeFieldEnd()
8566 
    oprot.writeFieldStop()
8567 
    oprot.writeStructEnd()
8568 
 
3431 rajveer 8569 
  def validate(self):
8570 
    return
8571 
 
8572 
 
94 ashish 8573 
  def __repr__(self):
8574 
    L = ['%s=%r' % (key, value)
8575 
      for key, value in self.__dict__.iteritems()]
8576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8577 
 
8578 
  def __eq__(self, other):
8579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8580 
 
8581 
  def __ne__(self, other):
8582 
    return not (self == other)
8583 
 
8584 
class getTransactionsForCustomer_args:
8585 
  """
8586 
  Attributes:
8587 
   - customerId
8588 
   - from_date
8589 
   - to_date
8590 
   - status
8591 
  """
8592 
 
8593 
  thrift_spec = (
8594 
    None, # 0
8595 
    (1, TType.I64, 'customerId', None, None, ), # 1
8596 
    (2, TType.I64, 'from_date', None, None, ), # 2
8597 
    (3, TType.I64, 'to_date', None, None, ), # 3
8598 
    (4, TType.I32, 'status', None, None, ), # 4
8599 
  )
8600 
 
8601 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8602 
    self.customerId = customerId
8603 
    self.from_date = from_date
8604 
    self.to_date = to_date
8605 
    self.status = status
8606 
 
8607 
  def read(self, iprot):
8608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8610 
      return
8611 
    iprot.readStructBegin()
8612 
    while True:
8613 
      (fname, ftype, fid) = iprot.readFieldBegin()
8614 
      if ftype == TType.STOP:
8615 
        break
8616 
      if fid == 1:
8617 
        if ftype == TType.I64:
8618 
          self.customerId = iprot.readI64();
8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      elif fid == 2:
8622 
        if ftype == TType.I64:
8623 
          self.from_date = iprot.readI64();
8624 
        else:
8625 
          iprot.skip(ftype)
8626 
      elif fid == 3:
8627 
        if ftype == TType.I64:
8628 
          self.to_date = iprot.readI64();
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      elif fid == 4:
8632 
        if ftype == TType.I32:
8633 
          self.status = iprot.readI32();
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      else:
8637 
        iprot.skip(ftype)
8638 
      iprot.readFieldEnd()
8639 
    iprot.readStructEnd()
8640 
 
8641 
  def write(self, oprot):
8642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8644 
      return
8645 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8646 
    if self.customerId is not None:
94 ashish 8647 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8648 
      oprot.writeI64(self.customerId)
8649 
      oprot.writeFieldEnd()
3431 rajveer 8650 
    if self.from_date is not None:
94 ashish 8651 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8652 
      oprot.writeI64(self.from_date)
8653 
      oprot.writeFieldEnd()
3431 rajveer 8654 
    if self.to_date is not None:
94 ashish 8655 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8656 
      oprot.writeI64(self.to_date)
8657 
      oprot.writeFieldEnd()
3431 rajveer 8658 
    if self.status is not None:
94 ashish 8659 
      oprot.writeFieldBegin('status', TType.I32, 4)
8660 
      oprot.writeI32(self.status)
8661 
      oprot.writeFieldEnd()
8662 
    oprot.writeFieldStop()
8663 
    oprot.writeStructEnd()
8664 
 
3431 rajveer 8665 
  def validate(self):
8666 
    return
8667 
 
8668 
 
94 ashish 8669 
  def __repr__(self):
8670 
    L = ['%s=%r' % (key, value)
8671 
      for key, value in self.__dict__.iteritems()]
8672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8673 
 
8674 
  def __eq__(self, other):
8675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8676 
 
8677 
  def __ne__(self, other):
8678 
    return not (self == other)
8679 
 
8680 
class getTransactionsForCustomer_result:
8681 
  """
8682 
  Attributes:
8683 
   - success
8684 
   - ex
8685 
  """
8686 
 
8687 
  thrift_spec = (
8688 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8690 
  )
8691 
 
8692 
  def __init__(self, success=None, ex=None,):
8693 
    self.success = success
8694 
    self.ex = ex
8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      if fid == 0:
8706 
        if ftype == TType.LIST:
8707 
          self.success = []
6188 rajveer 8708 
          (_etype109, _size106) = iprot.readListBegin()
8709 
          for _i110 in xrange(_size106):
8710 
            _elem111 = Transaction()
8711 
            _elem111.read(iprot)
8712 
            self.success.append(_elem111)
94 ashish 8713 
          iprot.readListEnd()
8714 
        else:
8715 
          iprot.skip(ftype)
8716 
      elif fid == 1:
8717 
        if ftype == TType.STRUCT:
8718 
          self.ex = TransactionServiceException()
8719 
          self.ex.read(iprot)
8720 
        else:
8721 
          iprot.skip(ftype)
8722 
      else:
8723 
        iprot.skip(ftype)
8724 
      iprot.readFieldEnd()
8725 
    iprot.readStructEnd()
8726 
 
8727 
  def write(self, oprot):
8728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8730 
      return
8731 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8732 
    if self.success is not None:
94 ashish 8733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8735 
      for iter112 in self.success:
8736 
        iter112.write(oprot)
94 ashish 8737 
      oprot.writeListEnd()
8738 
      oprot.writeFieldEnd()
3431 rajveer 8739 
    if self.ex is not None:
94 ashish 8740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8741 
      self.ex.write(oprot)
8742 
      oprot.writeFieldEnd()
8743 
    oprot.writeFieldStop()
8744 
    oprot.writeStructEnd()
8745 
 
3431 rajveer 8746 
  def validate(self):
8747 
    return
8748 
 
8749 
 
94 ashish 8750 
  def __repr__(self):
8751 
    L = ['%s=%r' % (key, value)
8752 
      for key, value in self.__dict__.iteritems()]
8753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8754 
 
8755 
  def __eq__(self, other):
8756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8757 
 
8758 
  def __ne__(self, other):
8759 
    return not (self == other)
8760 
 
132 ashish 8761 
class getTransactionsForShoppingCartId_args:
8762 
  """
8763 
  Attributes:
8764 
   - shoppingCartId
8765 
  """
8766 
 
8767 
  thrift_spec = (
8768 
    None, # 0
8769 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8770 
  )
8771 
 
8772 
  def __init__(self, shoppingCartId=None,):
8773 
    self.shoppingCartId = shoppingCartId
8774 
 
8775 
  def read(self, iprot):
8776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8778 
      return
8779 
    iprot.readStructBegin()
8780 
    while True:
8781 
      (fname, ftype, fid) = iprot.readFieldBegin()
8782 
      if ftype == TType.STOP:
8783 
        break
8784 
      if fid == 1:
8785 
        if ftype == TType.I64:
8786 
          self.shoppingCartId = iprot.readI64();
8787 
        else:
8788 
          iprot.skip(ftype)
8789 
      else:
8790 
        iprot.skip(ftype)
8791 
      iprot.readFieldEnd()
8792 
    iprot.readStructEnd()
8793 
 
8794 
  def write(self, oprot):
8795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8797 
      return
8798 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8799 
    if self.shoppingCartId is not None:
132 ashish 8800 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8801 
      oprot.writeI64(self.shoppingCartId)
8802 
      oprot.writeFieldEnd()
8803 
    oprot.writeFieldStop()
8804 
    oprot.writeStructEnd()
8805 
 
3431 rajveer 8806 
  def validate(self):
8807 
    return
8808 
 
8809 
 
132 ashish 8810 
  def __repr__(self):
8811 
    L = ['%s=%r' % (key, value)
8812 
      for key, value in self.__dict__.iteritems()]
8813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8814 
 
8815 
  def __eq__(self, other):
8816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8817 
 
8818 
  def __ne__(self, other):
8819 
    return not (self == other)
8820 
 
8821 
class getTransactionsForShoppingCartId_result:
8822 
  """
8823 
  Attributes:
8824 
   - success
8825 
   - ex
8826 
  """
8827 
 
8828 
  thrift_spec = (
8829 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8831 
  )
8832 
 
8833 
  def __init__(self, success=None, ex=None,):
8834 
    self.success = success
8835 
    self.ex = ex
8836 
 
8837 
  def read(self, iprot):
8838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8840 
      return
8841 
    iprot.readStructBegin()
8842 
    while True:
8843 
      (fname, ftype, fid) = iprot.readFieldBegin()
8844 
      if ftype == TType.STOP:
8845 
        break
8846 
      if fid == 0:
8847 
        if ftype == TType.LIST:
8848 
          self.success = []
6188 rajveer 8849 
          (_etype116, _size113) = iprot.readListBegin()
8850 
          for _i117 in xrange(_size113):
8851 
            _elem118 = Transaction()
8852 
            _elem118.read(iprot)
8853 
            self.success.append(_elem118)
132 ashish 8854 
          iprot.readListEnd()
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      elif fid == 1:
8858 
        if ftype == TType.STRUCT:
8859 
          self.ex = TransactionServiceException()
8860 
          self.ex.read(iprot)
8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
8872 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8873 
    if self.success is not None:
132 ashish 8874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8876 
      for iter119 in self.success:
8877 
        iter119.write(oprot)
132 ashish 8878 
      oprot.writeListEnd()
8879 
      oprot.writeFieldEnd()
3431 rajveer 8880 
    if self.ex is not None:
132 ashish 8881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8882 
      self.ex.write(oprot)
8883 
      oprot.writeFieldEnd()
8884 
    oprot.writeFieldStop()
8885 
    oprot.writeStructEnd()
8886 
 
3431 rajveer 8887 
  def validate(self):
8888 
    return
8889 
 
8890 
 
132 ashish 8891 
  def __repr__(self):
8892 
    L = ['%s=%r' % (key, value)
8893 
      for key, value in self.__dict__.iteritems()]
8894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8895 
 
8896 
  def __eq__(self, other):
8897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8898 
 
8899 
  def __ne__(self, other):
8900 
    return not (self == other)
8901 
 
94 ashish 8902 
class getTransactionStatus_args:
8903 
  """
8904 
  Attributes:
8905 
   - transactionId
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    None, # 0
8910 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8911 
  )
8912 
 
8913 
  def __init__(self, transactionId=None,):
8914 
    self.transactionId = transactionId
8915 
 
8916 
  def read(self, iprot):
8917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8919 
      return
8920 
    iprot.readStructBegin()
8921 
    while True:
8922 
      (fname, ftype, fid) = iprot.readFieldBegin()
8923 
      if ftype == TType.STOP:
8924 
        break
8925 
      if fid == 1:
8926 
        if ftype == TType.I64:
8927 
          self.transactionId = iprot.readI64();
8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      else:
8931 
        iprot.skip(ftype)
8932 
      iprot.readFieldEnd()
8933 
    iprot.readStructEnd()
8934 
 
8935 
  def write(self, oprot):
8936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8938 
      return
8939 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8940 
    if self.transactionId is not None:
94 ashish 8941 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8942 
      oprot.writeI64(self.transactionId)
8943 
      oprot.writeFieldEnd()
8944 
    oprot.writeFieldStop()
8945 
    oprot.writeStructEnd()
8946 
 
3431 rajveer 8947 
  def validate(self):
8948 
    return
8949 
 
8950 
 
94 ashish 8951 
  def __repr__(self):
8952 
    L = ['%s=%r' % (key, value)
8953 
      for key, value in self.__dict__.iteritems()]
8954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8955 
 
8956 
  def __eq__(self, other):
8957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8958 
 
8959 
  def __ne__(self, other):
8960 
    return not (self == other)
8961 
 
8962 
class getTransactionStatus_result:
8963 
  """
8964 
  Attributes:
8965 
   - success
8966 
   - ex
8967 
  """
8968 
 
8969 
  thrift_spec = (
8970 
    (0, TType.I32, 'success', None, None, ), # 0
8971 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8972 
  )
8973 
 
8974 
  def __init__(self, success=None, ex=None,):
8975 
    self.success = success
8976 
    self.ex = ex
8977 
 
8978 
  def read(self, iprot):
8979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8981 
      return
8982 
    iprot.readStructBegin()
8983 
    while True:
8984 
      (fname, ftype, fid) = iprot.readFieldBegin()
8985 
      if ftype == TType.STOP:
8986 
        break
8987 
      if fid == 0:
8988 
        if ftype == TType.I32:
8989 
          self.success = iprot.readI32();
8990 
        else:
8991 
          iprot.skip(ftype)
8992 
      elif fid == 1:
8993 
        if ftype == TType.STRUCT:
8994 
          self.ex = TransactionServiceException()
8995 
          self.ex.read(iprot)
8996 
        else:
8997 
          iprot.skip(ftype)
8998 
      else:
8999 
        iprot.skip(ftype)
9000 
      iprot.readFieldEnd()
9001 
    iprot.readStructEnd()
9002 
 
9003 
  def write(self, oprot):
9004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9006 
      return
9007 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9008 
    if self.success is not None:
94 ashish 9009 
      oprot.writeFieldBegin('success', TType.I32, 0)
9010 
      oprot.writeI32(self.success)
9011 
      oprot.writeFieldEnd()
3431 rajveer 9012 
    if self.ex is not None:
94 ashish 9013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9014 
      self.ex.write(oprot)
9015 
      oprot.writeFieldEnd()
9016 
    oprot.writeFieldStop()
9017 
    oprot.writeStructEnd()
9018 
 
3431 rajveer 9019 
  def validate(self):
9020 
    return
9021 
 
9022 
 
94 ashish 9023 
  def __repr__(self):
9024 
    L = ['%s=%r' % (key, value)
9025 
      for key, value in self.__dict__.iteritems()]
9026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9027 
 
9028 
  def __eq__(self, other):
9029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9030 
 
9031 
  def __ne__(self, other):
9032 
    return not (self == other)
9033 
 
9034 
class changeTransactionStatus_args:
9035 
  """
9036 
  Attributes:
9037 
   - transactionId
9038 
   - status
9039 
   - description
5527 anupam.sin 9040 
   - pickUp
9041 
   - orderType
94 ashish 9042 
  """
9043 
 
9044 
  thrift_spec = (
9045 
    None, # 0
9046 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9047 
    (2, TType.I32, 'status', None, None, ), # 2
9048 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9049 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9050 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9051 
  )
9052 
 
5527 anupam.sin 9053 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9054 
    self.transactionId = transactionId
9055 
    self.status = status
9056 
    self.description = description
5527 anupam.sin 9057 
    self.pickUp = pickUp
9058 
    self.orderType = orderType
94 ashish 9059 
 
9060 
  def read(self, iprot):
9061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9063 
      return
9064 
    iprot.readStructBegin()
9065 
    while True:
9066 
      (fname, ftype, fid) = iprot.readFieldBegin()
9067 
      if ftype == TType.STOP:
9068 
        break
9069 
      if fid == 1:
9070 
        if ftype == TType.I64:
9071 
          self.transactionId = iprot.readI64();
9072 
        else:
9073 
          iprot.skip(ftype)
9074 
      elif fid == 2:
9075 
        if ftype == TType.I32:
9076 
          self.status = iprot.readI32();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      elif fid == 3:
9080 
        if ftype == TType.STRING:
9081 
          self.description = iprot.readString();
9082 
        else:
9083 
          iprot.skip(ftype)
5387 rajveer 9084 
      elif fid == 4:
5527 anupam.sin 9085 
        if ftype == TType.I64:
9086 
          self.pickUp = iprot.readI64();
5387 rajveer 9087 
        else:
9088 
          iprot.skip(ftype)
5527 anupam.sin 9089 
      elif fid == 5:
9090 
        if ftype == TType.I32:
9091 
          self.orderType = iprot.readI32();
9092 
        else:
9093 
          iprot.skip(ftype)
94 ashish 9094 
      else:
9095 
        iprot.skip(ftype)
9096 
      iprot.readFieldEnd()
9097 
    iprot.readStructEnd()
9098 
 
9099 
  def write(self, oprot):
9100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9102 
      return
9103 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9104 
    if self.transactionId is not None:
94 ashish 9105 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9106 
      oprot.writeI64(self.transactionId)
9107 
      oprot.writeFieldEnd()
3431 rajveer 9108 
    if self.status is not None:
94 ashish 9109 
      oprot.writeFieldBegin('status', TType.I32, 2)
9110 
      oprot.writeI32(self.status)
9111 
      oprot.writeFieldEnd()
3431 rajveer 9112 
    if self.description is not None:
94 ashish 9113 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9114 
      oprot.writeString(self.description)
9115 
      oprot.writeFieldEnd()
5527 anupam.sin 9116 
    if self.pickUp is not None:
9117 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9118 
      oprot.writeI64(self.pickUp)
5387 rajveer 9119 
      oprot.writeFieldEnd()
5527 anupam.sin 9120 
    if self.orderType is not None:
9121 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9122 
      oprot.writeI32(self.orderType)
9123 
      oprot.writeFieldEnd()
94 ashish 9124 
    oprot.writeFieldStop()
9125 
    oprot.writeStructEnd()
9126 
 
3431 rajveer 9127 
  def validate(self):
9128 
    return
9129 
 
9130 
 
94 ashish 9131 
  def __repr__(self):
9132 
    L = ['%s=%r' % (key, value)
9133 
      for key, value in self.__dict__.iteritems()]
9134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9135 
 
9136 
  def __eq__(self, other):
9137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9138 
 
9139 
  def __ne__(self, other):
9140 
    return not (self == other)
9141 
 
9142 
class changeTransactionStatus_result:
9143 
  """
9144 
  Attributes:
9145 
   - success
9146 
   - ex
9147 
  """
9148 
 
9149 
  thrift_spec = (
9150 
    (0, TType.BOOL, 'success', None, None, ), # 0
9151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9152 
  )
9153 
 
9154 
  def __init__(self, success=None, ex=None,):
9155 
    self.success = success
9156 
    self.ex = ex
9157 
 
9158 
  def read(self, iprot):
9159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9161 
      return
9162 
    iprot.readStructBegin()
9163 
    while True:
9164 
      (fname, ftype, fid) = iprot.readFieldBegin()
9165 
      if ftype == TType.STOP:
9166 
        break
9167 
      if fid == 0:
9168 
        if ftype == TType.BOOL:
9169 
          self.success = iprot.readBool();
9170 
        else:
9171 
          iprot.skip(ftype)
9172 
      elif fid == 1:
9173 
        if ftype == TType.STRUCT:
9174 
          self.ex = TransactionServiceException()
9175 
          self.ex.read(iprot)
9176 
        else:
9177 
          iprot.skip(ftype)
9178 
      else:
9179 
        iprot.skip(ftype)
9180 
      iprot.readFieldEnd()
9181 
    iprot.readStructEnd()
9182 
 
9183 
  def write(self, oprot):
9184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9186 
      return
9187 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9188 
    if self.success is not None:
94 ashish 9189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9190 
      oprot.writeBool(self.success)
9191 
      oprot.writeFieldEnd()
3431 rajveer 9192 
    if self.ex is not None:
94 ashish 9193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9194 
      self.ex.write(oprot)
9195 
      oprot.writeFieldEnd()
9196 
    oprot.writeFieldStop()
9197 
    oprot.writeStructEnd()
9198 
 
3431 rajveer 9199 
  def validate(self):
9200 
    return
9201 
 
9202 
 
94 ashish 9203 
  def __repr__(self):
9204 
    L = ['%s=%r' % (key, value)
9205 
      for key, value in self.__dict__.iteritems()]
9206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9207 
 
9208 
  def __eq__(self, other):
9209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9210 
 
9211 
  def __ne__(self, other):
9212 
    return not (self == other)
9213 
 
1398 varun.gupt 9214 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9215 
  """
9216 
  Attributes:
9217 
   - transactionId
9218 
  """
9219 
 
9220 
  thrift_spec = (
9221 
    None, # 0
9222 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9223 
  )
9224 
 
9225 
  def __init__(self, transactionId=None,):
9226 
    self.transactionId = transactionId
9227 
 
9228 
  def read(self, iprot):
9229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9231 
      return
9232 
    iprot.readStructBegin()
9233 
    while True:
9234 
      (fname, ftype, fid) = iprot.readFieldBegin()
9235 
      if ftype == TType.STOP:
9236 
        break
9237 
      if fid == 1:
9238 
        if ftype == TType.I64:
9239 
          self.transactionId = iprot.readI64();
9240 
        else:
9241 
          iprot.skip(ftype)
9242 
      else:
9243 
        iprot.skip(ftype)
9244 
      iprot.readFieldEnd()
9245 
    iprot.readStructEnd()
9246 
 
9247 
  def write(self, oprot):
9248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9250 
      return
1398 varun.gupt 9251 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9252 
    if self.transactionId is not None:
1382 varun.gupt 9253 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9254 
      oprot.writeI64(self.transactionId)
9255 
      oprot.writeFieldEnd()
9256 
    oprot.writeFieldStop()
9257 
    oprot.writeStructEnd()
9258 
 
3431 rajveer 9259 
  def validate(self):
9260 
    return
9261 
 
9262 
 
1382 varun.gupt 9263 
  def __repr__(self):
9264 
    L = ['%s=%r' % (key, value)
9265 
      for key, value in self.__dict__.iteritems()]
9266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9267 
 
9268 
  def __eq__(self, other):
9269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9270 
 
9271 
  def __ne__(self, other):
9272 
    return not (self == other)
9273 
 
1398 varun.gupt 9274 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9275 
  """
9276 
  Attributes:
9277 
   - success
9278 
   - ex
9279 
  """
9280 
 
9281 
  thrift_spec = (
9282 
    (0, TType.BOOL, 'success', None, None, ), # 0
9283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9284 
  )
9285 
 
9286 
  def __init__(self, success=None, ex=None,):
9287 
    self.success = success
9288 
    self.ex = ex
9289 
 
9290 
  def read(self, iprot):
9291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9293 
      return
9294 
    iprot.readStructBegin()
9295 
    while True:
9296 
      (fname, ftype, fid) = iprot.readFieldBegin()
9297 
      if ftype == TType.STOP:
9298 
        break
9299 
      if fid == 0:
9300 
        if ftype == TType.BOOL:
9301 
          self.success = iprot.readBool();
9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      elif fid == 1:
9305 
        if ftype == TType.STRUCT:
9306 
          self.ex = TransactionServiceException()
9307 
          self.ex.read(iprot)
9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      else:
9311 
        iprot.skip(ftype)
9312 
      iprot.readFieldEnd()
9313 
    iprot.readStructEnd()
9314 
 
9315 
  def write(self, oprot):
9316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9318 
      return
1398 varun.gupt 9319 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9320 
    if self.success is not None:
1382 varun.gupt 9321 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9322 
      oprot.writeBool(self.success)
9323 
      oprot.writeFieldEnd()
3431 rajveer 9324 
    if self.ex is not None:
1382 varun.gupt 9325 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9326 
      self.ex.write(oprot)
9327 
      oprot.writeFieldEnd()
9328 
    oprot.writeFieldStop()
9329 
    oprot.writeStructEnd()
9330 
 
3431 rajveer 9331 
  def validate(self):
9332 
    return
9333 
 
9334 
 
1382 varun.gupt 9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
483 rajveer 9346 
class getAllOrders_args:
94 ashish 9347 
  """
9348 
  Attributes:
4801 anupam.sin 9349 
   - statuses
483 rajveer 9350 
   - from_date
9351 
   - to_date
9352 
   - warehouse_id
94 ashish 9353 
  """
9354 
 
9355 
  thrift_spec = (
9356 
    None, # 0
4801 anupam.sin 9357 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9358 
    (2, TType.I64, 'from_date', None, None, ), # 2
9359 
    (3, TType.I64, 'to_date', None, None, ), # 3
9360 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9361 
  )
9362 
 
4801 anupam.sin 9363 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9364 
    self.statuses = statuses
483 rajveer 9365 
    self.from_date = from_date
9366 
    self.to_date = to_date
9367 
    self.warehouse_id = warehouse_id
94 ashish 9368 
 
9369 
  def read(self, iprot):
9370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9372 
      return
9373 
    iprot.readStructBegin()
9374 
    while True:
9375 
      (fname, ftype, fid) = iprot.readFieldBegin()
9376 
      if ftype == TType.STOP:
9377 
        break
9378 
      if fid == 1:
4801 anupam.sin 9379 
        if ftype == TType.LIST:
9380 
          self.statuses = []
6188 rajveer 9381 
          (_etype123, _size120) = iprot.readListBegin()
9382 
          for _i124 in xrange(_size120):
9383 
            _elem125 = iprot.readI32();
9384 
            self.statuses.append(_elem125)
4801 anupam.sin 9385 
          iprot.readListEnd()
94 ashish 9386 
        else:
9387 
          iprot.skip(ftype)
483 rajveer 9388 
      elif fid == 2:
9389 
        if ftype == TType.I64:
9390 
          self.from_date = iprot.readI64();
94 ashish 9391 
        else:
9392 
          iprot.skip(ftype)
483 rajveer 9393 
      elif fid == 3:
9394 
        if ftype == TType.I64:
9395 
          self.to_date = iprot.readI64();
94 ashish 9396 
        else:
9397 
          iprot.skip(ftype)
483 rajveer 9398 
      elif fid == 4:
94 ashish 9399 
        if ftype == TType.I64:
483 rajveer 9400 
          self.warehouse_id = iprot.readI64();
94 ashish 9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
483 rajveer 9412 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9413 
    if self.statuses is not None:
9414 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9415 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9416 
      for iter126 in self.statuses:
9417 
        oprot.writeI32(iter126)
4801 anupam.sin 9418 
      oprot.writeListEnd()
94 ashish 9419 
      oprot.writeFieldEnd()
3431 rajveer 9420 
    if self.from_date is not None:
483 rajveer 9421 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9422 
      oprot.writeI64(self.from_date)
94 ashish 9423 
      oprot.writeFieldEnd()
3431 rajveer 9424 
    if self.to_date is not None:
483 rajveer 9425 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9426 
      oprot.writeI64(self.to_date)
94 ashish 9427 
      oprot.writeFieldEnd()
3431 rajveer 9428 
    if self.warehouse_id is not None:
483 rajveer 9429 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9430 
      oprot.writeI64(self.warehouse_id)
94 ashish 9431 
      oprot.writeFieldEnd()
9432 
    oprot.writeFieldStop()
9433 
    oprot.writeStructEnd()
9434 
 
3431 rajveer 9435 
  def validate(self):
9436 
    return
9437 
 
9438 
 
94 ashish 9439 
  def __repr__(self):
9440 
    L = ['%s=%r' % (key, value)
9441 
      for key, value in self.__dict__.iteritems()]
9442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9443 
 
9444 
  def __eq__(self, other):
9445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9446 
 
9447 
  def __ne__(self, other):
9448 
    return not (self == other)
9449 
 
483 rajveer 9450 
class getAllOrders_result:
94 ashish 9451 
  """
9452 
  Attributes:
9453 
   - success
9454 
   - ex
9455 
  """
9456 
 
9457 
  thrift_spec = (
483 rajveer 9458 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9460 
  )
9461 
 
9462 
  def __init__(self, success=None, ex=None,):
9463 
    self.success = success
9464 
    self.ex = ex
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 0:
483 rajveer 9476 
        if ftype == TType.LIST:
9477 
          self.success = []
6188 rajveer 9478 
          (_etype130, _size127) = iprot.readListBegin()
9479 
          for _i131 in xrange(_size127):
9480 
            _elem132 = Order()
9481 
            _elem132.read(iprot)
9482 
            self.success.append(_elem132)
483 rajveer 9483 
          iprot.readListEnd()
94 ashish 9484 
        else:
9485 
          iprot.skip(ftype)
9486 
      elif fid == 1:
9487 
        if ftype == TType.STRUCT:
9488 
          self.ex = TransactionServiceException()
9489 
          self.ex.read(iprot)
9490 
        else:
9491 
          iprot.skip(ftype)
9492 
      else:
9493 
        iprot.skip(ftype)
9494 
      iprot.readFieldEnd()
9495 
    iprot.readStructEnd()
9496 
 
9497 
  def write(self, oprot):
9498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9500 
      return
483 rajveer 9501 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9502 
    if self.success is not None:
483 rajveer 9503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9505 
      for iter133 in self.success:
9506 
        iter133.write(oprot)
483 rajveer 9507 
      oprot.writeListEnd()
94 ashish 9508 
      oprot.writeFieldEnd()
3431 rajveer 9509 
    if self.ex is not None:
94 ashish 9510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9511 
      self.ex.write(oprot)
9512 
      oprot.writeFieldEnd()
9513 
    oprot.writeFieldStop()
9514 
    oprot.writeStructEnd()
9515 
 
3431 rajveer 9516 
  def validate(self):
9517 
    return
9518 
 
9519 
 
94 ashish 9520 
  def __repr__(self):
9521 
    L = ['%s=%r' % (key, value)
9522 
      for key, value in self.__dict__.iteritems()]
9523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9524 
 
9525 
  def __eq__(self, other):
9526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9527 
 
9528 
  def __ne__(self, other):
9529 
    return not (self == other)
9530 
 
4133 chandransh 9531 
class getOrdersInBatch_args:
9532 
  """
9533 
  Attributes:
9534 
   - statuses
9535 
   - offset
9536 
   - limit
9537 
   - warehouse_id
9538 
  """
9539 
 
9540 
  thrift_spec = (
9541 
    None, # 0
9542 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9543 
    (2, TType.I64, 'offset', None, None, ), # 2
9544 
    (3, TType.I64, 'limit', None, None, ), # 3
9545 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9546 
  )
9547 
 
9548 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9549 
    self.statuses = statuses
9550 
    self.offset = offset
9551 
    self.limit = limit
9552 
    self.warehouse_id = warehouse_id
9553 
 
9554 
  def read(self, iprot):
9555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9557 
      return
9558 
    iprot.readStructBegin()
9559 
    while True:
9560 
      (fname, ftype, fid) = iprot.readFieldBegin()
9561 
      if ftype == TType.STOP:
9562 
        break
9563 
      if fid == 1:
9564 
        if ftype == TType.LIST:
9565 
          self.statuses = []
6188 rajveer 9566 
          (_etype137, _size134) = iprot.readListBegin()
9567 
          for _i138 in xrange(_size134):
9568 
            _elem139 = iprot.readI32();
9569 
            self.statuses.append(_elem139)
4133 chandransh 9570 
          iprot.readListEnd()
9571 
        else:
9572 
          iprot.skip(ftype)
9573 
      elif fid == 2:
9574 
        if ftype == TType.I64:
9575 
          self.offset = iprot.readI64();
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      elif fid == 3:
9579 
        if ftype == TType.I64:
9580 
          self.limit = iprot.readI64();
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      elif fid == 4:
9584 
        if ftype == TType.I64:
9585 
          self.warehouse_id = iprot.readI64();
9586 
        else:
9587 
          iprot.skip(ftype)
9588 
      else:
9589 
        iprot.skip(ftype)
9590 
      iprot.readFieldEnd()
9591 
    iprot.readStructEnd()
9592 
 
9593 
  def write(self, oprot):
9594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9596 
      return
9597 
    oprot.writeStructBegin('getOrdersInBatch_args')
9598 
    if self.statuses is not None:
9599 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9600 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9601 
      for iter140 in self.statuses:
9602 
        oprot.writeI32(iter140)
4133 chandransh 9603 
      oprot.writeListEnd()
9604 
      oprot.writeFieldEnd()
9605 
    if self.offset is not None:
9606 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9607 
      oprot.writeI64(self.offset)
9608 
      oprot.writeFieldEnd()
9609 
    if self.limit is not None:
9610 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9611 
      oprot.writeI64(self.limit)
9612 
      oprot.writeFieldEnd()
9613 
    if self.warehouse_id is not None:
9614 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9615 
      oprot.writeI64(self.warehouse_id)
9616 
      oprot.writeFieldEnd()
9617 
    oprot.writeFieldStop()
9618 
    oprot.writeStructEnd()
9619 
 
9620 
  def validate(self):
9621 
    return
9622 
 
9623 
 
9624 
  def __repr__(self):
9625 
    L = ['%s=%r' % (key, value)
9626 
      for key, value in self.__dict__.iteritems()]
9627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9628 
 
9629 
  def __eq__(self, other):
9630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9631 
 
9632 
  def __ne__(self, other):
9633 
    return not (self == other)
9634 
 
9635 
class getOrdersInBatch_result:
9636 
  """
9637 
  Attributes:
9638 
   - success
9639 
   - ex
9640 
  """
9641 
 
9642 
  thrift_spec = (
9643 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9645 
  )
9646 
 
9647 
  def __init__(self, success=None, ex=None,):
9648 
    self.success = success
9649 
    self.ex = ex
9650 
 
9651 
  def read(self, iprot):
9652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9654 
      return
9655 
    iprot.readStructBegin()
9656 
    while True:
9657 
      (fname, ftype, fid) = iprot.readFieldBegin()
9658 
      if ftype == TType.STOP:
9659 
        break
9660 
      if fid == 0:
9661 
        if ftype == TType.LIST:
9662 
          self.success = []
6188 rajveer 9663 
          (_etype144, _size141) = iprot.readListBegin()
9664 
          for _i145 in xrange(_size141):
9665 
            _elem146 = Order()
9666 
            _elem146.read(iprot)
9667 
            self.success.append(_elem146)
4133 chandransh 9668 
          iprot.readListEnd()
9669 
        else:
9670 
          iprot.skip(ftype)
9671 
      elif fid == 1:
9672 
        if ftype == TType.STRUCT:
9673 
          self.ex = TransactionServiceException()
9674 
          self.ex.read(iprot)
9675 
        else:
9676 
          iprot.skip(ftype)
9677 
      else:
9678 
        iprot.skip(ftype)
9679 
      iprot.readFieldEnd()
9680 
    iprot.readStructEnd()
9681 
 
9682 
  def write(self, oprot):
9683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9685 
      return
9686 
    oprot.writeStructBegin('getOrdersInBatch_result')
9687 
    if self.success is not None:
9688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9689 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9690 
      for iter147 in self.success:
9691 
        iter147.write(oprot)
4133 chandransh 9692 
      oprot.writeListEnd()
9693 
      oprot.writeFieldEnd()
9694 
    if self.ex is not None:
9695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9696 
      self.ex.write(oprot)
9697 
      oprot.writeFieldEnd()
9698 
    oprot.writeFieldStop()
9699 
    oprot.writeStructEnd()
9700 
 
9701 
  def validate(self):
9702 
    return
9703 
 
9704 
 
9705 
  def __repr__(self):
9706 
    L = ['%s=%r' % (key, value)
9707 
      for key, value in self.__dict__.iteritems()]
9708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9709 
 
9710 
  def __eq__(self, other):
9711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9712 
 
9713 
  def __ne__(self, other):
9714 
    return not (self == other)
9715 
 
9716 
class getOrderCount_args:
9717 
  """
9718 
  Attributes:
9719 
   - statuses
9720 
   - warehouseId
9721 
  """
9722 
 
9723 
  thrift_spec = (
9724 
    None, # 0
9725 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9726 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9727 
  )
9728 
 
9729 
  def __init__(self, statuses=None, warehouseId=None,):
9730 
    self.statuses = statuses
9731 
    self.warehouseId = warehouseId
9732 
 
9733 
  def read(self, iprot):
9734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9736 
      return
9737 
    iprot.readStructBegin()
9738 
    while True:
9739 
      (fname, ftype, fid) = iprot.readFieldBegin()
9740 
      if ftype == TType.STOP:
9741 
        break
9742 
      if fid == 1:
9743 
        if ftype == TType.LIST:
9744 
          self.statuses = []
6188 rajveer 9745 
          (_etype151, _size148) = iprot.readListBegin()
9746 
          for _i152 in xrange(_size148):
9747 
            _elem153 = iprot.readI32();
9748 
            self.statuses.append(_elem153)
4133 chandransh 9749 
          iprot.readListEnd()
9750 
        else:
9751 
          iprot.skip(ftype)
9752 
      elif fid == 2:
9753 
        if ftype == TType.I64:
9754 
          self.warehouseId = iprot.readI64();
9755 
        else:
9756 
          iprot.skip(ftype)
9757 
      else:
9758 
        iprot.skip(ftype)
9759 
      iprot.readFieldEnd()
9760 
    iprot.readStructEnd()
9761 
 
9762 
  def write(self, oprot):
9763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9765 
      return
9766 
    oprot.writeStructBegin('getOrderCount_args')
9767 
    if self.statuses is not None:
9768 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9769 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9770 
      for iter154 in self.statuses:
9771 
        oprot.writeI32(iter154)
4133 chandransh 9772 
      oprot.writeListEnd()
9773 
      oprot.writeFieldEnd()
9774 
    if self.warehouseId is not None:
9775 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9776 
      oprot.writeI64(self.warehouseId)
9777 
      oprot.writeFieldEnd()
9778 
    oprot.writeFieldStop()
9779 
    oprot.writeStructEnd()
9780 
 
9781 
  def validate(self):
9782 
    return
9783 
 
9784 
 
9785 
  def __repr__(self):
9786 
    L = ['%s=%r' % (key, value)
9787 
      for key, value in self.__dict__.iteritems()]
9788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9789 
 
9790 
  def __eq__(self, other):
9791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9792 
 
9793 
  def __ne__(self, other):
9794 
    return not (self == other)
9795 
 
9796 
class getOrderCount_result:
9797 
  """
9798 
  Attributes:
9799 
   - success
9800 
   - ex
9801 
  """
9802 
 
9803 
  thrift_spec = (
9804 
    (0, TType.I32, 'success', None, None, ), # 0
9805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9806 
  )
9807 
 
9808 
  def __init__(self, success=None, ex=None,):
9809 
    self.success = success
9810 
    self.ex = ex
9811 
 
9812 
  def read(self, iprot):
9813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9815 
      return
9816 
    iprot.readStructBegin()
9817 
    while True:
9818 
      (fname, ftype, fid) = iprot.readFieldBegin()
9819 
      if ftype == TType.STOP:
9820 
        break
9821 
      if fid == 0:
9822 
        if ftype == TType.I32:
9823 
          self.success = iprot.readI32();
9824 
        else:
9825 
          iprot.skip(ftype)
9826 
      elif fid == 1:
9827 
        if ftype == TType.STRUCT:
9828 
          self.ex = TransactionServiceException()
9829 
          self.ex.read(iprot)
9830 
        else:
9831 
          iprot.skip(ftype)
9832 
      else:
9833 
        iprot.skip(ftype)
9834 
      iprot.readFieldEnd()
9835 
    iprot.readStructEnd()
9836 
 
9837 
  def write(self, oprot):
9838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9840 
      return
9841 
    oprot.writeStructBegin('getOrderCount_result')
9842 
    if self.success is not None:
9843 
      oprot.writeFieldBegin('success', TType.I32, 0)
9844 
      oprot.writeI32(self.success)
9845 
      oprot.writeFieldEnd()
9846 
    if self.ex is not None:
9847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9848 
      self.ex.write(oprot)
9849 
      oprot.writeFieldEnd()
9850 
    oprot.writeFieldStop()
9851 
    oprot.writeStructEnd()
9852 
 
9853 
  def validate(self):
9854 
    return
9855 
 
9856 
 
9857 
  def __repr__(self):
9858 
    L = ['%s=%r' % (key, value)
9859 
      for key, value in self.__dict__.iteritems()]
9860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9861 
 
9862 
  def __eq__(self, other):
9863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9864 
 
9865 
  def __ne__(self, other):
9866 
    return not (self == other)
9867 
 
999 varun.gupt 9868 
class getOrdersByBillingDate_args:
9869 
  """
9870 
  Attributes:
9871 
   - status
9872 
   - start_billing_date
9873 
   - end_billing_date
9874 
   - warehouse_id
9875 
  """
9876 
 
9877 
  thrift_spec = (
9878 
    None, # 0
9879 
    (1, TType.I32, 'status', None, None, ), # 1
9880 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9881 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9882 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9883 
  )
9884 
 
9885 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9886 
    self.status = status
9887 
    self.start_billing_date = start_billing_date
9888 
    self.end_billing_date = end_billing_date
9889 
    self.warehouse_id = warehouse_id
9890 
 
9891 
  def read(self, iprot):
9892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9894 
      return
9895 
    iprot.readStructBegin()
9896 
    while True:
9897 
      (fname, ftype, fid) = iprot.readFieldBegin()
9898 
      if ftype == TType.STOP:
9899 
        break
9900 
      if fid == 1:
9901 
        if ftype == TType.I32:
9902 
          self.status = iprot.readI32();
9903 
        else:
9904 
          iprot.skip(ftype)
9905 
      elif fid == 2:
9906 
        if ftype == TType.I64:
9907 
          self.start_billing_date = iprot.readI64();
9908 
        else:
9909 
          iprot.skip(ftype)
9910 
      elif fid == 3:
9911 
        if ftype == TType.I64:
9912 
          self.end_billing_date = iprot.readI64();
9913 
        else:
9914 
          iprot.skip(ftype)
9915 
      elif fid == 4:
9916 
        if ftype == TType.I64:
9917 
          self.warehouse_id = iprot.readI64();
9918 
        else:
9919 
          iprot.skip(ftype)
9920 
      else:
9921 
        iprot.skip(ftype)
9922 
      iprot.readFieldEnd()
9923 
    iprot.readStructEnd()
9924 
 
9925 
  def write(self, oprot):
9926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9928 
      return
9929 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9930 
    if self.status is not None:
999 varun.gupt 9931 
      oprot.writeFieldBegin('status', TType.I32, 1)
9932 
      oprot.writeI32(self.status)
9933 
      oprot.writeFieldEnd()
3431 rajveer 9934 
    if self.start_billing_date is not None:
999 varun.gupt 9935 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9936 
      oprot.writeI64(self.start_billing_date)
9937 
      oprot.writeFieldEnd()
3431 rajveer 9938 
    if self.end_billing_date is not None:
999 varun.gupt 9939 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9940 
      oprot.writeI64(self.end_billing_date)
9941 
      oprot.writeFieldEnd()
3431 rajveer 9942 
    if self.warehouse_id is not None:
999 varun.gupt 9943 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9944 
      oprot.writeI64(self.warehouse_id)
9945 
      oprot.writeFieldEnd()
9946 
    oprot.writeFieldStop()
9947 
    oprot.writeStructEnd()
9948 
 
3431 rajveer 9949 
  def validate(self):
9950 
    return
9951 
 
9952 
 
999 varun.gupt 9953 
  def __repr__(self):
9954 
    L = ['%s=%r' % (key, value)
9955 
      for key, value in self.__dict__.iteritems()]
9956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9957 
 
9958 
  def __eq__(self, other):
9959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9960 
 
9961 
  def __ne__(self, other):
9962 
    return not (self == other)
9963 
 
9964 
class getOrdersByBillingDate_result:
9965 
  """
9966 
  Attributes:
9967 
   - success
9968 
   - ex
9969 
  """
9970 
 
9971 
  thrift_spec = (
9972 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9974 
  )
9975 
 
9976 
  def __init__(self, success=None, ex=None,):
9977 
    self.success = success
9978 
    self.ex = ex
9979 
 
9980 
  def read(self, iprot):
9981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9983 
      return
9984 
    iprot.readStructBegin()
9985 
    while True:
9986 
      (fname, ftype, fid) = iprot.readFieldBegin()
9987 
      if ftype == TType.STOP:
9988 
        break
9989 
      if fid == 0:
9990 
        if ftype == TType.LIST:
9991 
          self.success = []
6188 rajveer 9992 
          (_etype158, _size155) = iprot.readListBegin()
9993 
          for _i159 in xrange(_size155):
9994 
            _elem160 = Order()
9995 
            _elem160.read(iprot)
9996 
            self.success.append(_elem160)
999 varun.gupt 9997 
          iprot.readListEnd()
9998 
        else:
9999 
          iprot.skip(ftype)
10000 
      elif fid == 1:
10001 
        if ftype == TType.STRUCT:
10002 
          self.ex = TransactionServiceException()
10003 
          self.ex.read(iprot)
10004 
        else:
10005 
          iprot.skip(ftype)
10006 
      else:
10007 
        iprot.skip(ftype)
10008 
      iprot.readFieldEnd()
10009 
    iprot.readStructEnd()
10010 
 
10011 
  def write(self, oprot):
10012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10014 
      return
10015 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10016 
    if self.success is not None:
999 varun.gupt 10017 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10018 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10019 
      for iter161 in self.success:
10020 
        iter161.write(oprot)
999 varun.gupt 10021 
      oprot.writeListEnd()
10022 
      oprot.writeFieldEnd()
3431 rajveer 10023 
    if self.ex is not None:
999 varun.gupt 10024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10025 
      self.ex.write(oprot)
10026 
      oprot.writeFieldEnd()
10027 
    oprot.writeFieldStop()
10028 
    oprot.writeStructEnd()
10029 
 
3431 rajveer 10030 
  def validate(self):
10031 
    return
10032 
 
10033 
 
999 varun.gupt 10034 
  def __repr__(self):
10035 
    L = ['%s=%r' % (key, value)
10036 
      for key, value in self.__dict__.iteritems()]
10037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10038 
 
10039 
  def __eq__(self, other):
10040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10041 
 
10042 
  def __ne__(self, other):
10043 
    return not (self == other)
10044 
 
3427 chandransh 10045 
class getOrdersByShippingDate_args:
10046 
  """
10047 
  Attributes:
10048 
   - fromShippingDate
10049 
   - toShippingDate
10050 
   - providerId
10051 
   - warehouseId
3451 chandransh 10052 
   - cod
3427 chandransh 10053 
  """
10054 
 
10055 
  thrift_spec = (
10056 
    None, # 0
10057 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10058 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10059 
    (3, TType.I64, 'providerId', None, None, ), # 3
10060 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10061 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10062 
  )
10063 
 
3451 chandransh 10064 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10065 
    self.fromShippingDate = fromShippingDate
10066 
    self.toShippingDate = toShippingDate
10067 
    self.providerId = providerId
10068 
    self.warehouseId = warehouseId
3451 chandransh 10069 
    self.cod = cod
3427 chandransh 10070 
 
10071 
  def read(self, iprot):
10072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10074 
      return
10075 
    iprot.readStructBegin()
10076 
    while True:
10077 
      (fname, ftype, fid) = iprot.readFieldBegin()
10078 
      if ftype == TType.STOP:
10079 
        break
10080 
      if fid == 1:
10081 
        if ftype == TType.I64:
10082 
          self.fromShippingDate = iprot.readI64();
10083 
        else:
10084 
          iprot.skip(ftype)
10085 
      elif fid == 2:
10086 
        if ftype == TType.I64:
10087 
          self.toShippingDate = iprot.readI64();
10088 
        else:
10089 
          iprot.skip(ftype)
10090 
      elif fid == 3:
10091 
        if ftype == TType.I64:
10092 
          self.providerId = iprot.readI64();
10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      elif fid == 4:
10096 
        if ftype == TType.I64:
10097 
          self.warehouseId = iprot.readI64();
10098 
        else:
10099 
          iprot.skip(ftype)
3451 chandransh 10100 
      elif fid == 5:
10101 
        if ftype == TType.BOOL:
10102 
          self.cod = iprot.readBool();
10103 
        else:
10104 
          iprot.skip(ftype)
3427 chandransh 10105 
      else:
10106 
        iprot.skip(ftype)
10107 
      iprot.readFieldEnd()
10108 
    iprot.readStructEnd()
10109 
 
10110 
  def write(self, oprot):
10111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10113 
      return
10114 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10115 
    if self.fromShippingDate is not None:
3427 chandransh 10116 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10117 
      oprot.writeI64(self.fromShippingDate)
10118 
      oprot.writeFieldEnd()
3431 rajveer 10119 
    if self.toShippingDate is not None:
3427 chandransh 10120 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10121 
      oprot.writeI64(self.toShippingDate)
10122 
      oprot.writeFieldEnd()
3431 rajveer 10123 
    if self.providerId is not None:
3427 chandransh 10124 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10125 
      oprot.writeI64(self.providerId)
10126 
      oprot.writeFieldEnd()
3431 rajveer 10127 
    if self.warehouseId is not None:
3427 chandransh 10128 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10129 
      oprot.writeI64(self.warehouseId)
10130 
      oprot.writeFieldEnd()
3451 chandransh 10131 
    if self.cod is not None:
10132 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10133 
      oprot.writeBool(self.cod)
10134 
      oprot.writeFieldEnd()
3427 chandransh 10135 
    oprot.writeFieldStop()
10136 
    oprot.writeStructEnd()
10137 
 
3431 rajveer 10138 
  def validate(self):
10139 
    return
10140 
 
10141 
 
3427 chandransh 10142 
  def __repr__(self):
10143 
    L = ['%s=%r' % (key, value)
10144 
      for key, value in self.__dict__.iteritems()]
10145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10146 
 
10147 
  def __eq__(self, other):
10148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10149 
 
10150 
  def __ne__(self, other):
10151 
    return not (self == other)
10152 
 
10153 
class getOrdersByShippingDate_result:
10154 
  """
10155 
  Attributes:
10156 
   - success
10157 
   - ex
10158 
  """
10159 
 
10160 
  thrift_spec = (
10161 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10163 
  )
10164 
 
10165 
  def __init__(self, success=None, ex=None,):
10166 
    self.success = success
10167 
    self.ex = ex
10168 
 
10169 
  def read(self, iprot):
10170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10172 
      return
10173 
    iprot.readStructBegin()
10174 
    while True:
10175 
      (fname, ftype, fid) = iprot.readFieldBegin()
10176 
      if ftype == TType.STOP:
10177 
        break
10178 
      if fid == 0:
10179 
        if ftype == TType.LIST:
10180 
          self.success = []
6188 rajveer 10181 
          (_etype165, _size162) = iprot.readListBegin()
10182 
          for _i166 in xrange(_size162):
10183 
            _elem167 = Order()
10184 
            _elem167.read(iprot)
10185 
            self.success.append(_elem167)
3427 chandransh 10186 
          iprot.readListEnd()
10187 
        else:
10188 
          iprot.skip(ftype)
10189 
      elif fid == 1:
10190 
        if ftype == TType.STRUCT:
10191 
          self.ex = TransactionServiceException()
10192 
          self.ex.read(iprot)
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      else:
10196 
        iprot.skip(ftype)
10197 
      iprot.readFieldEnd()
10198 
    iprot.readStructEnd()
10199 
 
10200 
  def write(self, oprot):
10201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10203 
      return
10204 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10205 
    if self.success is not None:
3427 chandransh 10206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10208 
      for iter168 in self.success:
10209 
        iter168.write(oprot)
3427 chandransh 10210 
      oprot.writeListEnd()
10211 
      oprot.writeFieldEnd()
3431 rajveer 10212 
    if self.ex is not None:
3427 chandransh 10213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10214 
      self.ex.write(oprot)
10215 
      oprot.writeFieldEnd()
10216 
    oprot.writeFieldStop()
10217 
    oprot.writeStructEnd()
10218 
 
3431 rajveer 10219 
  def validate(self):
10220 
    return
10221 
 
10222 
 
3427 chandransh 10223 
  def __repr__(self):
10224 
    L = ['%s=%r' % (key, value)
10225 
      for key, value in self.__dict__.iteritems()]
10226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10227 
 
10228 
  def __eq__(self, other):
10229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10230 
 
10231 
  def __ne__(self, other):
10232 
    return not (self == other)
10233 
 
1382 varun.gupt 10234 
class getReturnableOrdersForCustomer_args:
10235 
  """
10236 
  Attributes:
10237 
   - customer_id
10238 
   - limit
10239 
  """
10240 
 
10241 
  thrift_spec = (
10242 
    None, # 0
10243 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10244 
    (2, TType.I64, 'limit', None, None, ), # 2
10245 
  )
10246 
 
10247 
  def __init__(self, customer_id=None, limit=None,):
10248 
    self.customer_id = customer_id
10249 
    self.limit = limit
10250 
 
10251 
  def read(self, iprot):
10252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10254 
      return
10255 
    iprot.readStructBegin()
10256 
    while True:
10257 
      (fname, ftype, fid) = iprot.readFieldBegin()
10258 
      if ftype == TType.STOP:
10259 
        break
10260 
      if fid == 1:
10261 
        if ftype == TType.I64:
10262 
          self.customer_id = iprot.readI64();
10263 
        else:
10264 
          iprot.skip(ftype)
10265 
      elif fid == 2:
10266 
        if ftype == TType.I64:
10267 
          self.limit = iprot.readI64();
10268 
        else:
10269 
          iprot.skip(ftype)
10270 
      else:
10271 
        iprot.skip(ftype)
10272 
      iprot.readFieldEnd()
10273 
    iprot.readStructEnd()
10274 
 
10275 
  def write(self, oprot):
10276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10278 
      return
10279 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10280 
    if self.customer_id is not None:
1382 varun.gupt 10281 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10282 
      oprot.writeI64(self.customer_id)
10283 
      oprot.writeFieldEnd()
3431 rajveer 10284 
    if self.limit is not None:
1382 varun.gupt 10285 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10286 
      oprot.writeI64(self.limit)
10287 
      oprot.writeFieldEnd()
10288 
    oprot.writeFieldStop()
10289 
    oprot.writeStructEnd()
10290 
 
3431 rajveer 10291 
  def validate(self):
10292 
    return
10293 
 
10294 
 
1382 varun.gupt 10295 
  def __repr__(self):
10296 
    L = ['%s=%r' % (key, value)
10297 
      for key, value in self.__dict__.iteritems()]
10298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10299 
 
10300 
  def __eq__(self, other):
10301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10302 
 
10303 
  def __ne__(self, other):
10304 
    return not (self == other)
10305 
 
10306 
class getReturnableOrdersForCustomer_result:
10307 
  """
10308 
  Attributes:
10309 
   - success
10310 
   - ex
10311 
  """
10312 
 
10313 
  thrift_spec = (
10314 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10316 
  )
10317 
 
10318 
  def __init__(self, success=None, ex=None,):
10319 
    self.success = success
10320 
    self.ex = ex
10321 
 
10322 
  def read(self, iprot):
10323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10325 
      return
10326 
    iprot.readStructBegin()
10327 
    while True:
10328 
      (fname, ftype, fid) = iprot.readFieldBegin()
10329 
      if ftype == TType.STOP:
10330 
        break
10331 
      if fid == 0:
10332 
        if ftype == TType.LIST:
10333 
          self.success = []
6188 rajveer 10334 
          (_etype172, _size169) = iprot.readListBegin()
10335 
          for _i173 in xrange(_size169):
10336 
            _elem174 = iprot.readI64();
10337 
            self.success.append(_elem174)
1382 varun.gupt 10338 
          iprot.readListEnd()
10339 
        else:
10340 
          iprot.skip(ftype)
10341 
      elif fid == 1:
10342 
        if ftype == TType.STRUCT:
10343 
          self.ex = TransactionServiceException()
10344 
          self.ex.read(iprot)
10345 
        else:
10346 
          iprot.skip(ftype)
10347 
      else:
10348 
        iprot.skip(ftype)
10349 
      iprot.readFieldEnd()
10350 
    iprot.readStructEnd()
10351 
 
10352 
  def write(self, oprot):
10353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10355 
      return
10356 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10357 
    if self.success is not None:
1382 varun.gupt 10358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10359 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10360 
      for iter175 in self.success:
10361 
        oprot.writeI64(iter175)
1382 varun.gupt 10362 
      oprot.writeListEnd()
10363 
      oprot.writeFieldEnd()
3431 rajveer 10364 
    if self.ex is not None:
1382 varun.gupt 10365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10366 
      self.ex.write(oprot)
10367 
      oprot.writeFieldEnd()
10368 
    oprot.writeFieldStop()
10369 
    oprot.writeStructEnd()
10370 
 
3431 rajveer 10371 
  def validate(self):
10372 
    return
10373 
 
10374 
 
1382 varun.gupt 10375 
  def __repr__(self):
10376 
    L = ['%s=%r' % (key, value)
10377 
      for key, value in self.__dict__.iteritems()]
10378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10379 
 
10380 
  def __eq__(self, other):
10381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10382 
 
10383 
  def __ne__(self, other):
10384 
    return not (self == other)
10385 
 
10386 
class getCancellableOrdersForCustomer_args:
10387 
  """
10388 
  Attributes:
10389 
   - customer_id
10390 
   - limit
10391 
  """
10392 
 
10393 
  thrift_spec = (
10394 
    None, # 0
10395 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10396 
    (2, TType.I64, 'limit', None, None, ), # 2
10397 
  )
10398 
 
10399 
  def __init__(self, customer_id=None, limit=None,):
10400 
    self.customer_id = customer_id
10401 
    self.limit = limit
10402 
 
10403 
  def read(self, iprot):
10404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10406 
      return
10407 
    iprot.readStructBegin()
10408 
    while True:
10409 
      (fname, ftype, fid) = iprot.readFieldBegin()
10410 
      if ftype == TType.STOP:
10411 
        break
10412 
      if fid == 1:
10413 
        if ftype == TType.I64:
10414 
          self.customer_id = iprot.readI64();
10415 
        else:
10416 
          iprot.skip(ftype)
10417 
      elif fid == 2:
10418 
        if ftype == TType.I64:
10419 
          self.limit = iprot.readI64();
10420 
        else:
10421 
          iprot.skip(ftype)
10422 
      else:
10423 
        iprot.skip(ftype)
10424 
      iprot.readFieldEnd()
10425 
    iprot.readStructEnd()
10426 
 
10427 
  def write(self, oprot):
10428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10430 
      return
10431 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10432 
    if self.customer_id is not None:
1382 varun.gupt 10433 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10434 
      oprot.writeI64(self.customer_id)
10435 
      oprot.writeFieldEnd()
3431 rajveer 10436 
    if self.limit is not None:
1382 varun.gupt 10437 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10438 
      oprot.writeI64(self.limit)
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
3431 rajveer 10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
1382 varun.gupt 10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
10458 
class getCancellableOrdersForCustomer_result:
10459 
  """
10460 
  Attributes:
10461 
   - success
10462 
   - ex
10463 
  """
10464 
 
10465 
  thrift_spec = (
10466 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10468 
  )
10469 
 
10470 
  def __init__(self, success=None, ex=None,):
10471 
    self.success = success
10472 
    self.ex = ex
10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 0:
10484 
        if ftype == TType.LIST:
10485 
          self.success = []
6188 rajveer 10486 
          (_etype179, _size176) = iprot.readListBegin()
10487 
          for _i180 in xrange(_size176):
10488 
            _elem181 = iprot.readI64();
10489 
            self.success.append(_elem181)
1382 varun.gupt 10490 
          iprot.readListEnd()
10491 
        else:
10492 
          iprot.skip(ftype)
10493 
      elif fid == 1:
10494 
        if ftype == TType.STRUCT:
10495 
          self.ex = TransactionServiceException()
10496 
          self.ex.read(iprot)
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10509 
    if self.success is not None:
1382 varun.gupt 10510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10511 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10512 
      for iter182 in self.success:
10513 
        oprot.writeI64(iter182)
1382 varun.gupt 10514 
      oprot.writeListEnd()
10515 
      oprot.writeFieldEnd()
3431 rajveer 10516 
    if self.ex is not None:
1382 varun.gupt 10517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10518 
      self.ex.write(oprot)
10519 
      oprot.writeFieldEnd()
10520 
    oprot.writeFieldStop()
10521 
    oprot.writeStructEnd()
10522 
 
3431 rajveer 10523 
  def validate(self):
10524 
    return
10525 
 
10526 
 
1382 varun.gupt 10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
10537 
 
483 rajveer 10538 
class changeOrderStatus_args:
94 ashish 10539 
  """
10540 
  Attributes:
483 rajveer 10541 
   - orderId
10542 
   - status
10543 
   - description
94 ashish 10544 
  """
10545 
 
10546 
  thrift_spec = (
10547 
    None, # 0
483 rajveer 10548 
    (1, TType.I64, 'orderId', None, None, ), # 1
10549 
    (2, TType.I32, 'status', None, None, ), # 2
10550 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10551 
  )
10552 
 
483 rajveer 10553 
  def __init__(self, orderId=None, status=None, description=None,):
10554 
    self.orderId = orderId
10555 
    self.status = status
10556 
    self.description = description
94 ashish 10557 
 
10558 
  def read(self, iprot):
10559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10561 
      return
10562 
    iprot.readStructBegin()
10563 
    while True:
10564 
      (fname, ftype, fid) = iprot.readFieldBegin()
10565 
      if ftype == TType.STOP:
10566 
        break
10567 
      if fid == 1:
10568 
        if ftype == TType.I64:
483 rajveer 10569 
          self.orderId = iprot.readI64();
94 ashish 10570 
        else:
10571 
          iprot.skip(ftype)
10572 
      elif fid == 2:
483 rajveer 10573 
        if ftype == TType.I32:
10574 
          self.status = iprot.readI32();
94 ashish 10575 
        else:
10576 
          iprot.skip(ftype)
483 rajveer 10577 
      elif fid == 3:
10578 
        if ftype == TType.STRING:
10579 
          self.description = iprot.readString();
10580 
        else:
10581 
          iprot.skip(ftype)
94 ashish 10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
483 rajveer 10591 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10592 
    if self.orderId is not None:
483 rajveer 10593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10594 
      oprot.writeI64(self.orderId)
94 ashish 10595 
      oprot.writeFieldEnd()
3431 rajveer 10596 
    if self.status is not None:
483 rajveer 10597 
      oprot.writeFieldBegin('status', TType.I32, 2)
10598 
      oprot.writeI32(self.status)
94 ashish 10599 
      oprot.writeFieldEnd()
3431 rajveer 10600 
    if self.description is not None:
483 rajveer 10601 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10602 
      oprot.writeString(self.description)
10603 
      oprot.writeFieldEnd()
94 ashish 10604 
    oprot.writeFieldStop()
10605 
    oprot.writeStructEnd()
10606 
 
3431 rajveer 10607 
  def validate(self):
10608 
    return
10609 
 
10610 
 
94 ashish 10611 
  def __repr__(self):
10612 
    L = ['%s=%r' % (key, value)
10613 
      for key, value in self.__dict__.iteritems()]
10614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10615 
 
10616 
  def __eq__(self, other):
10617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10618 
 
10619 
  def __ne__(self, other):
10620 
    return not (self == other)
10621 
 
483 rajveer 10622 
class changeOrderStatus_result:
94 ashish 10623 
  """
10624 
  Attributes:
10625 
   - success
10626 
   - ex
10627 
  """
10628 
 
10629 
  thrift_spec = (
10630 
    (0, TType.BOOL, 'success', None, None, ), # 0
10631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10632 
  )
10633 
 
10634 
  def __init__(self, success=None, ex=None,):
10635 
    self.success = success
10636 
    self.ex = ex
10637 
 
10638 
  def read(self, iprot):
10639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10641 
      return
10642 
    iprot.readStructBegin()
10643 
    while True:
10644 
      (fname, ftype, fid) = iprot.readFieldBegin()
10645 
      if ftype == TType.STOP:
10646 
        break
10647 
      if fid == 0:
10648 
        if ftype == TType.BOOL:
10649 
          self.success = iprot.readBool();
10650 
        else:
10651 
          iprot.skip(ftype)
10652 
      elif fid == 1:
10653 
        if ftype == TType.STRUCT:
10654 
          self.ex = TransactionServiceException()
10655 
          self.ex.read(iprot)
10656 
        else:
10657 
          iprot.skip(ftype)
10658 
      else:
10659 
        iprot.skip(ftype)
10660 
      iprot.readFieldEnd()
10661 
    iprot.readStructEnd()
10662 
 
10663 
  def write(self, oprot):
10664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10666 
      return
483 rajveer 10667 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10668 
    if self.success is not None:
94 ashish 10669 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10670 
      oprot.writeBool(self.success)
10671 
      oprot.writeFieldEnd()
3431 rajveer 10672 
    if self.ex is not None:
94 ashish 10673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10674 
      self.ex.write(oprot)
10675 
      oprot.writeFieldEnd()
10676 
    oprot.writeFieldStop()
10677 
    oprot.writeStructEnd()
10678 
 
3431 rajveer 10679 
  def validate(self):
10680 
    return
10681 
 
10682 
 
94 ashish 10683 
  def __repr__(self):
10684 
    L = ['%s=%r' % (key, value)
10685 
      for key, value in self.__dict__.iteritems()]
10686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10687 
 
10688 
  def __eq__(self, other):
10689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10690 
 
10691 
  def __ne__(self, other):
10692 
    return not (self == other)
10693 
 
3064 chandransh 10694 
class getOrdersForTransaction_args:
494 rajveer 10695 
  """
10696 
  Attributes:
3064 chandransh 10697 
   - transactionId
10698 
   - customerId
494 rajveer 10699 
  """
10700 
 
10701 
  thrift_spec = (
10702 
    None, # 0
3064 chandransh 10703 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10704 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10705 
  )
10706 
 
3064 chandransh 10707 
  def __init__(self, transactionId=None, customerId=None,):
10708 
    self.transactionId = transactionId
10709 
    self.customerId = customerId
494 rajveer 10710 
 
10711 
  def read(self, iprot):
10712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10714 
      return
10715 
    iprot.readStructBegin()
10716 
    while True:
10717 
      (fname, ftype, fid) = iprot.readFieldBegin()
10718 
      if ftype == TType.STOP:
10719 
        break
10720 
      if fid == 1:
10721 
        if ftype == TType.I64:
3064 chandransh 10722 
          self.transactionId = iprot.readI64();
494 rajveer 10723 
        else:
10724 
          iprot.skip(ftype)
10725 
      elif fid == 2:
3064 chandransh 10726 
        if ftype == TType.I64:
10727 
          self.customerId = iprot.readI64();
494 rajveer 10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      else:
10731 
        iprot.skip(ftype)
10732 
      iprot.readFieldEnd()
10733 
    iprot.readStructEnd()
10734 
 
10735 
  def write(self, oprot):
10736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10738 
      return
3064 chandransh 10739 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10740 
    if self.transactionId is not None:
3064 chandransh 10741 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10742 
      oprot.writeI64(self.transactionId)
494 rajveer 10743 
      oprot.writeFieldEnd()
3431 rajveer 10744 
    if self.customerId is not None:
3064 chandransh 10745 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10746 
      oprot.writeI64(self.customerId)
494 rajveer 10747 
      oprot.writeFieldEnd()
10748 
    oprot.writeFieldStop()
10749 
    oprot.writeStructEnd()
10750 
 
3431 rajveer 10751 
  def validate(self):
10752 
    return
10753 
 
10754 
 
494 rajveer 10755 
  def __repr__(self):
10756 
    L = ['%s=%r' % (key, value)
10757 
      for key, value in self.__dict__.iteritems()]
10758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10759 
 
10760 
  def __eq__(self, other):
10761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10762 
 
10763 
  def __ne__(self, other):
10764 
    return not (self == other)
10765 
 
3064 chandransh 10766 
class getOrdersForTransaction_result:
494 rajveer 10767 
  """
10768 
  Attributes:
10769 
   - success
10770 
   - ex
10771 
  """
10772 
 
10773 
  thrift_spec = (
3064 chandransh 10774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10776 
  )
10777 
 
10778 
  def __init__(self, success=None, ex=None,):
10779 
    self.success = success
10780 
    self.ex = ex
10781 
 
10782 
  def read(self, iprot):
10783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10785 
      return
10786 
    iprot.readStructBegin()
10787 
    while True:
10788 
      (fname, ftype, fid) = iprot.readFieldBegin()
10789 
      if ftype == TType.STOP:
10790 
        break
10791 
      if fid == 0:
3064 chandransh 10792 
        if ftype == TType.LIST:
10793 
          self.success = []
6188 rajveer 10794 
          (_etype186, _size183) = iprot.readListBegin()
10795 
          for _i187 in xrange(_size183):
10796 
            _elem188 = Order()
10797 
            _elem188.read(iprot)
10798 
            self.success.append(_elem188)
3064 chandransh 10799 
          iprot.readListEnd()
494 rajveer 10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      elif fid == 1:
10803 
        if ftype == TType.STRUCT:
10804 
          self.ex = TransactionServiceException()
10805 
          self.ex.read(iprot)
10806 
        else:
10807 
          iprot.skip(ftype)
10808 
      else:
10809 
        iprot.skip(ftype)
10810 
      iprot.readFieldEnd()
10811 
    iprot.readStructEnd()
10812 
 
10813 
  def write(self, oprot):
10814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10816 
      return
3064 chandransh 10817 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10818 
    if self.success is not None:
3064 chandransh 10819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10821 
      for iter189 in self.success:
10822 
        iter189.write(oprot)
3064 chandransh 10823 
      oprot.writeListEnd()
494 rajveer 10824 
      oprot.writeFieldEnd()
3431 rajveer 10825 
    if self.ex is not None:
494 rajveer 10826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10827 
      self.ex.write(oprot)
10828 
      oprot.writeFieldEnd()
10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
3431 rajveer 10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
494 rajveer 10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
3064 chandransh 10847 
class getOrdersForCustomer_args:
1149 chandransh 10848 
  """
10849 
  Attributes:
3064 chandransh 10850 
   - customerId
10851 
   - from_date
10852 
   - to_date
10853 
   - statuses
1149 chandransh 10854 
  """
10855 
 
10856 
  thrift_spec = (
10857 
    None, # 0
3064 chandransh 10858 
    (1, TType.I64, 'customerId', None, None, ), # 1
10859 
    (2, TType.I64, 'from_date', None, None, ), # 2
10860 
    (3, TType.I64, 'to_date', None, None, ), # 3
10861 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10862 
  )
10863 
 
3064 chandransh 10864 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10865 
    self.customerId = customerId
10866 
    self.from_date = from_date
10867 
    self.to_date = to_date
10868 
    self.statuses = statuses
1149 chandransh 10869 
 
10870 
  def read(self, iprot):
10871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10873 
      return
10874 
    iprot.readStructBegin()
10875 
    while True:
10876 
      (fname, ftype, fid) = iprot.readFieldBegin()
10877 
      if ftype == TType.STOP:
10878 
        break
10879 
      if fid == 1:
10880 
        if ftype == TType.I64:
3064 chandransh 10881 
          self.customerId = iprot.readI64();
1149 chandransh 10882 
        else:
10883 
          iprot.skip(ftype)
10884 
      elif fid == 2:
10885 
        if ftype == TType.I64:
3064 chandransh 10886 
          self.from_date = iprot.readI64();
1149 chandransh 10887 
        else:
10888 
          iprot.skip(ftype)
2783 chandransh 10889 
      elif fid == 3:
10890 
        if ftype == TType.I64:
3064 chandransh 10891 
          self.to_date = iprot.readI64();
2783 chandransh 10892 
        else:
10893 
          iprot.skip(ftype)
10894 
      elif fid == 4:
3064 chandransh 10895 
        if ftype == TType.LIST:
10896 
          self.statuses = []
6188 rajveer 10897 
          (_etype193, _size190) = iprot.readListBegin()
10898 
          for _i194 in xrange(_size190):
10899 
            _elem195 = iprot.readI32();
10900 
            self.statuses.append(_elem195)
3064 chandransh 10901 
          iprot.readListEnd()
2783 chandransh 10902 
        else:
10903 
          iprot.skip(ftype)
1149 chandransh 10904 
      else:
10905 
        iprot.skip(ftype)
10906 
      iprot.readFieldEnd()
10907 
    iprot.readStructEnd()
10908 
 
10909 
  def write(self, oprot):
10910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10912 
      return
3064 chandransh 10913 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10914 
    if self.customerId is not None:
3064 chandransh 10915 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10916 
      oprot.writeI64(self.customerId)
1149 chandransh 10917 
      oprot.writeFieldEnd()
3431 rajveer 10918 
    if self.from_date is not None:
3064 chandransh 10919 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10920 
      oprot.writeI64(self.from_date)
1149 chandransh 10921 
      oprot.writeFieldEnd()
3431 rajveer 10922 
    if self.to_date is not None:
3064 chandransh 10923 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10924 
      oprot.writeI64(self.to_date)
2783 chandransh 10925 
      oprot.writeFieldEnd()
3431 rajveer 10926 
    if self.statuses is not None:
3064 chandransh 10927 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10928 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10929 
      for iter196 in self.statuses:
10930 
        oprot.writeI32(iter196)
3064 chandransh 10931 
      oprot.writeListEnd()
2783 chandransh 10932 
      oprot.writeFieldEnd()
1149 chandransh 10933 
    oprot.writeFieldStop()
10934 
    oprot.writeStructEnd()
10935 
 
3431 rajveer 10936 
  def validate(self):
10937 
    return
10938 
 
10939 
 
1149 chandransh 10940 
  def __repr__(self):
10941 
    L = ['%s=%r' % (key, value)
10942 
      for key, value in self.__dict__.iteritems()]
10943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10944 
 
10945 
  def __eq__(self, other):
10946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10947 
 
10948 
  def __ne__(self, other):
10949 
    return not (self == other)
10950 
 
3064 chandransh 10951 
class getOrdersForCustomer_result:
1149 chandransh 10952 
  """
10953 
  Attributes:
10954 
   - success
10955 
   - ex
10956 
  """
10957 
 
10958 
  thrift_spec = (
3064 chandransh 10959 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10961 
  )
10962 
 
10963 
  def __init__(self, success=None, ex=None,):
10964 
    self.success = success
10965 
    self.ex = ex
10966 
 
10967 
  def read(self, iprot):
10968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10970 
      return
10971 
    iprot.readStructBegin()
10972 
    while True:
10973 
      (fname, ftype, fid) = iprot.readFieldBegin()
10974 
      if ftype == TType.STOP:
10975 
        break
10976 
      if fid == 0:
3064 chandransh 10977 
        if ftype == TType.LIST:
10978 
          self.success = []
6188 rajveer 10979 
          (_etype200, _size197) = iprot.readListBegin()
10980 
          for _i201 in xrange(_size197):
10981 
            _elem202 = Order()
10982 
            _elem202.read(iprot)
10983 
            self.success.append(_elem202)
3064 chandransh 10984 
          iprot.readListEnd()
1149 chandransh 10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      elif fid == 1:
10988 
        if ftype == TType.STRUCT:
10989 
          self.ex = TransactionServiceException()
10990 
          self.ex.read(iprot)
10991 
        else:
10992 
          iprot.skip(ftype)
10993 
      else:
10994 
        iprot.skip(ftype)
10995 
      iprot.readFieldEnd()
10996 
    iprot.readStructEnd()
10997 
 
10998 
  def write(self, oprot):
10999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11001 
      return
3064 chandransh 11002 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11003 
    if self.success is not None:
3064 chandransh 11004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11006 
      for iter203 in self.success:
11007 
        iter203.write(oprot)
3064 chandransh 11008 
      oprot.writeListEnd()
1149 chandransh 11009 
      oprot.writeFieldEnd()
3431 rajveer 11010 
    if self.ex is not None:
1149 chandransh 11011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11012 
      self.ex.write(oprot)
11013 
      oprot.writeFieldEnd()
11014 
    oprot.writeFieldStop()
11015 
    oprot.writeStructEnd()
11016 
 
3431 rajveer 11017 
  def validate(self):
11018 
    return
11019 
 
11020 
 
1149 chandransh 11021 
  def __repr__(self):
11022 
    L = ['%s=%r' % (key, value)
11023 
      for key, value in self.__dict__.iteritems()]
11024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11025 
 
11026 
  def __eq__(self, other):
11027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11028 
 
11029 
  def __ne__(self, other):
11030 
    return not (self == other)
11031 
 
3064 chandransh 11032 
class createOrder_args:
921 rajveer 11033 
  """
11034 
  Attributes:
3064 chandransh 11035 
   - order
921 rajveer 11036 
  """
11037 
 
11038 
  thrift_spec = (
11039 
    None, # 0
3064 chandransh 11040 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11041 
  )
11042 
 
3064 chandransh 11043 
  def __init__(self, order=None,):
11044 
    self.order = order
921 rajveer 11045 
 
11046 
  def read(self, iprot):
11047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11049 
      return
11050 
    iprot.readStructBegin()
11051 
    while True:
11052 
      (fname, ftype, fid) = iprot.readFieldBegin()
11053 
      if ftype == TType.STOP:
11054 
        break
11055 
      if fid == 1:
3064 chandransh 11056 
        if ftype == TType.STRUCT:
11057 
          self.order = Order()
11058 
          self.order.read(iprot)
921 rajveer 11059 
        else:
11060 
          iprot.skip(ftype)
11061 
      else:
11062 
        iprot.skip(ftype)
11063 
      iprot.readFieldEnd()
11064 
    iprot.readStructEnd()
11065 
 
11066 
  def write(self, oprot):
11067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11069 
      return
3064 chandransh 11070 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11071 
    if self.order is not None:
3064 chandransh 11072 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11073 
      self.order.write(oprot)
921 rajveer 11074 
      oprot.writeFieldEnd()
11075 
    oprot.writeFieldStop()
11076 
    oprot.writeStructEnd()
11077 
 
3431 rajveer 11078 
  def validate(self):
11079 
    return
11080 
 
11081 
 
921 rajveer 11082 
  def __repr__(self):
11083 
    L = ['%s=%r' % (key, value)
11084 
      for key, value in self.__dict__.iteritems()]
11085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11086 
 
11087 
  def __eq__(self, other):
11088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11089 
 
11090 
  def __ne__(self, other):
11091 
    return not (self == other)
11092 
 
3064 chandransh 11093 
class createOrder_result:
921 rajveer 11094 
  """
11095 
  Attributes:
11096 
   - success
11097 
   - ex
11098 
  """
11099 
 
11100 
  thrift_spec = (
3064 chandransh 11101 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11103 
  )
11104 
 
11105 
  def __init__(self, success=None, ex=None,):
11106 
    self.success = success
11107 
    self.ex = ex
11108 
 
11109 
  def read(self, iprot):
11110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11112 
      return
11113 
    iprot.readStructBegin()
11114 
    while True:
11115 
      (fname, ftype, fid) = iprot.readFieldBegin()
11116 
      if ftype == TType.STOP:
11117 
        break
11118 
      if fid == 0:
3064 chandransh 11119 
        if ftype == TType.I64:
11120 
          self.success = iprot.readI64();
921 rajveer 11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      elif fid == 1:
11124 
        if ftype == TType.STRUCT:
11125 
          self.ex = TransactionServiceException()
11126 
          self.ex.read(iprot)
11127 
        else:
11128 
          iprot.skip(ftype)
11129 
      else:
11130 
        iprot.skip(ftype)
11131 
      iprot.readFieldEnd()
11132 
    iprot.readStructEnd()
11133 
 
11134 
  def write(self, oprot):
11135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11137 
      return
3064 chandransh 11138 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11139 
    if self.success is not None:
3064 chandransh 11140 
      oprot.writeFieldBegin('success', TType.I64, 0)
11141 
      oprot.writeI64(self.success)
921 rajveer 11142 
      oprot.writeFieldEnd()
3431 rajveer 11143 
    if self.ex is not None:
921 rajveer 11144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11145 
      self.ex.write(oprot)
11146 
      oprot.writeFieldEnd()
11147 
    oprot.writeFieldStop()
11148 
    oprot.writeStructEnd()
11149 
 
3431 rajveer 11150 
  def validate(self):
11151 
    return
11152 
 
11153 
 
921 rajveer 11154 
  def __repr__(self):
11155 
    L = ['%s=%r' % (key, value)
11156 
      for key, value in self.__dict__.iteritems()]
11157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11158 
 
11159 
  def __eq__(self, other):
11160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11161 
 
11162 
  def __ne__(self, other):
11163 
    return not (self == other)
11164 
 
3064 chandransh 11165 
class getOrder_args:
921 rajveer 11166 
  """
11167 
  Attributes:
3064 chandransh 11168 
   - id
921 rajveer 11169 
  """
11170 
 
11171 
  thrift_spec = (
11172 
    None, # 0
3064 chandransh 11173 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11174 
  )
11175 
 
3064 chandransh 11176 
  def __init__(self, id=None,):
11177 
    self.id = id
921 rajveer 11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 1:
11189 
        if ftype == TType.I64:
3064 chandransh 11190 
          self.id = iprot.readI64();
921 rajveer 11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      else:
11194 
        iprot.skip(ftype)
11195 
      iprot.readFieldEnd()
11196 
    iprot.readStructEnd()
11197 
 
11198 
  def write(self, oprot):
11199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11201 
      return
3064 chandransh 11202 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11203 
    if self.id is not None:
3064 chandransh 11204 
      oprot.writeFieldBegin('id', TType.I64, 1)
11205 
      oprot.writeI64(self.id)
921 rajveer 11206 
      oprot.writeFieldEnd()
11207 
    oprot.writeFieldStop()
11208 
    oprot.writeStructEnd()
11209 
 
3431 rajveer 11210 
  def validate(self):
11211 
    return
11212 
 
11213 
 
921 rajveer 11214 
  def __repr__(self):
11215 
    L = ['%s=%r' % (key, value)
11216 
      for key, value in self.__dict__.iteritems()]
11217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11218 
 
11219 
  def __eq__(self, other):
11220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11221 
 
11222 
  def __ne__(self, other):
11223 
    return not (self == other)
11224 
 
3064 chandransh 11225 
class getOrder_result:
921 rajveer 11226 
  """
11227 
  Attributes:
11228 
   - success
11229 
   - ex
11230 
  """
11231 
 
11232 
  thrift_spec = (
3064 chandransh 11233 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11235 
  )
11236 
 
11237 
  def __init__(self, success=None, ex=None,):
11238 
    self.success = success
11239 
    self.ex = ex
11240 
 
11241 
  def read(self, iprot):
11242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11244 
      return
11245 
    iprot.readStructBegin()
11246 
    while True:
11247 
      (fname, ftype, fid) = iprot.readFieldBegin()
11248 
      if ftype == TType.STOP:
11249 
        break
11250 
      if fid == 0:
3064 chandransh 11251 
        if ftype == TType.STRUCT:
11252 
          self.success = Order()
11253 
          self.success.read(iprot)
921 rajveer 11254 
        else:
11255 
          iprot.skip(ftype)
11256 
      elif fid == 1:
11257 
        if ftype == TType.STRUCT:
11258 
          self.ex = TransactionServiceException()
11259 
          self.ex.read(iprot)
11260 
        else:
11261 
          iprot.skip(ftype)
11262 
      else:
11263 
        iprot.skip(ftype)
11264 
      iprot.readFieldEnd()
11265 
    iprot.readStructEnd()
11266 
 
11267 
  def write(self, oprot):
11268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11270 
      return
3064 chandransh 11271 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11272 
    if self.success is not None:
3064 chandransh 11273 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11274 
      self.success.write(oprot)
921 rajveer 11275 
      oprot.writeFieldEnd()
3431 rajveer 11276 
    if self.ex is not None:
921 rajveer 11277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11278 
      self.ex.write(oprot)
11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
3431 rajveer 11283 
  def validate(self):
11284 
    return
11285 
 
11286 
 
921 rajveer 11287 
  def __repr__(self):
11288 
    L = ['%s=%r' % (key, value)
11289 
      for key, value in self.__dict__.iteritems()]
11290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11291 
 
11292 
  def __eq__(self, other):
11293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11294 
 
11295 
  def __ne__(self, other):
11296 
    return not (self == other)
11297 
 
3064 chandransh 11298 
class getLineItemsForOrder_args:
94 ashish 11299 
  """
11300 
  Attributes:
3064 chandransh 11301 
   - orderId
94 ashish 11302 
  """
11303 
 
11304 
  thrift_spec = (
11305 
    None, # 0
3064 chandransh 11306 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11307 
  )
11308 
 
3064 chandransh 11309 
  def __init__(self, orderId=None,):
11310 
    self.orderId = orderId
94 ashish 11311 
 
11312 
  def read(self, iprot):
11313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11315 
      return
11316 
    iprot.readStructBegin()
11317 
    while True:
11318 
      (fname, ftype, fid) = iprot.readFieldBegin()
11319 
      if ftype == TType.STOP:
11320 
        break
11321 
      if fid == 1:
11322 
        if ftype == TType.I64:
3064 chandransh 11323 
          self.orderId = iprot.readI64();
94 ashish 11324 
        else:
11325 
          iprot.skip(ftype)
11326 
      else:
11327 
        iprot.skip(ftype)
11328 
      iprot.readFieldEnd()
11329 
    iprot.readStructEnd()
11330 
 
11331 
  def write(self, oprot):
11332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11334 
      return
3064 chandransh 11335 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11336 
    if self.orderId is not None:
3064 chandransh 11337 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11338 
      oprot.writeI64(self.orderId)
94 ashish 11339 
      oprot.writeFieldEnd()
11340 
    oprot.writeFieldStop()
11341 
    oprot.writeStructEnd()
11342 
 
3431 rajveer 11343 
  def validate(self):
11344 
    return
11345 
 
11346 
 
94 ashish 11347 
  def __repr__(self):
11348 
    L = ['%s=%r' % (key, value)
11349 
      for key, value in self.__dict__.iteritems()]
11350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11351 
 
11352 
  def __eq__(self, other):
11353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11354 
 
11355 
  def __ne__(self, other):
11356 
    return not (self == other)
11357 
 
3064 chandransh 11358 
class getLineItemsForOrder_result:
94 ashish 11359 
  """
11360 
  Attributes:
11361 
   - success
11362 
   - ex
11363 
  """
11364 
 
11365 
  thrift_spec = (
3064 chandransh 11366 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11368 
  )
11369 
 
11370 
  def __init__(self, success=None, ex=None,):
11371 
    self.success = success
11372 
    self.ex = ex
11373 
 
11374 
  def read(self, iprot):
11375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11377 
      return
11378 
    iprot.readStructBegin()
11379 
    while True:
11380 
      (fname, ftype, fid) = iprot.readFieldBegin()
11381 
      if ftype == TType.STOP:
11382 
        break
11383 
      if fid == 0:
483 rajveer 11384 
        if ftype == TType.LIST:
11385 
          self.success = []
6188 rajveer 11386 
          (_etype207, _size204) = iprot.readListBegin()
11387 
          for _i208 in xrange(_size204):
11388 
            _elem209 = LineItem()
11389 
            _elem209.read(iprot)
11390 
            self.success.append(_elem209)
483 rajveer 11391 
          iprot.readListEnd()
94 ashish 11392 
        else:
11393 
          iprot.skip(ftype)
11394 
      elif fid == 1:
11395 
        if ftype == TType.STRUCT:
11396 
          self.ex = TransactionServiceException()
11397 
          self.ex.read(iprot)
11398 
        else:
11399 
          iprot.skip(ftype)
11400 
      else:
11401 
        iprot.skip(ftype)
11402 
      iprot.readFieldEnd()
11403 
    iprot.readStructEnd()
11404 
 
11405 
  def write(self, oprot):
11406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11408 
      return
3064 chandransh 11409 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11410 
    if self.success is not None:
483 rajveer 11411 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11412 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11413 
      for iter210 in self.success:
11414 
        iter210.write(oprot)
483 rajveer 11415 
      oprot.writeListEnd()
94 ashish 11416 
      oprot.writeFieldEnd()
3431 rajveer 11417 
    if self.ex is not None:
94 ashish 11418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11419 
      self.ex.write(oprot)
11420 
      oprot.writeFieldEnd()
11421 
    oprot.writeFieldStop()
11422 
    oprot.writeStructEnd()
11423 
 
3431 rajveer 11424 
  def validate(self):
11425 
    return
11426 
 
11427 
 
94 ashish 11428 
  def __repr__(self):
11429 
    L = ['%s=%r' % (key, value)
11430 
      for key, value in self.__dict__.iteritems()]
11431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11432 
 
11433 
  def __eq__(self, other):
11434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11435 
 
11436 
  def __ne__(self, other):
11437 
    return not (self == other)
11438 
 
4999 phani.kuma 11439 
class getOrderList_args:
11440 
  """
11441 
  Attributes:
11442 
   - order_ids
11443 
  """
11444 
 
11445 
  thrift_spec = (
11446 
    None, # 0
11447 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11448 
  )
11449 
 
11450 
  def __init__(self, order_ids=None,):
11451 
    self.order_ids = order_ids
11452 
 
11453 
  def read(self, iprot):
11454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11456 
      return
11457 
    iprot.readStructBegin()
11458 
    while True:
11459 
      (fname, ftype, fid) = iprot.readFieldBegin()
11460 
      if ftype == TType.STOP:
11461 
        break
11462 
      if fid == 1:
11463 
        if ftype == TType.LIST:
11464 
          self.order_ids = []
6188 rajveer 11465 
          (_etype214, _size211) = iprot.readListBegin()
11466 
          for _i215 in xrange(_size211):
11467 
            _elem216 = iprot.readI64();
11468 
            self.order_ids.append(_elem216)
4999 phani.kuma 11469 
          iprot.readListEnd()
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      else:
11473 
        iprot.skip(ftype)
11474 
      iprot.readFieldEnd()
11475 
    iprot.readStructEnd()
11476 
 
11477 
  def write(self, oprot):
11478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11480 
      return
11481 
    oprot.writeStructBegin('getOrderList_args')
11482 
    if self.order_ids is not None:
11483 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11484 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11485 
      for iter217 in self.order_ids:
11486 
        oprot.writeI64(iter217)
4999 phani.kuma 11487 
      oprot.writeListEnd()
11488 
      oprot.writeFieldEnd()
11489 
    oprot.writeFieldStop()
11490 
    oprot.writeStructEnd()
11491 
 
11492 
  def validate(self):
11493 
    return
11494 
 
11495 
 
11496 
  def __repr__(self):
11497 
    L = ['%s=%r' % (key, value)
11498 
      for key, value in self.__dict__.iteritems()]
11499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11500 
 
11501 
  def __eq__(self, other):
11502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11503 
 
11504 
  def __ne__(self, other):
11505 
    return not (self == other)
11506 
 
11507 
class getOrderList_result:
11508 
  """
11509 
  Attributes:
11510 
   - success
11511 
  """
11512 
 
11513 
  thrift_spec = (
11514 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11515 
  )
11516 
 
11517 
  def __init__(self, success=None,):
11518 
    self.success = success
11519 
 
11520 
  def read(self, iprot):
11521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11523 
      return
11524 
    iprot.readStructBegin()
11525 
    while True:
11526 
      (fname, ftype, fid) = iprot.readFieldBegin()
11527 
      if ftype == TType.STOP:
11528 
        break
11529 
      if fid == 0:
11530 
        if ftype == TType.LIST:
11531 
          self.success = []
6188 rajveer 11532 
          (_etype221, _size218) = iprot.readListBegin()
11533 
          for _i222 in xrange(_size218):
11534 
            _elem223 = Order()
11535 
            _elem223.read(iprot)
11536 
            self.success.append(_elem223)
4999 phani.kuma 11537 
          iprot.readListEnd()
11538 
        else:
11539 
          iprot.skip(ftype)
11540 
      else:
11541 
        iprot.skip(ftype)
11542 
      iprot.readFieldEnd()
11543 
    iprot.readStructEnd()
11544 
 
11545 
  def write(self, oprot):
11546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11548 
      return
11549 
    oprot.writeStructBegin('getOrderList_result')
11550 
    if self.success is not None:
11551 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11552 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11553 
      for iter224 in self.success:
11554 
        iter224.write(oprot)
4999 phani.kuma 11555 
      oprot.writeListEnd()
11556 
      oprot.writeFieldEnd()
11557 
    oprot.writeFieldStop()
11558 
    oprot.writeStructEnd()
11559 
 
11560 
  def validate(self):
11561 
    return
11562 
 
11563 
 
11564 
  def __repr__(self):
11565 
    L = ['%s=%r' % (key, value)
11566 
      for key, value in self.__dict__.iteritems()]
11567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11568 
 
11569 
  def __eq__(self, other):
11570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11571 
 
11572 
  def __ne__(self, other):
11573 
    return not (self == other)
11574 
 
5386 phani.kuma 11575 
class getOrderListForVendor_args:
11576 
  """
11577 
  Attributes:
11578 
   - order_ids
11579 
   - vendorId
11580 
  """
11581 
 
11582 
  thrift_spec = (
11583 
    None, # 0
11584 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11585 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11586 
  )
11587 
 
11588 
  def __init__(self, order_ids=None, vendorId=None,):
11589 
    self.order_ids = order_ids
11590 
    self.vendorId = vendorId
11591 
 
11592 
  def read(self, iprot):
11593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11595 
      return
11596 
    iprot.readStructBegin()
11597 
    while True:
11598 
      (fname, ftype, fid) = iprot.readFieldBegin()
11599 
      if ftype == TType.STOP:
11600 
        break
11601 
      if fid == 1:
11602 
        if ftype == TType.LIST:
11603 
          self.order_ids = []
6188 rajveer 11604 
          (_etype228, _size225) = iprot.readListBegin()
11605 
          for _i229 in xrange(_size225):
11606 
            _elem230 = iprot.readI64();
11607 
            self.order_ids.append(_elem230)
5386 phani.kuma 11608 
          iprot.readListEnd()
11609 
        else:
11610 
          iprot.skip(ftype)
11611 
      elif fid == 2:
11612 
        if ftype == TType.I64:
11613 
          self.vendorId = iprot.readI64();
11614 
        else:
11615 
          iprot.skip(ftype)
11616 
      else:
11617 
        iprot.skip(ftype)
11618 
      iprot.readFieldEnd()
11619 
    iprot.readStructEnd()
11620 
 
11621 
  def write(self, oprot):
11622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11624 
      return
11625 
    oprot.writeStructBegin('getOrderListForVendor_args')
11626 
    if self.order_ids is not None:
11627 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11628 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11629 
      for iter231 in self.order_ids:
11630 
        oprot.writeI64(iter231)
5386 phani.kuma 11631 
      oprot.writeListEnd()
11632 
      oprot.writeFieldEnd()
11633 
    if self.vendorId is not None:
11634 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11635 
      oprot.writeI64(self.vendorId)
11636 
      oprot.writeFieldEnd()
11637 
    oprot.writeFieldStop()
11638 
    oprot.writeStructEnd()
11639 
 
11640 
  def validate(self):
11641 
    return
11642 
 
11643 
 
11644 
  def __repr__(self):
11645 
    L = ['%s=%r' % (key, value)
11646 
      for key, value in self.__dict__.iteritems()]
11647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11648 
 
11649 
  def __eq__(self, other):
11650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11651 
 
11652 
  def __ne__(self, other):
11653 
    return not (self == other)
11654 
 
11655 
class getOrderListForVendor_result:
11656 
  """
11657 
  Attributes:
11658 
   - success
11659 
  """
11660 
 
11661 
  thrift_spec = (
11662 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11663 
  )
11664 
 
11665 
  def __init__(self, success=None,):
11666 
    self.success = success
11667 
 
11668 
  def read(self, iprot):
11669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11671 
      return
11672 
    iprot.readStructBegin()
11673 
    while True:
11674 
      (fname, ftype, fid) = iprot.readFieldBegin()
11675 
      if ftype == TType.STOP:
11676 
        break
11677 
      if fid == 0:
11678 
        if ftype == TType.LIST:
11679 
          self.success = []
6188 rajveer 11680 
          (_etype235, _size232) = iprot.readListBegin()
11681 
          for _i236 in xrange(_size232):
11682 
            _elem237 = Order()
11683 
            _elem237.read(iprot)
11684 
            self.success.append(_elem237)
5386 phani.kuma 11685 
          iprot.readListEnd()
11686 
        else:
11687 
          iprot.skip(ftype)
11688 
      else:
11689 
        iprot.skip(ftype)
11690 
      iprot.readFieldEnd()
11691 
    iprot.readStructEnd()
11692 
 
11693 
  def write(self, oprot):
11694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11696 
      return
11697 
    oprot.writeStructBegin('getOrderListForVendor_result')
11698 
    if self.success is not None:
11699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11701 
      for iter238 in self.success:
11702 
        iter238.write(oprot)
5386 phani.kuma 11703 
      oprot.writeListEnd()
11704 
      oprot.writeFieldEnd()
11705 
    oprot.writeFieldStop()
11706 
    oprot.writeStructEnd()
11707 
 
11708 
  def validate(self):
11709 
    return
11710 
 
11711 
 
11712 
  def __repr__(self):
11713 
    L = ['%s=%r' % (key, value)
11714 
      for key, value in self.__dict__.iteritems()]
11715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11716 
 
11717 
  def __eq__(self, other):
11718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11719 
 
11720 
  def __ne__(self, other):
11721 
    return not (self == other)
11722 
 
3064 chandransh 11723 
class getOrderForCustomer_args:
94 ashish 11724 
  """
11725 
  Attributes:
3064 chandransh 11726 
   - orderId
483 rajveer 11727 
   - customerId
94 ashish 11728 
  """
11729 
 
11730 
  thrift_spec = (
11731 
    None, # 0
3064 chandransh 11732 
    (1, TType.I64, 'orderId', None, None, ), # 1
11733 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11734 
  )
11735 
 
3064 chandransh 11736 
  def __init__(self, orderId=None, customerId=None,):
11737 
    self.orderId = orderId
483 rajveer 11738 
    self.customerId = customerId
94 ashish 11739 
 
11740 
  def read(self, iprot):
11741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11743 
      return
11744 
    iprot.readStructBegin()
11745 
    while True:
11746 
      (fname, ftype, fid) = iprot.readFieldBegin()
11747 
      if ftype == TType.STOP:
11748 
        break
11749 
      if fid == 1:
11750 
        if ftype == TType.I64:
3064 chandransh 11751 
          self.orderId = iprot.readI64();
94 ashish 11752 
        else:
11753 
          iprot.skip(ftype)
11754 
      elif fid == 2:
11755 
        if ftype == TType.I64:
3064 chandransh 11756 
          self.customerId = iprot.readI64();
94 ashish 11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      else:
11760 
        iprot.skip(ftype)
11761 
      iprot.readFieldEnd()
11762 
    iprot.readStructEnd()
11763 
 
11764 
  def write(self, oprot):
11765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11767 
      return
3064 chandransh 11768 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11769 
    if self.orderId is not None:
3064 chandransh 11770 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11771 
      oprot.writeI64(self.orderId)
11772 
      oprot.writeFieldEnd()
3431 rajveer 11773 
    if self.customerId is not None:
3064 chandransh 11774 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11775 
      oprot.writeI64(self.customerId)
94 ashish 11776 
      oprot.writeFieldEnd()
11777 
    oprot.writeFieldStop()
11778 
    oprot.writeStructEnd()
11779 
 
3431 rajveer 11780 
  def validate(self):
11781 
    return
11782 
 
11783 
 
94 ashish 11784 
  def __repr__(self):
11785 
    L = ['%s=%r' % (key, value)
11786 
      for key, value in self.__dict__.iteritems()]
11787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11788 
 
11789 
  def __eq__(self, other):
11790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11791 
 
11792 
  def __ne__(self, other):
11793 
    return not (self == other)
11794 
 
3064 chandransh 11795 
class getOrderForCustomer_result:
94 ashish 11796 
  """
11797 
  Attributes:
11798 
   - success
11799 
   - ex
11800 
  """
11801 
 
11802 
  thrift_spec = (
3064 chandransh 11803 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11805 
  )
11806 
 
11807 
  def __init__(self, success=None, ex=None,):
11808 
    self.success = success
11809 
    self.ex = ex
11810 
 
11811 
  def read(self, iprot):
11812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11814 
      return
11815 
    iprot.readStructBegin()
11816 
    while True:
11817 
      (fname, ftype, fid) = iprot.readFieldBegin()
11818 
      if ftype == TType.STOP:
11819 
        break
11820 
      if fid == 0:
3064 chandransh 11821 
        if ftype == TType.STRUCT:
11822 
          self.success = Order()
11823 
          self.success.read(iprot)
94 ashish 11824 
        else:
11825 
          iprot.skip(ftype)
11826 
      elif fid == 1:
11827 
        if ftype == TType.STRUCT:
11828 
          self.ex = TransactionServiceException()
11829 
          self.ex.read(iprot)
11830 
        else:
11831 
          iprot.skip(ftype)
11832 
      else:
11833 
        iprot.skip(ftype)
11834 
      iprot.readFieldEnd()
11835 
    iprot.readStructEnd()
11836 
 
11837 
  def write(self, oprot):
11838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11840 
      return
3064 chandransh 11841 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11842 
    if self.success is not None:
3064 chandransh 11843 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11844 
      self.success.write(oprot)
94 ashish 11845 
      oprot.writeFieldEnd()
3431 rajveer 11846 
    if self.ex is not None:
94 ashish 11847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11848 
      self.ex.write(oprot)
11849 
      oprot.writeFieldEnd()
11850 
    oprot.writeFieldStop()
11851 
    oprot.writeStructEnd()
11852 
 
3431 rajveer 11853 
  def validate(self):
11854 
    return
11855 
 
11856 
 
94 ashish 11857 
  def __repr__(self):
11858 
    L = ['%s=%r' % (key, value)
11859 
      for key, value in self.__dict__.iteritems()]
11860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11861 
 
11862 
  def __eq__(self, other):
11863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11864 
 
11865 
  def __ne__(self, other):
11866 
    return not (self == other)
11867 
 
3064 chandransh 11868 
class getAlerts_args:
94 ashish 11869 
  """
11870 
  Attributes:
4394 rajveer 11871 
   - type
4444 rajveer 11872 
   - warehouseId
4394 rajveer 11873 
   - status
11874 
   - timestamp
94 ashish 11875 
  """
11876 
 
11877 
  thrift_spec = (
11878 
    None, # 0
4394 rajveer 11879 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11880 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11881 
    (3, TType.I64, 'status', None, None, ), # 3
11882 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11883 
  )
11884 
 
4444 rajveer 11885 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11886 
    self.type = type
4444 rajveer 11887 
    self.warehouseId = warehouseId
4394 rajveer 11888 
    self.status = status
11889 
    self.timestamp = timestamp
94 ashish 11890 
 
11891 
  def read(self, iprot):
11892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11894 
      return
11895 
    iprot.readStructBegin()
11896 
    while True:
11897 
      (fname, ftype, fid) = iprot.readFieldBegin()
11898 
      if ftype == TType.STOP:
11899 
        break
11900 
      if fid == 1:
3064 chandransh 11901 
        if ftype == TType.I64:
4394 rajveer 11902 
          self.type = iprot.readI64();
94 ashish 11903 
        else:
11904 
          iprot.skip(ftype)
3064 chandransh 11905 
      elif fid == 2:
4394 rajveer 11906 
        if ftype == TType.I64:
4444 rajveer 11907 
          self.warehouseId = iprot.readI64();
3064 chandransh 11908 
        else:
11909 
          iprot.skip(ftype)
4394 rajveer 11910 
      elif fid == 3:
11911 
        if ftype == TType.I64:
4444 rajveer 11912 
          self.status = iprot.readI64();
11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      elif fid == 4:
11916 
        if ftype == TType.I64:
4394 rajveer 11917 
          self.timestamp = iprot.readI64();
11918 
        else:
11919 
          iprot.skip(ftype)
94 ashish 11920 
      else:
11921 
        iprot.skip(ftype)
11922 
      iprot.readFieldEnd()
11923 
    iprot.readStructEnd()
11924 
 
11925 
  def write(self, oprot):
11926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11928 
      return
3064 chandransh 11929 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11930 
    if self.type is not None:
11931 
      oprot.writeFieldBegin('type', TType.I64, 1)
11932 
      oprot.writeI64(self.type)
94 ashish 11933 
      oprot.writeFieldEnd()
4444 rajveer 11934 
    if self.warehouseId is not None:
11935 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11936 
      oprot.writeI64(self.warehouseId)
11937 
      oprot.writeFieldEnd()
4394 rajveer 11938 
    if self.status is not None:
4444 rajveer 11939 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11940 
      oprot.writeI64(self.status)
3064 chandransh 11941 
      oprot.writeFieldEnd()
4394 rajveer 11942 
    if self.timestamp is not None:
4444 rajveer 11943 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11944 
      oprot.writeI64(self.timestamp)
11945 
      oprot.writeFieldEnd()
94 ashish 11946 
    oprot.writeFieldStop()
11947 
    oprot.writeStructEnd()
11948 
 
3431 rajveer 11949 
  def validate(self):
11950 
    return
11951 
 
11952 
 
94 ashish 11953 
  def __repr__(self):
11954 
    L = ['%s=%r' % (key, value)
11955 
      for key, value in self.__dict__.iteritems()]
11956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11957 
 
11958 
  def __eq__(self, other):
11959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11960 
 
11961 
  def __ne__(self, other):
11962 
    return not (self == other)
11963 
 
3064 chandransh 11964 
class getAlerts_result:
94 ashish 11965 
  """
11966 
  Attributes:
11967 
   - success
11968 
  """
11969 
 
11970 
  thrift_spec = (
3064 chandransh 11971 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11972 
  )
11973 
 
3064 chandransh 11974 
  def __init__(self, success=None,):
94 ashish 11975 
    self.success = success
11976 
 
11977 
  def read(self, iprot):
11978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11980 
      return
11981 
    iprot.readStructBegin()
11982 
    while True:
11983 
      (fname, ftype, fid) = iprot.readFieldBegin()
11984 
      if ftype == TType.STOP:
11985 
        break
11986 
      if fid == 0:
3064 chandransh 11987 
        if ftype == TType.LIST:
11988 
          self.success = []
6188 rajveer 11989 
          (_etype242, _size239) = iprot.readListBegin()
11990 
          for _i243 in xrange(_size239):
11991 
            _elem244 = Alert()
11992 
            _elem244.read(iprot)
11993 
            self.success.append(_elem244)
3064 chandransh 11994 
          iprot.readListEnd()
94 ashish 11995 
        else:
11996 
          iprot.skip(ftype)
11997 
      else:
11998 
        iprot.skip(ftype)
11999 
      iprot.readFieldEnd()
12000 
    iprot.readStructEnd()
12001 
 
12002 
  def write(self, oprot):
12003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12005 
      return
3064 chandransh 12006 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12007 
    if self.success is not None:
3064 chandransh 12008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12010 
      for iter245 in self.success:
12011 
        iter245.write(oprot)
3064 chandransh 12012 
      oprot.writeListEnd()
94 ashish 12013 
      oprot.writeFieldEnd()
12014 
    oprot.writeFieldStop()
12015 
    oprot.writeStructEnd()
12016 
 
3431 rajveer 12017 
  def validate(self):
12018 
    return
12019 
 
12020 
 
94 ashish 12021 
  def __repr__(self):
12022 
    L = ['%s=%r' % (key, value)
12023 
      for key, value in self.__dict__.iteritems()]
12024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12025 
 
12026 
  def __eq__(self, other):
12027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12028 
 
12029 
  def __ne__(self, other):
12030 
    return not (self == other)
12031 
 
4394 rajveer 12032 
class addAlert_args:
94 ashish 12033 
  """
12034 
  Attributes:
3064 chandransh 12035 
   - type
4444 rajveer 12036 
   - warehouseId
4394 rajveer 12037 
   - description
94 ashish 12038 
  """
12039 
 
12040 
  thrift_spec = (
12041 
    None, # 0
4394 rajveer 12042 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12043 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12044 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12045 
  )
12046 
 
4444 rajveer 12047 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12048 
    self.type = type
4444 rajveer 12049 
    self.warehouseId = warehouseId
4394 rajveer 12050 
    self.description = description
94 ashish 12051 
 
12052 
  def read(self, iprot):
12053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12055 
      return
12056 
    iprot.readStructBegin()
12057 
    while True:
12058 
      (fname, ftype, fid) = iprot.readFieldBegin()
12059 
      if ftype == TType.STOP:
12060 
        break
12061 
      if fid == 1:
12062 
        if ftype == TType.I64:
4394 rajveer 12063 
          self.type = iprot.readI64();
94 ashish 12064 
        else:
12065 
          iprot.skip(ftype)
3064 chandransh 12066 
      elif fid == 2:
4444 rajveer 12067 
        if ftype == TType.I64:
12068 
          self.warehouseId = iprot.readI64();
12069 
        else:
12070 
          iprot.skip(ftype)
12071 
      elif fid == 3:
3064 chandransh 12072 
        if ftype == TType.STRING:
4394 rajveer 12073 
          self.description = iprot.readString();
3064 chandransh 12074 
        else:
12075 
          iprot.skip(ftype)
94 ashish 12076 
      else:
12077 
        iprot.skip(ftype)
12078 
      iprot.readFieldEnd()
12079 
    iprot.readStructEnd()
12080 
 
12081 
  def write(self, oprot):
12082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12084 
      return
4394 rajveer 12085 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12086 
    if self.type is not None:
4394 rajveer 12087 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12088 
      oprot.writeI64(self.type)
12089 
      oprot.writeFieldEnd()
4444 rajveer 12090 
    if self.warehouseId is not None:
12091 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12092 
      oprot.writeI64(self.warehouseId)
12093 
      oprot.writeFieldEnd()
4394 rajveer 12094 
    if self.description is not None:
4444 rajveer 12095 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12096 
      oprot.writeString(self.description)
3064 chandransh 12097 
      oprot.writeFieldEnd()
94 ashish 12098 
    oprot.writeFieldStop()
12099 
    oprot.writeStructEnd()
12100 
 
3431 rajveer 12101 
  def validate(self):
12102 
    return
12103 
 
12104 
 
94 ashish 12105 
  def __repr__(self):
12106 
    L = ['%s=%r' % (key, value)
12107 
      for key, value in self.__dict__.iteritems()]
12108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12109 
 
12110 
  def __eq__(self, other):
12111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12112 
 
12113 
  def __ne__(self, other):
12114 
    return not (self == other)
12115 
 
4394 rajveer 12116 
class addAlert_result:
3064 chandransh 12117 
 
12118 
  thrift_spec = (
12119 
  )
12120 
 
12121 
  def read(self, iprot):
12122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12124 
      return
12125 
    iprot.readStructBegin()
12126 
    while True:
12127 
      (fname, ftype, fid) = iprot.readFieldBegin()
12128 
      if ftype == TType.STOP:
12129 
        break
12130 
      else:
12131 
        iprot.skip(ftype)
12132 
      iprot.readFieldEnd()
12133 
    iprot.readStructEnd()
12134 
 
12135 
  def write(self, oprot):
12136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12138 
      return
4394 rajveer 12139 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12140 
    oprot.writeFieldStop()
12141 
    oprot.writeStructEnd()
12142 
 
3431 rajveer 12143 
  def validate(self):
12144 
    return
12145 
 
12146 
 
3064 chandransh 12147 
  def __repr__(self):
12148 
    L = ['%s=%r' % (key, value)
12149 
      for key, value in self.__dict__.iteritems()]
12150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12151 
 
12152 
  def __eq__(self, other):
12153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12154 
 
12155 
  def __ne__(self, other):
12156 
    return not (self == other)
12157 
 
4444 rajveer 12158 
class markAlertsAsSeen_args:
12159 
  """
12160 
  Attributes:
12161 
   - warehouseId
12162 
  """
12163 
 
12164 
  thrift_spec = (
12165 
    None, # 0
12166 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12167 
  )
12168 
 
12169 
  def __init__(self, warehouseId=None,):
12170 
    self.warehouseId = warehouseId
12171 
 
12172 
  def read(self, iprot):
12173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12175 
      return
12176 
    iprot.readStructBegin()
12177 
    while True:
12178 
      (fname, ftype, fid) = iprot.readFieldBegin()
12179 
      if ftype == TType.STOP:
12180 
        break
12181 
      if fid == 1:
12182 
        if ftype == TType.I64:
12183 
          self.warehouseId = iprot.readI64();
12184 
        else:
12185 
          iprot.skip(ftype)
12186 
      else:
12187 
        iprot.skip(ftype)
12188 
      iprot.readFieldEnd()
12189 
    iprot.readStructEnd()
12190 
 
12191 
  def write(self, oprot):
12192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12194 
      return
12195 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12196 
    if self.warehouseId is not None:
12197 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12198 
      oprot.writeI64(self.warehouseId)
12199 
      oprot.writeFieldEnd()
12200 
    oprot.writeFieldStop()
12201 
    oprot.writeStructEnd()
12202 
 
12203 
  def validate(self):
12204 
    return
12205 
 
12206 
 
12207 
  def __repr__(self):
12208 
    L = ['%s=%r' % (key, value)
12209 
      for key, value in self.__dict__.iteritems()]
12210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12211 
 
12212 
  def __eq__(self, other):
12213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12214 
 
12215 
  def __ne__(self, other):
12216 
    return not (self == other)
12217 
 
12218 
class markAlertsAsSeen_result:
12219 
 
12220 
  thrift_spec = (
12221 
  )
12222 
 
12223 
  def read(self, iprot):
12224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12226 
      return
12227 
    iprot.readStructBegin()
12228 
    while True:
12229 
      (fname, ftype, fid) = iprot.readFieldBegin()
12230 
      if ftype == TType.STOP:
12231 
        break
12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
12241 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12242 
    oprot.writeFieldStop()
12243 
    oprot.writeStructEnd()
12244 
 
12245 
  def validate(self):
12246 
    return
12247 
 
12248 
 
12249 
  def __repr__(self):
12250 
    L = ['%s=%r' % (key, value)
12251 
      for key, value in self.__dict__.iteritems()]
12252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12253 
 
12254 
  def __eq__(self, other):
12255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12256 
 
12257 
  def __ne__(self, other):
12258 
    return not (self == other)
12259 
 
3064 chandransh 12260 
class getValidOrderCount_args:
12261 
 
12262 
  thrift_spec = (
12263 
  )
12264 
 
12265 
  def read(self, iprot):
12266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12268 
      return
12269 
    iprot.readStructBegin()
12270 
    while True:
12271 
      (fname, ftype, fid) = iprot.readFieldBegin()
12272 
      if ftype == TType.STOP:
12273 
        break
12274 
      else:
12275 
        iprot.skip(ftype)
12276 
      iprot.readFieldEnd()
12277 
    iprot.readStructEnd()
12278 
 
12279 
  def write(self, oprot):
12280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12282 
      return
12283 
    oprot.writeStructBegin('getValidOrderCount_args')
12284 
    oprot.writeFieldStop()
12285 
    oprot.writeStructEnd()
12286 
 
3431 rajveer 12287 
  def validate(self):
12288 
    return
12289 
 
12290 
 
3064 chandransh 12291 
  def __repr__(self):
12292 
    L = ['%s=%r' % (key, value)
12293 
      for key, value in self.__dict__.iteritems()]
12294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12295 
 
12296 
  def __eq__(self, other):
12297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12298 
 
12299 
  def __ne__(self, other):
12300 
    return not (self == other)
12301 
 
12302 
class getValidOrderCount_result:
94 ashish 12303 
  """
12304 
  Attributes:
12305 
   - success
12306 
  """
12307 
 
12308 
  thrift_spec = (
3064 chandransh 12309 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12310 
  )
12311 
 
3064 chandransh 12312 
  def __init__(self, success=None,):
94 ashish 12313 
    self.success = success
12314 
 
12315 
  def read(self, iprot):
12316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12318 
      return
12319 
    iprot.readStructBegin()
12320 
    while True:
12321 
      (fname, ftype, fid) = iprot.readFieldBegin()
12322 
      if ftype == TType.STOP:
12323 
        break
12324 
      if fid == 0:
3064 chandransh 12325 
        if ftype == TType.I64:
12326 
          self.success = iprot.readI64();
94 ashish 12327 
        else:
12328 
          iprot.skip(ftype)
12329 
      else:
12330 
        iprot.skip(ftype)
12331 
      iprot.readFieldEnd()
12332 
    iprot.readStructEnd()
12333 
 
12334 
  def write(self, oprot):
12335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12337 
      return
3064 chandransh 12338 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12339 
    if self.success is not None:
3064 chandransh 12340 
      oprot.writeFieldBegin('success', TType.I64, 0)
12341 
      oprot.writeI64(self.success)
94 ashish 12342 
      oprot.writeFieldEnd()
12343 
    oprot.writeFieldStop()
12344 
    oprot.writeStructEnd()
12345 
 
3431 rajveer 12346 
  def validate(self):
12347 
    return
12348 
 
12349 
 
94 ashish 12350 
  def __repr__(self):
12351 
    L = ['%s=%r' % (key, value)
12352 
      for key, value in self.__dict__.iteritems()]
12353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12354 
 
12355 
  def __eq__(self, other):
12356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12357 
 
12358 
  def __ne__(self, other):
12359 
    return not (self == other)
12360 
 
3064 chandransh 12361 
class getNoOfCustomersWithSuccessfulTransaction_args:
12362 
 
12363 
  thrift_spec = (
12364 
  )
12365 
 
12366 
  def read(self, iprot):
12367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12369 
      return
12370 
    iprot.readStructBegin()
12371 
    while True:
12372 
      (fname, ftype, fid) = iprot.readFieldBegin()
12373 
      if ftype == TType.STOP:
12374 
        break
12375 
      else:
12376 
        iprot.skip(ftype)
12377 
      iprot.readFieldEnd()
12378 
    iprot.readStructEnd()
12379 
 
12380 
  def write(self, oprot):
12381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12383 
      return
12384 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12385 
    oprot.writeFieldStop()
12386 
    oprot.writeStructEnd()
12387 
 
3431 rajveer 12388 
  def validate(self):
12389 
    return
12390 
 
12391 
 
3064 chandransh 12392 
  def __repr__(self):
12393 
    L = ['%s=%r' % (key, value)
12394 
      for key, value in self.__dict__.iteritems()]
12395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12396 
 
12397 
  def __eq__(self, other):
12398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12399 
 
12400 
  def __ne__(self, other):
12401 
    return not (self == other)
12402 
 
12403 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12404 
  """
12405 
  Attributes:
3064 chandransh 12406 
   - success
94 ashish 12407 
  """
12408 
 
12409 
  thrift_spec = (
3064 chandransh 12410 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12411 
  )
12412 
 
3064 chandransh 12413 
  def __init__(self, success=None,):
12414 
    self.success = success
94 ashish 12415 
 
12416 
  def read(self, iprot):
12417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12419 
      return
12420 
    iprot.readStructBegin()
12421 
    while True:
12422 
      (fname, ftype, fid) = iprot.readFieldBegin()
12423 
      if ftype == TType.STOP:
12424 
        break
3064 chandransh 12425 
      if fid == 0:
94 ashish 12426 
        if ftype == TType.I64:
3064 chandransh 12427 
          self.success = iprot.readI64();
94 ashish 12428 
        else:
12429 
          iprot.skip(ftype)
12430 
      else:
12431 
        iprot.skip(ftype)
12432 
      iprot.readFieldEnd()
12433 
    iprot.readStructEnd()
12434 
 
12435 
  def write(self, oprot):
12436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12438 
      return
3064 chandransh 12439 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12440 
    if self.success is not None:
3064 chandransh 12441 
      oprot.writeFieldBegin('success', TType.I64, 0)
12442 
      oprot.writeI64(self.success)
94 ashish 12443 
      oprot.writeFieldEnd()
12444 
    oprot.writeFieldStop()
12445 
    oprot.writeStructEnd()
12446 
 
3431 rajveer 12447 
  def validate(self):
12448 
    return
12449 
 
12450 
 
94 ashish 12451 
  def __repr__(self):
12452 
    L = ['%s=%r' % (key, value)
12453 
      for key, value in self.__dict__.iteritems()]
12454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12455 
 
12456 
  def __eq__(self, other):
12457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12458 
 
12459 
  def __ne__(self, other):
12460 
    return not (self == other)
12461 
 
3064 chandransh 12462 
class getValidOrdersAmountRange_args:
12463 
 
12464 
  thrift_spec = (
12465 
  )
12466 
 
12467 
  def read(self, iprot):
12468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12470 
      return
12471 
    iprot.readStructBegin()
12472 
    while True:
12473 
      (fname, ftype, fid) = iprot.readFieldBegin()
12474 
      if ftype == TType.STOP:
12475 
        break
12476 
      else:
12477 
        iprot.skip(ftype)
12478 
      iprot.readFieldEnd()
12479 
    iprot.readStructEnd()
12480 
 
12481 
  def write(self, oprot):
12482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12484 
      return
12485 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12486 
    oprot.writeFieldStop()
12487 
    oprot.writeStructEnd()
12488 
 
3431 rajveer 12489 
  def validate(self):
12490 
    return
12491 
 
12492 
 
3064 chandransh 12493 
  def __repr__(self):
12494 
    L = ['%s=%r' % (key, value)
12495 
      for key, value in self.__dict__.iteritems()]
12496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12497 
 
12498 
  def __eq__(self, other):
12499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12500 
 
12501 
  def __ne__(self, other):
12502 
    return not (self == other)
12503 
 
12504 
class getValidOrdersAmountRange_result:
94 ashish 12505 
  """
12506 
  Attributes:
12507 
   - success
12508 
  """
12509 
 
12510 
  thrift_spec = (
3064 chandransh 12511 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12512 
  )
12513 
 
3064 chandransh 12514 
  def __init__(self, success=None,):
94 ashish 12515 
    self.success = success
12516 
 
12517 
  def read(self, iprot):
12518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12520 
      return
12521 
    iprot.readStructBegin()
12522 
    while True:
12523 
      (fname, ftype, fid) = iprot.readFieldBegin()
12524 
      if ftype == TType.STOP:
12525 
        break
12526 
      if fid == 0:
483 rajveer 12527 
        if ftype == TType.LIST:
12528 
          self.success = []
6188 rajveer 12529 
          (_etype249, _size246) = iprot.readListBegin()
12530 
          for _i250 in xrange(_size246):
12531 
            _elem251 = iprot.readDouble();
12532 
            self.success.append(_elem251)
483 rajveer 12533 
          iprot.readListEnd()
94 ashish 12534 
        else:
12535 
          iprot.skip(ftype)
12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
3064 chandransh 12545 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12546 
    if self.success is not None:
483 rajveer 12547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12548 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12549 
      for iter252 in self.success:
12550 
        oprot.writeDouble(iter252)
483 rajveer 12551 
      oprot.writeListEnd()
94 ashish 12552 
      oprot.writeFieldEnd()
12553 
    oprot.writeFieldStop()
12554 
    oprot.writeStructEnd()
12555 
 
3431 rajveer 12556 
  def validate(self):
12557 
    return
12558 
 
12559 
 
94 ashish 12560 
  def __repr__(self):
12561 
    L = ['%s=%r' % (key, value)
12562 
      for key, value in self.__dict__.iteritems()]
12563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12564 
 
12565 
  def __eq__(self, other):
12566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12567 
 
12568 
  def __ne__(self, other):
12569 
    return not (self == other)
12570 
 
3064 chandransh 12571 
class getValidOrders_args:
1528 ankur.sing 12572 
  """
12573 
  Attributes:
3064 chandransh 12574 
   - limit
5874 rajveer 12575 
   - onlyStore
1528 ankur.sing 12576 
  """
12577 
 
12578 
  thrift_spec = (
12579 
    None, # 0
3064 chandransh 12580 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12581 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12582 
  )
12583 
 
5874 rajveer 12584 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12585 
    self.limit = limit
5874 rajveer 12586 
    self.onlyStore = onlyStore
1528 ankur.sing 12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
12597 
      if fid == 1:
12598 
        if ftype == TType.I64:
3064 chandransh 12599 
          self.limit = iprot.readI64();
1528 ankur.sing 12600 
        else:
12601 
          iprot.skip(ftype)
5874 rajveer 12602 
      elif fid == 2:
12603 
        if ftype == TType.BOOL:
12604 
          self.onlyStore = iprot.readBool();
12605 
        else:
12606 
          iprot.skip(ftype)
1528 ankur.sing 12607 
      else:
12608 
        iprot.skip(ftype)
12609 
      iprot.readFieldEnd()
12610 
    iprot.readStructEnd()
12611 
 
12612 
  def write(self, oprot):
12613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12615 
      return
3064 chandransh 12616 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12617 
    if self.limit is not None:
3064 chandransh 12618 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12619 
      oprot.writeI64(self.limit)
1528 ankur.sing 12620 
      oprot.writeFieldEnd()
5874 rajveer 12621 
    if self.onlyStore is not None:
12622 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12623 
      oprot.writeBool(self.onlyStore)
12624 
      oprot.writeFieldEnd()
1528 ankur.sing 12625 
    oprot.writeFieldStop()
12626 
    oprot.writeStructEnd()
12627 
 
3431 rajveer 12628 
  def validate(self):
12629 
    return
12630 
 
12631 
 
1528 ankur.sing 12632 
  def __repr__(self):
12633 
    L = ['%s=%r' % (key, value)
12634 
      for key, value in self.__dict__.iteritems()]
12635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12636 
 
12637 
  def __eq__(self, other):
12638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12639 
 
12640 
  def __ne__(self, other):
12641 
    return not (self == other)
12642 
 
3064 chandransh 12643 
class getValidOrders_result:
1528 ankur.sing 12644 
  """
12645 
  Attributes:
12646 
   - success
12647 
  """
12648 
 
12649 
  thrift_spec = (
3064 chandransh 12650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12651 
  )
12652 
 
3064 chandransh 12653 
  def __init__(self, success=None,):
1528 ankur.sing 12654 
    self.success = success
12655 
 
12656 
  def read(self, iprot):
12657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12659 
      return
12660 
    iprot.readStructBegin()
12661 
    while True:
12662 
      (fname, ftype, fid) = iprot.readFieldBegin()
12663 
      if ftype == TType.STOP:
12664 
        break
12665 
      if fid == 0:
3064 chandransh 12666 
        if ftype == TType.LIST:
12667 
          self.success = []
6188 rajveer 12668 
          (_etype256, _size253) = iprot.readListBegin()
12669 
          for _i257 in xrange(_size253):
12670 
            _elem258 = Order()
12671 
            _elem258.read(iprot)
12672 
            self.success.append(_elem258)
3064 chandransh 12673 
          iprot.readListEnd()
1528 ankur.sing 12674 
        else:
12675 
          iprot.skip(ftype)
12676 
      else:
12677 
        iprot.skip(ftype)
12678 
      iprot.readFieldEnd()
12679 
    iprot.readStructEnd()
12680 
 
12681 
  def write(self, oprot):
12682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12684 
      return
3064 chandransh 12685 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12686 
    if self.success is not None:
3064 chandransh 12687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12688 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12689 
      for iter259 in self.success:
12690 
        iter259.write(oprot)
3064 chandransh 12691 
      oprot.writeListEnd()
1528 ankur.sing 12692 
      oprot.writeFieldEnd()
12693 
    oprot.writeFieldStop()
12694 
    oprot.writeStructEnd()
12695 
 
3431 rajveer 12696 
  def validate(self):
12697 
    return
12698 
 
12699 
 
1528 ankur.sing 12700 
  def __repr__(self):
12701 
    L = ['%s=%r' % (key, value)
12702 
      for key, value in self.__dict__.iteritems()]
12703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12704 
 
12705 
  def __eq__(self, other):
12706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12707 
 
12708 
  def __ne__(self, other):
12709 
    return not (self == other)
12710 
 
1220 chandransh 12711 
class batchOrders_args:
12712 
  """
12713 
  Attributes:
12714 
   - warehouseId
12715 
  """
12716 
 
12717 
  thrift_spec = (
12718 
    None, # 0
12719 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12720 
  )
12721 
 
12722 
  def __init__(self, warehouseId=None,):
12723 
    self.warehouseId = warehouseId
12724 
 
12725 
  def read(self, iprot):
12726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12728 
      return
12729 
    iprot.readStructBegin()
12730 
    while True:
12731 
      (fname, ftype, fid) = iprot.readFieldBegin()
12732 
      if ftype == TType.STOP:
12733 
        break
12734 
      if fid == 1:
12735 
        if ftype == TType.I64:
12736 
          self.warehouseId = iprot.readI64();
12737 
        else:
12738 
          iprot.skip(ftype)
12739 
      else:
12740 
        iprot.skip(ftype)
12741 
      iprot.readFieldEnd()
12742 
    iprot.readStructEnd()
12743 
 
12744 
  def write(self, oprot):
12745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12747 
      return
12748 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12749 
    if self.warehouseId is not None:
1220 chandransh 12750 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12751 
      oprot.writeI64(self.warehouseId)
12752 
      oprot.writeFieldEnd()
12753 
    oprot.writeFieldStop()
12754 
    oprot.writeStructEnd()
12755 
 
3431 rajveer 12756 
  def validate(self):
12757 
    return
12758 
 
12759 
 
1220 chandransh 12760 
  def __repr__(self):
12761 
    L = ['%s=%r' % (key, value)
12762 
      for key, value in self.__dict__.iteritems()]
12763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12764 
 
12765 
  def __eq__(self, other):
12766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12767 
 
12768 
  def __ne__(self, other):
12769 
    return not (self == other)
12770 
 
12771 
class batchOrders_result:
12772 
  """
12773 
  Attributes:
12774 
   - success
12775 
   - ex
12776 
  """
12777 
 
12778 
  thrift_spec = (
12779 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12781 
  )
12782 
 
12783 
  def __init__(self, success=None, ex=None,):
12784 
    self.success = success
12785 
    self.ex = ex
12786 
 
12787 
  def read(self, iprot):
12788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12790 
      return
12791 
    iprot.readStructBegin()
12792 
    while True:
12793 
      (fname, ftype, fid) = iprot.readFieldBegin()
12794 
      if ftype == TType.STOP:
12795 
        break
12796 
      if fid == 0:
12797 
        if ftype == TType.LIST:
12798 
          self.success = []
6188 rajveer 12799 
          (_etype263, _size260) = iprot.readListBegin()
12800 
          for _i264 in xrange(_size260):
12801 
            _elem265 = Order()
12802 
            _elem265.read(iprot)
12803 
            self.success.append(_elem265)
1220 chandransh 12804 
          iprot.readListEnd()
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      elif fid == 1:
12808 
        if ftype == TType.STRUCT:
12809 
          self.ex = TransactionServiceException()
12810 
          self.ex.read(iprot)
12811 
        else:
12812 
          iprot.skip(ftype)
12813 
      else:
12814 
        iprot.skip(ftype)
12815 
      iprot.readFieldEnd()
12816 
    iprot.readStructEnd()
12817 
 
12818 
  def write(self, oprot):
12819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12821 
      return
12822 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12823 
    if self.success is not None:
1220 chandransh 12824 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12825 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12826 
      for iter266 in self.success:
12827 
        iter266.write(oprot)
1220 chandransh 12828 
      oprot.writeListEnd()
12829 
      oprot.writeFieldEnd()
3431 rajveer 12830 
    if self.ex is not None:
1220 chandransh 12831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12832 
      self.ex.write(oprot)
12833 
      oprot.writeFieldEnd()
12834 
    oprot.writeFieldStop()
12835 
    oprot.writeStructEnd()
12836 
 
3431 rajveer 12837 
  def validate(self):
12838 
    return
12839 
 
12840 
 
1220 chandransh 12841 
  def __repr__(self):
12842 
    L = ['%s=%r' % (key, value)
12843 
      for key, value in self.__dict__.iteritems()]
12844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12845 
 
12846 
  def __eq__(self, other):
12847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12848 
 
12849 
  def __ne__(self, other):
12850 
    return not (self == other)
12851 
 
1208 chandransh 12852 
class markOrderAsOutOfStock_args:
12853 
  """
12854 
  Attributes:
12855 
   - orderId
12856 
  """
12857 
 
12858 
  thrift_spec = (
12859 
    None, # 0
12860 
    (1, TType.I64, 'orderId', None, None, ), # 1
12861 
  )
12862 
 
12863 
  def __init__(self, orderId=None,):
12864 
    self.orderId = orderId
12865 
 
12866 
  def read(self, iprot):
12867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12869 
      return
12870 
    iprot.readStructBegin()
12871 
    while True:
12872 
      (fname, ftype, fid) = iprot.readFieldBegin()
12873 
      if ftype == TType.STOP:
12874 
        break
12875 
      if fid == 1:
12876 
        if ftype == TType.I64:
12877 
          self.orderId = iprot.readI64();
12878 
        else:
12879 
          iprot.skip(ftype)
12880 
      else:
12881 
        iprot.skip(ftype)
12882 
      iprot.readFieldEnd()
12883 
    iprot.readStructEnd()
12884 
 
12885 
  def write(self, oprot):
12886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12888 
      return
12889 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12890 
    if self.orderId is not None:
1208 chandransh 12891 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12892 
      oprot.writeI64(self.orderId)
12893 
      oprot.writeFieldEnd()
12894 
    oprot.writeFieldStop()
12895 
    oprot.writeStructEnd()
12896 
 
3431 rajveer 12897 
  def validate(self):
12898 
    return
12899 
 
12900 
 
1208 chandransh 12901 
  def __repr__(self):
12902 
    L = ['%s=%r' % (key, value)
12903 
      for key, value in self.__dict__.iteritems()]
12904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12905 
 
12906 
  def __eq__(self, other):
12907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12908 
 
12909 
  def __ne__(self, other):
12910 
    return not (self == other)
12911 
 
12912 
class markOrderAsOutOfStock_result:
12913 
  """
12914 
  Attributes:
12915 
   - success
12916 
   - ex
12917 
  """
12918 
 
12919 
  thrift_spec = (
12920 
    (0, TType.BOOL, 'success', None, None, ), # 0
12921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12922 
  )
12923 
 
12924 
  def __init__(self, success=None, ex=None,):
12925 
    self.success = success
12926 
    self.ex = ex
12927 
 
12928 
  def read(self, iprot):
12929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12931 
      return
12932 
    iprot.readStructBegin()
12933 
    while True:
12934 
      (fname, ftype, fid) = iprot.readFieldBegin()
12935 
      if ftype == TType.STOP:
12936 
        break
12937 
      if fid == 0:
12938 
        if ftype == TType.BOOL:
12939 
          self.success = iprot.readBool();
12940 
        else:
12941 
          iprot.skip(ftype)
12942 
      elif fid == 1:
12943 
        if ftype == TType.STRUCT:
12944 
          self.ex = TransactionServiceException()
12945 
          self.ex.read(iprot)
12946 
        else:
12947 
          iprot.skip(ftype)
12948 
      else:
12949 
        iprot.skip(ftype)
12950 
      iprot.readFieldEnd()
12951 
    iprot.readStructEnd()
12952 
 
12953 
  def write(self, oprot):
12954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12956 
      return
12957 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12958 
    if self.success is not None:
1208 chandransh 12959 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12960 
      oprot.writeBool(self.success)
12961 
      oprot.writeFieldEnd()
3431 rajveer 12962 
    if self.ex is not None:
1208 chandransh 12963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12964 
      self.ex.write(oprot)
12965 
      oprot.writeFieldEnd()
12966 
    oprot.writeFieldStop()
12967 
    oprot.writeStructEnd()
12968 
 
3431 rajveer 12969 
  def validate(self):
12970 
    return
12971 
 
12972 
 
1208 chandransh 12973 
  def __repr__(self):
12974 
    L = ['%s=%r' % (key, value)
12975 
      for key, value in self.__dict__.iteritems()]
12976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12977 
 
12978 
  def __eq__(self, other):
12979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12980 
 
12981 
  def __ne__(self, other):
12982 
    return not (self == other)
12983 
 
3064 chandransh 12984 
class verifyOrder_args:
759 chandransh 12985 
  """
12986 
  Attributes:
3064 chandransh 12987 
   - orderId
759 chandransh 12988 
  """
12989 
 
12990 
  thrift_spec = (
12991 
    None, # 0
3064 chandransh 12992 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12993 
  )
12994 
 
3064 chandransh 12995 
  def __init__(self, orderId=None,):
12996 
    self.orderId = orderId
759 chandransh 12997 
 
12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
13007 
      if fid == 1:
13008 
        if ftype == TType.I64:
3064 chandransh 13009 
          self.orderId = iprot.readI64();
759 chandransh 13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      else:
13013 
        iprot.skip(ftype)
13014 
      iprot.readFieldEnd()
13015 
    iprot.readStructEnd()
13016 
 
13017 
  def write(self, oprot):
13018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13020 
      return
3064 chandransh 13021 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13022 
    if self.orderId is not None:
3064 chandransh 13023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13024 
      oprot.writeI64(self.orderId)
759 chandransh 13025 
      oprot.writeFieldEnd()
13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
3431 rajveer 13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
759 chandransh 13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
3064 chandransh 13044 
class verifyOrder_result:
759 chandransh 13045 
  """
13046 
  Attributes:
13047 
   - success
13048 
   - ex
13049 
  """
13050 
 
13051 
  thrift_spec = (
13052 
    (0, TType.BOOL, 'success', None, None, ), # 0
13053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13054 
  )
13055 
 
13056 
  def __init__(self, success=None, ex=None,):
13057 
    self.success = success
13058 
    self.ex = ex
13059 
 
13060 
  def read(self, iprot):
13061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13063 
      return
13064 
    iprot.readStructBegin()
13065 
    while True:
13066 
      (fname, ftype, fid) = iprot.readFieldBegin()
13067 
      if ftype == TType.STOP:
13068 
        break
13069 
      if fid == 0:
13070 
        if ftype == TType.BOOL:
13071 
          self.success = iprot.readBool();
13072 
        else:
13073 
          iprot.skip(ftype)
13074 
      elif fid == 1:
13075 
        if ftype == TType.STRUCT:
13076 
          self.ex = TransactionServiceException()
13077 
          self.ex.read(iprot)
13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      else:
13081 
        iprot.skip(ftype)
13082 
      iprot.readFieldEnd()
13083 
    iprot.readStructEnd()
13084 
 
13085 
  def write(self, oprot):
13086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13088 
      return
3064 chandransh 13089 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13090 
    if self.success is not None:
759 chandransh 13091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13092 
      oprot.writeBool(self.success)
13093 
      oprot.writeFieldEnd()
3431 rajveer 13094 
    if self.ex is not None:
759 chandransh 13095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13096 
      self.ex.write(oprot)
13097 
      oprot.writeFieldEnd()
13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
3431 rajveer 13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
759 chandransh 13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
3064 chandransh 13116 
class acceptOrder_args:
1113 chandransh 13117 
  """
13118 
  Attributes:
3064 chandransh 13119 
   - orderId
1113 chandransh 13120 
  """
13121 
 
13122 
  thrift_spec = (
13123 
    None, # 0
3064 chandransh 13124 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13125 
  )
13126 
 
3064 chandransh 13127 
  def __init__(self, orderId=None,):
13128 
    self.orderId = orderId
1113 chandransh 13129 
 
13130 
  def read(self, iprot):
13131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13133 
      return
13134 
    iprot.readStructBegin()
13135 
    while True:
13136 
      (fname, ftype, fid) = iprot.readFieldBegin()
13137 
      if ftype == TType.STOP:
13138 
        break
13139 
      if fid == 1:
13140 
        if ftype == TType.I64:
3064 chandransh 13141 
          self.orderId = iprot.readI64();
1113 chandransh 13142 
        else:
13143 
          iprot.skip(ftype)
13144 
      else:
13145 
        iprot.skip(ftype)
13146 
      iprot.readFieldEnd()
13147 
    iprot.readStructEnd()
13148 
 
13149 
  def write(self, oprot):
13150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13152 
      return
3064 chandransh 13153 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13154 
    if self.orderId is not None:
3064 chandransh 13155 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13156 
      oprot.writeI64(self.orderId)
1113 chandransh 13157 
      oprot.writeFieldEnd()
13158 
    oprot.writeFieldStop()
13159 
    oprot.writeStructEnd()
13160 
 
3431 rajveer 13161 
  def validate(self):
13162 
    return
13163 
 
13164 
 
1113 chandransh 13165 
  def __repr__(self):
13166 
    L = ['%s=%r' % (key, value)
13167 
      for key, value in self.__dict__.iteritems()]
13168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13169 
 
13170 
  def __eq__(self, other):
13171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13172 
 
13173 
  def __ne__(self, other):
13174 
    return not (self == other)
13175 
 
3064 chandransh 13176 
class acceptOrder_result:
1113 chandransh 13177 
  """
13178 
  Attributes:
13179 
   - success
13180 
   - ex
13181 
  """
13182 
 
13183 
  thrift_spec = (
3064 chandransh 13184 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13186 
  )
13187 
 
13188 
  def __init__(self, success=None, ex=None,):
13189 
    self.success = success
13190 
    self.ex = ex
13191 
 
13192 
  def read(self, iprot):
13193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13195 
      return
13196 
    iprot.readStructBegin()
13197 
    while True:
13198 
      (fname, ftype, fid) = iprot.readFieldBegin()
13199 
      if ftype == TType.STOP:
13200 
        break
13201 
      if fid == 0:
3064 chandransh 13202 
        if ftype == TType.BOOL:
13203 
          self.success = iprot.readBool();
1113 chandransh 13204 
        else:
13205 
          iprot.skip(ftype)
13206 
      elif fid == 1:
13207 
        if ftype == TType.STRUCT:
13208 
          self.ex = TransactionServiceException()
13209 
          self.ex.read(iprot)
13210 
        else:
13211 
          iprot.skip(ftype)
13212 
      else:
13213 
        iprot.skip(ftype)
13214 
      iprot.readFieldEnd()
13215 
    iprot.readStructEnd()
13216 
 
13217 
  def write(self, oprot):
13218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13220 
      return
3064 chandransh 13221 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13222 
    if self.success is not None:
3064 chandransh 13223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13224 
      oprot.writeBool(self.success)
1113 chandransh 13225 
      oprot.writeFieldEnd()
3431 rajveer 13226 
    if self.ex is not None:
1113 chandransh 13227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13228 
      self.ex.write(oprot)
13229 
      oprot.writeFieldEnd()
13230 
    oprot.writeFieldStop()
13231 
    oprot.writeStructEnd()
13232 
 
3431 rajveer 13233 
  def validate(self):
13234 
    return
13235 
 
13236 
 
1113 chandransh 13237 
  def __repr__(self):
13238 
    L = ['%s=%r' % (key, value)
13239 
      for key, value in self.__dict__.iteritems()]
13240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13241 
 
13242 
  def __eq__(self, other):
13243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13244 
 
13245 
  def __ne__(self, other):
13246 
    return not (self == other)
13247 
 
3064 chandransh 13248 
class addBillingDetails_args:
1135 chandransh 13249 
  """
13250 
  Attributes:
3064 chandransh 13251 
   - orderId
13252 
   - invoice_number
4658 mandeep.dh 13253 
   - serialNumber
4283 anupam.sin 13254 
   - itemNumber
3064 chandransh 13255 
   - billed_by
4264 rajveer 13256 
   - jacketNumber
4283 anupam.sin 13257 
   - billingType
5110 mandeep.dh 13258 
   - fulfilmentWarehouseId
4763 rajveer 13259 
   - authorize
1135 chandransh 13260 
  """
13261 
 
13262 
  thrift_spec = (
13263 
    None, # 0
3064 chandransh 13264 
    (1, TType.I64, 'orderId', None, None, ), # 1
13265 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13266 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13267 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13268 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13269 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13270 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13271 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13272 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13273 
  )
13274 
 
5110 mandeep.dh 13275 
  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 13276 
    self.orderId = orderId
13277 
    self.invoice_number = invoice_number
4658 mandeep.dh 13278 
    self.serialNumber = serialNumber
4283 anupam.sin 13279 
    self.itemNumber = itemNumber
3064 chandransh 13280 
    self.billed_by = billed_by
4264 rajveer 13281 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13282 
    self.billingType = billingType
5110 mandeep.dh 13283 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13284 
    self.authorize = authorize
1135 chandransh 13285 
 
13286 
  def read(self, iprot):
13287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13289 
      return
13290 
    iprot.readStructBegin()
13291 
    while True:
13292 
      (fname, ftype, fid) = iprot.readFieldBegin()
13293 
      if ftype == TType.STOP:
13294 
        break
13295 
      if fid == 1:
13296 
        if ftype == TType.I64:
3064 chandransh 13297 
          self.orderId = iprot.readI64();
1135 chandransh 13298 
        else:
13299 
          iprot.skip(ftype)
13300 
      elif fid == 2:
3064 chandransh 13301 
        if ftype == TType.STRING:
13302 
          self.invoice_number = iprot.readString();
1135 chandransh 13303 
        else:
13304 
          iprot.skip(ftype)
3064 chandransh 13305 
      elif fid == 3:
5411 rajveer 13306 
        if ftype == TType.LIST:
13307 
          self.serialNumber = []
6188 rajveer 13308 
          (_etype270, _size267) = iprot.readListBegin()
13309 
          for _i271 in xrange(_size267):
13310 
            _elem272 = iprot.readString();
13311 
            self.serialNumber.append(_elem272)
5411 rajveer 13312 
          iprot.readListEnd()
3064 chandransh 13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      elif fid == 4:
5411 rajveer 13316 
        if ftype == TType.LIST:
13317 
          self.itemNumber = []
6188 rajveer 13318 
          (_etype276, _size273) = iprot.readListBegin()
13319 
          for _i277 in xrange(_size273):
13320 
            _elem278 = iprot.readString();
13321 
            self.itemNumber.append(_elem278)
5411 rajveer 13322 
          iprot.readListEnd()
3064 chandransh 13323 
        else:
13324 
          iprot.skip(ftype)
13325 
      elif fid == 5:
13326 
        if ftype == TType.STRING:
4283 anupam.sin 13327 
          self.billed_by = iprot.readString();
3064 chandransh 13328 
        else:
13329 
          iprot.skip(ftype)
13330 
      elif fid == 6:
13331 
        if ftype == TType.I64:
4283 anupam.sin 13332 
          self.jacketNumber = iprot.readI64();
13333 
        else:
13334 
          iprot.skip(ftype)
13335 
      elif fid == 7:
13336 
        if ftype == TType.I64:
3064 chandransh 13337 
          self.billingType = iprot.readI64();
13338 
        else:
13339 
          iprot.skip(ftype)
4283 anupam.sin 13340 
      elif fid == 8:
13341 
        if ftype == TType.I64:
5110 mandeep.dh 13342 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13343 
        else:
13344 
          iprot.skip(ftype)
4763 rajveer 13345 
      elif fid == 9:
13346 
        if ftype == TType.BOOL:
13347 
          self.authorize = iprot.readBool();
13348 
        else:
13349 
          iprot.skip(ftype)
1246 chandransh 13350 
      else:
13351 
        iprot.skip(ftype)
13352 
      iprot.readFieldEnd()
13353 
    iprot.readStructEnd()
13354 
 
13355 
  def write(self, oprot):
13356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13358 
      return
4283 anupam.sin 13359 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13360 
    if self.orderId is not None:
3064 chandransh 13361 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13362 
      oprot.writeI64(self.orderId)
1246 chandransh 13363 
      oprot.writeFieldEnd()
4283 anupam.sin 13364 
    if self.invoice_number is not None:
13365 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13366 
      oprot.writeString(self.invoice_number)
1246 chandransh 13367 
      oprot.writeFieldEnd()
4658 mandeep.dh 13368 
    if self.serialNumber is not None:
5411 rajveer 13369 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13370 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13371 
      for iter279 in self.serialNumber:
13372 
        oprot.writeString(iter279)
5411 rajveer 13373 
      oprot.writeListEnd()
3064 chandransh 13374 
      oprot.writeFieldEnd()
3431 rajveer 13375 
    if self.itemNumber is not None:
5411 rajveer 13376 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13377 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13378 
      for iter280 in self.itemNumber:
13379 
        oprot.writeString(iter280)
5411 rajveer 13380 
      oprot.writeListEnd()
3064 chandransh 13381 
      oprot.writeFieldEnd()
4283 anupam.sin 13382 
    if self.billed_by is not None:
13383 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13384 
      oprot.writeString(self.billed_by)
3064 chandransh 13385 
      oprot.writeFieldEnd()
4283 anupam.sin 13386 
    if self.jacketNumber is not None:
13387 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13388 
      oprot.writeI64(self.jacketNumber)
13389 
      oprot.writeFieldEnd()
3431 rajveer 13390 
    if self.billingType is not None:
4283 anupam.sin 13391 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13392 
      oprot.writeI64(self.billingType)
13393 
      oprot.writeFieldEnd()
5110 mandeep.dh 13394 
    if self.fulfilmentWarehouseId is not None:
13395 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13396 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13397 
      oprot.writeFieldEnd()
4763 rajveer 13398 
    if self.authorize is not None:
13399 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13400 
      oprot.writeBool(self.authorize)
13401 
      oprot.writeFieldEnd()
1246 chandransh 13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
3431 rajveer 13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
1246 chandransh 13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
4283 anupam.sin 13420 
class addBillingDetails_result:
1246 chandransh 13421 
  """
13422 
  Attributes:
3064 chandransh 13423 
   - success
1246 chandransh 13424 
   - ex
13425 
  """
13426 
 
13427 
  thrift_spec = (
3064 chandransh 13428 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13430 
  )
13431 
 
3064 chandransh 13432 
  def __init__(self, success=None, ex=None,):
13433 
    self.success = success
1246 chandransh 13434 
    self.ex = ex
13435 
 
13436 
  def read(self, iprot):
13437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13439 
      return
13440 
    iprot.readStructBegin()
13441 
    while True:
13442 
      (fname, ftype, fid) = iprot.readFieldBegin()
13443 
      if ftype == TType.STOP:
13444 
        break
3064 chandransh 13445 
      if fid == 0:
13446 
        if ftype == TType.BOOL:
13447 
          self.success = iprot.readBool();
13448 
        else:
13449 
          iprot.skip(ftype)
13450 
      elif fid == 1:
1246 chandransh 13451 
        if ftype == TType.STRUCT:
13452 
          self.ex = TransactionServiceException()
13453 
          self.ex.read(iprot)
13454 
        else:
13455 
          iprot.skip(ftype)
13456 
      else:
13457 
        iprot.skip(ftype)
13458 
      iprot.readFieldEnd()
13459 
    iprot.readStructEnd()
13460 
 
13461 
  def write(self, oprot):
13462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13464 
      return
4283 anupam.sin 13465 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13466 
    if self.success is not None:
3064 chandransh 13467 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13468 
      oprot.writeBool(self.success)
13469 
      oprot.writeFieldEnd()
3431 rajveer 13470 
    if self.ex is not None:
1246 chandransh 13471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13472 
      self.ex.write(oprot)
13473 
      oprot.writeFieldEnd()
13474 
    oprot.writeFieldStop()
13475 
    oprot.writeStructEnd()
13476 
 
3431 rajveer 13477 
  def validate(self):
13478 
    return
13479 
 
13480 
 
1246 chandransh 13481 
  def __repr__(self):
13482 
    L = ['%s=%r' % (key, value)
13483 
      for key, value in self.__dict__.iteritems()]
13484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13485 
 
13486 
  def __eq__(self, other):
13487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13488 
 
13489 
  def __ne__(self, other):
13490 
    return not (self == other)
13491 
 
4579 rajveer 13492 
class addInvoiceNumber_args:
13493 
  """
13494 
  Attributes:
13495 
   - orderId
13496 
   - invoiceNumber
4763 rajveer 13497 
   - color
4579 rajveer 13498 
  """
13499 
 
13500 
  thrift_spec = (
13501 
    None, # 0
13502 
    (1, TType.I64, 'orderId', None, None, ), # 1
13503 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13504 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13505 
  )
13506 
 
4763 rajveer 13507 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13508 
    self.orderId = orderId
13509 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13510 
    self.color = color
4579 rajveer 13511 
 
13512 
  def read(self, iprot):
13513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13515 
      return
13516 
    iprot.readStructBegin()
13517 
    while True:
13518 
      (fname, ftype, fid) = iprot.readFieldBegin()
13519 
      if ftype == TType.STOP:
13520 
        break
13521 
      if fid == 1:
13522 
        if ftype == TType.I64:
13523 
          self.orderId = iprot.readI64();
13524 
        else:
13525 
          iprot.skip(ftype)
13526 
      elif fid == 2:
13527 
        if ftype == TType.STRING:
13528 
          self.invoiceNumber = iprot.readString();
13529 
        else:
13530 
          iprot.skip(ftype)
4763 rajveer 13531 
      elif fid == 3:
13532 
        if ftype == TType.STRING:
13533 
          self.color = iprot.readString();
13534 
        else:
13535 
          iprot.skip(ftype)
4579 rajveer 13536 
      else:
13537 
        iprot.skip(ftype)
13538 
      iprot.readFieldEnd()
13539 
    iprot.readStructEnd()
13540 
 
13541 
  def write(self, oprot):
13542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13544 
      return
13545 
    oprot.writeStructBegin('addInvoiceNumber_args')
13546 
    if self.orderId is not None:
13547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13548 
      oprot.writeI64(self.orderId)
13549 
      oprot.writeFieldEnd()
13550 
    if self.invoiceNumber is not None:
13551 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13552 
      oprot.writeString(self.invoiceNumber)
13553 
      oprot.writeFieldEnd()
4763 rajveer 13554 
    if self.color is not None:
13555 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13556 
      oprot.writeString(self.color)
13557 
      oprot.writeFieldEnd()
4579 rajveer 13558 
    oprot.writeFieldStop()
13559 
    oprot.writeStructEnd()
13560 
 
13561 
  def validate(self):
13562 
    return
13563 
 
13564 
 
13565 
  def __repr__(self):
13566 
    L = ['%s=%r' % (key, value)
13567 
      for key, value in self.__dict__.iteritems()]
13568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13569 
 
13570 
  def __eq__(self, other):
13571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13572 
 
13573 
  def __ne__(self, other):
13574 
    return not (self == other)
13575 
 
13576 
class addInvoiceNumber_result:
13577 
  """
13578 
  Attributes:
13579 
   - ex
13580 
  """
13581 
 
13582 
  thrift_spec = (
13583 
    None, # 0
13584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13585 
  )
13586 
 
13587 
  def __init__(self, ex=None,):
13588 
    self.ex = ex
13589 
 
13590 
  def read(self, iprot):
13591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13593 
      return
13594 
    iprot.readStructBegin()
13595 
    while True:
13596 
      (fname, ftype, fid) = iprot.readFieldBegin()
13597 
      if ftype == TType.STOP:
13598 
        break
13599 
      if fid == 1:
13600 
        if ftype == TType.STRUCT:
13601 
          self.ex = TransactionServiceException()
13602 
          self.ex.read(iprot)
13603 
        else:
13604 
          iprot.skip(ftype)
13605 
      else:
13606 
        iprot.skip(ftype)
13607 
      iprot.readFieldEnd()
13608 
    iprot.readStructEnd()
13609 
 
13610 
  def write(self, oprot):
13611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13613 
      return
13614 
    oprot.writeStructBegin('addInvoiceNumber_result')
13615 
    if self.ex is not None:
13616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13617 
      self.ex.write(oprot)
13618 
      oprot.writeFieldEnd()
13619 
    oprot.writeFieldStop()
13620 
    oprot.writeStructEnd()
13621 
 
13622 
  def validate(self):
13623 
    return
13624 
 
13625 
 
13626 
  def __repr__(self):
13627 
    L = ['%s=%r' % (key, value)
13628 
      for key, value in self.__dict__.iteritems()]
13629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13630 
 
13631 
  def __eq__(self, other):
13632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13633 
 
13634 
  def __ne__(self, other):
13635 
    return not (self == other)
13636 
 
4910 phani.kuma 13637 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13638 
  """
13639 
  Attributes:
3064 chandransh 13640 
   - warehouseId
1408 ankur.sing 13641 
   - providerId
3064 chandransh 13642 
   - cod
4910 phani.kuma 13643 
   - orderIds
1408 ankur.sing 13644 
  """
13645 
 
13646 
  thrift_spec = (
13647 
    None, # 0
3064 chandransh 13648 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13649 
    (2, TType.I64, 'providerId', None, None, ), # 2
13650 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13651 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13652 
  )
13653 
 
4910 phani.kuma 13654 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13655 
    self.warehouseId = warehouseId
1408 ankur.sing 13656 
    self.providerId = providerId
3064 chandransh 13657 
    self.cod = cod
4910 phani.kuma 13658 
    self.orderIds = orderIds
1408 ankur.sing 13659 
 
13660 
  def read(self, iprot):
13661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13663 
      return
13664 
    iprot.readStructBegin()
13665 
    while True:
13666 
      (fname, ftype, fid) = iprot.readFieldBegin()
13667 
      if ftype == TType.STOP:
13668 
        break
13669 
      if fid == 1:
13670 
        if ftype == TType.I64:
3064 chandransh 13671 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13672 
        else:
13673 
          iprot.skip(ftype)
13674 
      elif fid == 2:
13675 
        if ftype == TType.I64:
3064 chandransh 13676 
          self.providerId = iprot.readI64();
1408 ankur.sing 13677 
        else:
13678 
          iprot.skip(ftype)
3064 chandransh 13679 
      elif fid == 3:
13680 
        if ftype == TType.BOOL:
13681 
          self.cod = iprot.readBool();
13682 
        else:
13683 
          iprot.skip(ftype)
4910 phani.kuma 13684 
      elif fid == 4:
13685 
        if ftype == TType.LIST:
13686 
          self.orderIds = []
6188 rajveer 13687 
          (_etype284, _size281) = iprot.readListBegin()
13688 
          for _i285 in xrange(_size281):
13689 
            _elem286 = iprot.readI64();
13690 
            self.orderIds.append(_elem286)
4910 phani.kuma 13691 
          iprot.readListEnd()
13692 
        else:
13693 
          iprot.skip(ftype)
1408 ankur.sing 13694 
      else:
13695 
        iprot.skip(ftype)
13696 
      iprot.readFieldEnd()
13697 
    iprot.readStructEnd()
13698 
 
13699 
  def write(self, oprot):
13700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13702 
      return
4910 phani.kuma 13703 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13704 
    if self.warehouseId is not None:
3064 chandransh 13705 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13706 
      oprot.writeI64(self.warehouseId)
13707 
      oprot.writeFieldEnd()
3431 rajveer 13708 
    if self.providerId is not None:
3064 chandransh 13709 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13710 
      oprot.writeI64(self.providerId)
13711 
      oprot.writeFieldEnd()
3431 rajveer 13712 
    if self.cod is not None:
3064 chandransh 13713 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13714 
      oprot.writeBool(self.cod)
1408 ankur.sing 13715 
      oprot.writeFieldEnd()
4910 phani.kuma 13716 
    if self.orderIds is not None:
13717 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13718 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13719 
      for iter287 in self.orderIds:
13720 
        oprot.writeI64(iter287)
4910 phani.kuma 13721 
      oprot.writeListEnd()
13722 
      oprot.writeFieldEnd()
1408 ankur.sing 13723 
    oprot.writeFieldStop()
13724 
    oprot.writeStructEnd()
13725 
 
3431 rajveer 13726 
  def validate(self):
13727 
    return
13728 
 
13729 
 
1408 ankur.sing 13730 
  def __repr__(self):
13731 
    L = ['%s=%r' % (key, value)
13732 
      for key, value in self.__dict__.iteritems()]
13733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13734 
 
13735 
  def __eq__(self, other):
13736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13737 
 
13738 
  def __ne__(self, other):
13739 
    return not (self == other)
13740 
 
4910 phani.kuma 13741 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13742 
  """
13743 
  Attributes:
13744 
   - success
3064 chandransh 13745 
   - ex
1408 ankur.sing 13746 
  """
13747 
 
13748 
  thrift_spec = (
3064 chandransh 13749 
    (0, TType.BOOL, 'success', None, None, ), # 0
13750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13751 
  )
13752 
 
3064 chandransh 13753 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13754 
    self.success = success
3064 chandransh 13755 
    self.ex = ex
1408 ankur.sing 13756 
 
13757 
  def read(self, iprot):
13758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13760 
      return
13761 
    iprot.readStructBegin()
13762 
    while True:
13763 
      (fname, ftype, fid) = iprot.readFieldBegin()
13764 
      if ftype == TType.STOP:
13765 
        break
13766 
      if fid == 0:
3064 chandransh 13767 
        if ftype == TType.BOOL:
13768 
          self.success = iprot.readBool();
1408 ankur.sing 13769 
        else:
13770 
          iprot.skip(ftype)
3064 chandransh 13771 
      elif fid == 1:
13772 
        if ftype == TType.STRUCT:
13773 
          self.ex = TransactionServiceException()
13774 
          self.ex.read(iprot)
13775 
        else:
13776 
          iprot.skip(ftype)
1408 ankur.sing 13777 
      else:
13778 
        iprot.skip(ftype)
13779 
      iprot.readFieldEnd()
13780 
    iprot.readStructEnd()
13781 
 
13782 
  def write(self, oprot):
13783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13785 
      return
4910 phani.kuma 13786 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13787 
    if self.success is not None:
3064 chandransh 13788 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13789 
      oprot.writeBool(self.success)
1408 ankur.sing 13790 
      oprot.writeFieldEnd()
3431 rajveer 13791 
    if self.ex is not None:
3064 chandransh 13792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13793 
      self.ex.write(oprot)
13794 
      oprot.writeFieldEnd()
1408 ankur.sing 13795 
    oprot.writeFieldStop()
13796 
    oprot.writeStructEnd()
13797 
 
3431 rajveer 13798 
  def validate(self):
13799 
    return
13800 
 
13801 
 
1408 ankur.sing 13802 
  def __repr__(self):
13803 
    L = ['%s=%r' % (key, value)
13804 
      for key, value in self.__dict__.iteritems()]
13805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13806 
 
13807 
  def __eq__(self, other):
13808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13809 
 
13810 
  def __ne__(self, other):
13811 
    return not (self == other)
13812 
 
5676 rajveer 13813 
class markOrdersAsReturnedFromStore_args:
13814 
  """
13815 
  Attributes:
13816 
   - providerId
13817 
   - orderIds
5713 rajveer 13818 
   - awbs
5676 rajveer 13819 
  """
13820 
 
13821 
  thrift_spec = (
13822 
    None, # 0
13823 
    (1, TType.I64, 'providerId', None, None, ), # 1
13824 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13825 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13826 
  )
13827 
 
5713 rajveer 13828 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13829 
    self.providerId = providerId
13830 
    self.orderIds = orderIds
5713 rajveer 13831 
    self.awbs = awbs
5676 rajveer 13832 
 
13833 
  def read(self, iprot):
13834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13836 
      return
13837 
    iprot.readStructBegin()
13838 
    while True:
13839 
      (fname, ftype, fid) = iprot.readFieldBegin()
13840 
      if ftype == TType.STOP:
13841 
        break
13842 
      if fid == 1:
13843 
        if ftype == TType.I64:
13844 
          self.providerId = iprot.readI64();
13845 
        else:
13846 
          iprot.skip(ftype)
13847 
      elif fid == 2:
13848 
        if ftype == TType.LIST:
13849 
          self.orderIds = []
6188 rajveer 13850 
          (_etype291, _size288) = iprot.readListBegin()
13851 
          for _i292 in xrange(_size288):
13852 
            _elem293 = iprot.readI64();
13853 
            self.orderIds.append(_elem293)
5676 rajveer 13854 
          iprot.readListEnd()
13855 
        else:
13856 
          iprot.skip(ftype)
5713 rajveer 13857 
      elif fid == 3:
13858 
        if ftype == TType.LIST:
13859 
          self.awbs = []
6188 rajveer 13860 
          (_etype297, _size294) = iprot.readListBegin()
13861 
          for _i298 in xrange(_size294):
13862 
            _elem299 = iprot.readString();
13863 
            self.awbs.append(_elem299)
5713 rajveer 13864 
          iprot.readListEnd()
13865 
        else:
13866 
          iprot.skip(ftype)
5676 rajveer 13867 
      else:
13868 
        iprot.skip(ftype)
13869 
      iprot.readFieldEnd()
13870 
    iprot.readStructEnd()
13871 
 
13872 
  def write(self, oprot):
13873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13875 
      return
13876 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13877 
    if self.providerId is not None:
13878 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13879 
      oprot.writeI64(self.providerId)
13880 
      oprot.writeFieldEnd()
13881 
    if self.orderIds is not None:
13882 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13883 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13884 
      for iter300 in self.orderIds:
13885 
        oprot.writeI64(iter300)
5676 rajveer 13886 
      oprot.writeListEnd()
13887 
      oprot.writeFieldEnd()
5713 rajveer 13888 
    if self.awbs is not None:
13889 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13890 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 13891 
      for iter301 in self.awbs:
13892 
        oprot.writeString(iter301)
5713 rajveer 13893 
      oprot.writeListEnd()
13894 
      oprot.writeFieldEnd()
5676 rajveer 13895 
    oprot.writeFieldStop()
13896 
    oprot.writeStructEnd()
13897 
 
13898 
  def validate(self):
13899 
    return
13900 
 
13901 
 
13902 
  def __repr__(self):
13903 
    L = ['%s=%r' % (key, value)
13904 
      for key, value in self.__dict__.iteritems()]
13905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13906 
 
13907 
  def __eq__(self, other):
13908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13909 
 
13910 
  def __ne__(self, other):
13911 
    return not (self == other)
13912 
 
13913 
class markOrdersAsReturnedFromStore_result:
13914 
  """
13915 
  Attributes:
13916 
   - success
13917 
   - ex
13918 
  """
13919 
 
13920 
  thrift_spec = (
13921 
    (0, TType.BOOL, 'success', None, None, ), # 0
13922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13923 
  )
13924 
 
13925 
  def __init__(self, success=None, ex=None,):
13926 
    self.success = success
13927 
    self.ex = ex
13928 
 
13929 
  def read(self, iprot):
13930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13932 
      return
13933 
    iprot.readStructBegin()
13934 
    while True:
13935 
      (fname, ftype, fid) = iprot.readFieldBegin()
13936 
      if ftype == TType.STOP:
13937 
        break
13938 
      if fid == 0:
13939 
        if ftype == TType.BOOL:
13940 
          self.success = iprot.readBool();
13941 
        else:
13942 
          iprot.skip(ftype)
13943 
      elif fid == 1:
13944 
        if ftype == TType.STRUCT:
13945 
          self.ex = TransactionServiceException()
13946 
          self.ex.read(iprot)
13947 
        else:
13948 
          iprot.skip(ftype)
13949 
      else:
13950 
        iprot.skip(ftype)
13951 
      iprot.readFieldEnd()
13952 
    iprot.readStructEnd()
13953 
 
13954 
  def write(self, oprot):
13955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13957 
      return
13958 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13959 
    if self.success is not None:
13960 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13961 
      oprot.writeBool(self.success)
13962 
      oprot.writeFieldEnd()
13963 
    if self.ex is not None:
13964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13965 
      self.ex.write(oprot)
13966 
      oprot.writeFieldEnd()
13967 
    oprot.writeFieldStop()
13968 
    oprot.writeStructEnd()
13969 
 
13970 
  def validate(self):
13971 
    return
13972 
 
13973 
 
13974 
  def __repr__(self):
13975 
    L = ['%s=%r' % (key, value)
13976 
      for key, value in self.__dict__.iteritems()]
13977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13978 
 
13979 
  def __eq__(self, other):
13980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13981 
 
13982 
  def __ne__(self, other):
13983 
    return not (self == other)
13984 
 
4910 phani.kuma 13985 
class markOrdersAsPickedUp_args:
4410 rajveer 13986 
  """
13987 
  Attributes:
13988 
   - providerId
4910 phani.kuma 13989 
   - pickupDetails
4410 rajveer 13990 
  """
13991 
 
13992 
  thrift_spec = (
13993 
    None, # 0
4910 phani.kuma 13994 
    (1, TType.I64, 'providerId', None, None, ), # 1
13995 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13996 
  )
13997 
 
4910 phani.kuma 13998 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13999 
    self.providerId = providerId
4910 phani.kuma 14000 
    self.pickupDetails = pickupDetails
4410 rajveer 14001 
 
14002 
  def read(self, iprot):
14003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14005 
      return
14006 
    iprot.readStructBegin()
14007 
    while True:
14008 
      (fname, ftype, fid) = iprot.readFieldBegin()
14009 
      if ftype == TType.STOP:
14010 
        break
14011 
      if fid == 1:
14012 
        if ftype == TType.I64:
4910 phani.kuma 14013 
          self.providerId = iprot.readI64();
4410 rajveer 14014 
        else:
14015 
          iprot.skip(ftype)
14016 
      elif fid == 2:
4910 phani.kuma 14017 
        if ftype == TType.MAP:
14018 
          self.pickupDetails = {}
6188 rajveer 14019 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14020 
          for _i306 in xrange(_size302):
14021 
            _key307 = iprot.readString();
14022 
            _val308 = iprot.readString();
14023 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14024 
          iprot.readMapEnd()
4410 rajveer 14025 
        else:
14026 
          iprot.skip(ftype)
14027 
      else:
14028 
        iprot.skip(ftype)
14029 
      iprot.readFieldEnd()
14030 
    iprot.readStructEnd()
14031 
 
14032 
  def write(self, oprot):
14033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14035 
      return
4910 phani.kuma 14036 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14037 
    if self.providerId is not None:
4910 phani.kuma 14038 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14039 
      oprot.writeI64(self.providerId)
14040 
      oprot.writeFieldEnd()
4910 phani.kuma 14041 
    if self.pickupDetails is not None:
14042 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14043 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14044 
      for kiter309,viter310 in self.pickupDetails.items():
14045 
        oprot.writeString(kiter309)
14046 
        oprot.writeString(viter310)
4910 phani.kuma 14047 
      oprot.writeMapEnd()
4410 rajveer 14048 
      oprot.writeFieldEnd()
14049 
    oprot.writeFieldStop()
14050 
    oprot.writeStructEnd()
14051 
 
14052 
  def validate(self):
14053 
    return
14054 
 
14055 
 
14056 
  def __repr__(self):
14057 
    L = ['%s=%r' % (key, value)
14058 
      for key, value in self.__dict__.iteritems()]
14059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14060 
 
14061 
  def __eq__(self, other):
14062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14063 
 
14064 
  def __ne__(self, other):
14065 
    return not (self == other)
14066 
 
4910 phani.kuma 14067 
class markOrdersAsPickedUp_result:
4410 rajveer 14068 
  """
14069 
  Attributes:
14070 
   - ex
14071 
  """
14072 
 
14073 
  thrift_spec = (
4910 phani.kuma 14074 
    None, # 0
4410 rajveer 14075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14076 
  )
14077 
 
4910 phani.kuma 14078 
  def __init__(self, ex=None,):
4410 rajveer 14079 
    self.ex = ex
14080 
 
14081 
  def read(self, iprot):
14082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14084 
      return
14085 
    iprot.readStructBegin()
14086 
    while True:
14087 
      (fname, ftype, fid) = iprot.readFieldBegin()
14088 
      if ftype == TType.STOP:
14089 
        break
4910 phani.kuma 14090 
      if fid == 1:
4410 rajveer 14091 
        if ftype == TType.STRUCT:
14092 
          self.ex = TransactionServiceException()
14093 
          self.ex.read(iprot)
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
4910 phani.kuma 14105 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14106 
    if self.ex is not None:
14107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14108 
      self.ex.write(oprot)
14109 
      oprot.writeFieldEnd()
14110 
    oprot.writeFieldStop()
14111 
    oprot.writeStructEnd()
14112 
 
14113 
  def validate(self):
14114 
    return
14115 
 
14116 
 
14117 
  def __repr__(self):
14118 
    L = ['%s=%r' % (key, value)
14119 
      for key, value in self.__dict__.iteritems()]
14120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14121 
 
14122 
  def __eq__(self, other):
14123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14124 
 
14125 
  def __ne__(self, other):
14126 
    return not (self == other)
14127 
 
4910 phani.kuma 14128 
class getOrdersNotPickedUp_args:
304 ashish 14129 
  """
14130 
  Attributes:
3064 chandransh 14131 
   - providerId
304 ashish 14132 
  """
94 ashish 14133 
 
304 ashish 14134 
  thrift_spec = (
14135 
    None, # 0
3064 chandransh 14136 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14137 
  )
14138 
 
4910 phani.kuma 14139 
  def __init__(self, providerId=None,):
3064 chandransh 14140 
    self.providerId = providerId
304 ashish 14141 
 
14142 
  def read(self, iprot):
14143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14145 
      return
14146 
    iprot.readStructBegin()
14147 
    while True:
14148 
      (fname, ftype, fid) = iprot.readFieldBegin()
14149 
      if ftype == TType.STOP:
14150 
        break
14151 
      if fid == 1:
14152 
        if ftype == TType.I64:
3064 chandransh 14153 
          self.providerId = iprot.readI64();
304 ashish 14154 
        else:
14155 
          iprot.skip(ftype)
14156 
      else:
14157 
        iprot.skip(ftype)
14158 
      iprot.readFieldEnd()
14159 
    iprot.readStructEnd()
14160 
 
14161 
  def write(self, oprot):
14162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14164 
      return
4910 phani.kuma 14165 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14166 
    if self.providerId is not None:
3064 chandransh 14167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14168 
      oprot.writeI64(self.providerId)
304 ashish 14169 
      oprot.writeFieldEnd()
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
3431 rajveer 14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
304 ashish 14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
4910 phani.kuma 14188 
class getOrdersNotPickedUp_result:
304 ashish 14189 
  """
14190 
  Attributes:
14191 
   - success
14192 
  """
14193 
 
14194 
  thrift_spec = (
3064 chandransh 14195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14196 
  )
14197 
 
4910 phani.kuma 14198 
  def __init__(self, success=None,):
304 ashish 14199 
    self.success = success
14200 
 
14201 
  def read(self, iprot):
14202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14204 
      return
14205 
    iprot.readStructBegin()
14206 
    while True:
14207 
      (fname, ftype, fid) = iprot.readFieldBegin()
14208 
      if ftype == TType.STOP:
14209 
        break
14210 
      if fid == 0:
14211 
        if ftype == TType.LIST:
14212 
          self.success = []
6188 rajveer 14213 
          (_etype314, _size311) = iprot.readListBegin()
14214 
          for _i315 in xrange(_size311):
14215 
            _elem316 = Order()
14216 
            _elem316.read(iprot)
14217 
            self.success.append(_elem316)
304 ashish 14218 
          iprot.readListEnd()
14219 
        else:
14220 
          iprot.skip(ftype)
14221 
      else:
14222 
        iprot.skip(ftype)
14223 
      iprot.readFieldEnd()
14224 
    iprot.readStructEnd()
14225 
 
14226 
  def write(self, oprot):
14227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14229 
      return
4910 phani.kuma 14230 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14231 
    if self.success is not None:
304 ashish 14232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14234 
      for iter317 in self.success:
14235 
        iter317.write(oprot)
304 ashish 14236 
      oprot.writeListEnd()
14237 
      oprot.writeFieldEnd()
14238 
    oprot.writeFieldStop()
14239 
    oprot.writeStructEnd()
14240 
 
3431 rajveer 14241 
  def validate(self):
14242 
    return
14243 
 
14244 
 
304 ashish 14245 
  def __repr__(self):
14246 
    L = ['%s=%r' % (key, value)
14247 
      for key, value in self.__dict__.iteritems()]
14248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14249 
 
14250 
  def __eq__(self, other):
14251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14252 
 
14253 
  def __ne__(self, other):
14254 
    return not (self == other)
14255 
 
3064 chandransh 14256 
class markOrdersAsDelivered_args:
304 ashish 14257 
  """
14258 
  Attributes:
3064 chandransh 14259 
   - providerId
14260 
   - deliveredOrders
304 ashish 14261 
  """
14262 
 
14263 
  thrift_spec = (
14264 
    None, # 0
3064 chandransh 14265 
    (1, TType.I64, 'providerId', None, None, ), # 1
14266 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14267 
  )
14268 
 
3064 chandransh 14269 
  def __init__(self, providerId=None, deliveredOrders=None,):
14270 
    self.providerId = providerId
14271 
    self.deliveredOrders = deliveredOrders
304 ashish 14272 
 
14273 
  def read(self, iprot):
14274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14276 
      return
14277 
    iprot.readStructBegin()
14278 
    while True:
14279 
      (fname, ftype, fid) = iprot.readFieldBegin()
14280 
      if ftype == TType.STOP:
14281 
        break
14282 
      if fid == 1:
14283 
        if ftype == TType.I64:
3064 chandransh 14284 
          self.providerId = iprot.readI64();
304 ashish 14285 
        else:
14286 
          iprot.skip(ftype)
14287 
      elif fid == 2:
3064 chandransh 14288 
        if ftype == TType.MAP:
14289 
          self.deliveredOrders = {}
6188 rajveer 14290 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14291 
          for _i322 in xrange(_size318):
14292 
            _key323 = iprot.readString();
14293 
            _val324 = iprot.readString();
14294 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14295 
          iprot.readMapEnd()
304 ashish 14296 
        else:
14297 
          iprot.skip(ftype)
14298 
      else:
14299 
        iprot.skip(ftype)
14300 
      iprot.readFieldEnd()
14301 
    iprot.readStructEnd()
14302 
 
14303 
  def write(self, oprot):
14304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14306 
      return
3064 chandransh 14307 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14308 
    if self.providerId is not None:
3064 chandransh 14309 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14310 
      oprot.writeI64(self.providerId)
304 ashish 14311 
      oprot.writeFieldEnd()
3431 rajveer 14312 
    if self.deliveredOrders is not None:
3064 chandransh 14313 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14314 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14315 
      for kiter325,viter326 in self.deliveredOrders.items():
14316 
        oprot.writeString(kiter325)
14317 
        oprot.writeString(viter326)
3064 chandransh 14318 
      oprot.writeMapEnd()
304 ashish 14319 
      oprot.writeFieldEnd()
14320 
    oprot.writeFieldStop()
14321 
    oprot.writeStructEnd()
14322 
 
3431 rajveer 14323 
  def validate(self):
14324 
    return
14325 
 
14326 
 
304 ashish 14327 
  def __repr__(self):
14328 
    L = ['%s=%r' % (key, value)
14329 
      for key, value in self.__dict__.iteritems()]
14330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14331 
 
14332 
  def __eq__(self, other):
14333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14334 
 
14335 
  def __ne__(self, other):
14336 
    return not (self == other)
14337 
 
3064 chandransh 14338 
class markOrdersAsDelivered_result:
14339 
  """
14340 
  Attributes:
14341 
   - ex
14342 
  """
304 ashish 14343 
 
14344 
  thrift_spec = (
3064 chandransh 14345 
    None, # 0
14346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14347 
  )
14348 
 
3064 chandransh 14349 
  def __init__(self, ex=None,):
14350 
    self.ex = ex
304 ashish 14351 
 
1596 ankur.sing 14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
3064 chandransh 14361 
      if fid == 1:
14362 
        if ftype == TType.STRUCT:
14363 
          self.ex = TransactionServiceException()
14364 
          self.ex.read(iprot)
14365 
        else:
14366 
          iprot.skip(ftype)
1596 ankur.sing 14367 
      else:
14368 
        iprot.skip(ftype)
14369 
      iprot.readFieldEnd()
14370 
    iprot.readStructEnd()
14371 
 
14372 
  def write(self, oprot):
14373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14375 
      return
3064 chandransh 14376 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14377 
    if self.ex is not None:
3064 chandransh 14378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14379 
      self.ex.write(oprot)
14380 
      oprot.writeFieldEnd()
1596 ankur.sing 14381 
    oprot.writeFieldStop()
14382 
    oprot.writeStructEnd()
14383 
 
3431 rajveer 14384 
  def validate(self):
14385 
    return
14386 
 
14387 
 
1596 ankur.sing 14388 
  def __repr__(self):
14389 
    L = ['%s=%r' % (key, value)
14390 
      for key, value in self.__dict__.iteritems()]
14391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14392 
 
14393 
  def __eq__(self, other):
14394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14395 
 
14396 
  def __ne__(self, other):
14397 
    return not (self == other)
14398 
 
4910 phani.kuma 14399 
class markAsRTOrders_args:
1596 ankur.sing 14400 
  """
14401 
  Attributes:
3064 chandransh 14402 
   - providerId
14403 
   - returnedOrders
1596 ankur.sing 14404 
  """
14405 
 
14406 
  thrift_spec = (
3064 chandransh 14407 
    None, # 0
14408 
    (1, TType.I64, 'providerId', None, None, ), # 1
14409 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14410 
  )
14411 
 
3064 chandransh 14412 
  def __init__(self, providerId=None, returnedOrders=None,):
14413 
    self.providerId = providerId
14414 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14415 
 
14416 
  def read(self, iprot):
14417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14419 
      return
14420 
    iprot.readStructBegin()
14421 
    while True:
14422 
      (fname, ftype, fid) = iprot.readFieldBegin()
14423 
      if ftype == TType.STOP:
14424 
        break
3064 chandransh 14425 
      if fid == 1:
1596 ankur.sing 14426 
        if ftype == TType.I64:
3064 chandransh 14427 
          self.providerId = iprot.readI64();
1596 ankur.sing 14428 
        else:
14429 
          iprot.skip(ftype)
3064 chandransh 14430 
      elif fid == 2:
14431 
        if ftype == TType.MAP:
14432 
          self.returnedOrders = {}
6188 rajveer 14433 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14434 
          for _i331 in xrange(_size327):
14435 
            _key332 = iprot.readString();
14436 
            _val333 = iprot.readString();
14437 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14438 
          iprot.readMapEnd()
14439 
        else:
14440 
          iprot.skip(ftype)
1596 ankur.sing 14441 
      else:
14442 
        iprot.skip(ftype)
14443 
      iprot.readFieldEnd()
14444 
    iprot.readStructEnd()
14445 
 
14446 
  def write(self, oprot):
14447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14449 
      return
4910 phani.kuma 14450 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14451 
    if self.providerId is not None:
3064 chandransh 14452 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14453 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14454 
      oprot.writeFieldEnd()
3431 rajveer 14455 
    if self.returnedOrders is not None:
3064 chandransh 14456 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14457 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14458 
      for kiter334,viter335 in self.returnedOrders.items():
14459 
        oprot.writeString(kiter334)
14460 
        oprot.writeString(viter335)
3064 chandransh 14461 
      oprot.writeMapEnd()
14462 
      oprot.writeFieldEnd()
1596 ankur.sing 14463 
    oprot.writeFieldStop()
14464 
    oprot.writeStructEnd()
14465 
 
3431 rajveer 14466 
  def validate(self):
14467 
    return
14468 
 
14469 
 
1596 ankur.sing 14470 
  def __repr__(self):
14471 
    L = ['%s=%r' % (key, value)
14472 
      for key, value in self.__dict__.iteritems()]
14473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14474 
 
14475 
  def __eq__(self, other):
14476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14477 
 
14478 
  def __ne__(self, other):
14479 
    return not (self == other)
14480 
 
4910 phani.kuma 14481 
class markAsRTOrders_result:
3064 chandransh 14482 
  """
14483 
  Attributes:
14484 
   - ex
14485 
  """
1596 ankur.sing 14486 
 
1627 ankur.sing 14487 
  thrift_spec = (
3064 chandransh 14488 
    None, # 0
14489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14490 
  )
14491 
 
3064 chandransh 14492 
  def __init__(self, ex=None,):
14493 
    self.ex = ex
14494 
 
1627 ankur.sing 14495 
  def read(self, iprot):
14496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14498 
      return
14499 
    iprot.readStructBegin()
14500 
    while True:
14501 
      (fname, ftype, fid) = iprot.readFieldBegin()
14502 
      if ftype == TType.STOP:
14503 
        break
3064 chandransh 14504 
      if fid == 1:
14505 
        if ftype == TType.STRUCT:
14506 
          self.ex = TransactionServiceException()
14507 
          self.ex.read(iprot)
14508 
        else:
14509 
          iprot.skip(ftype)
1627 ankur.sing 14510 
      else:
14511 
        iprot.skip(ftype)
14512 
      iprot.readFieldEnd()
14513 
    iprot.readStructEnd()
14514 
 
14515 
  def write(self, oprot):
14516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14518 
      return
4910 phani.kuma 14519 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14520 
    if self.ex is not None:
3064 chandransh 14521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14522 
      self.ex.write(oprot)
14523 
      oprot.writeFieldEnd()
1627 ankur.sing 14524 
    oprot.writeFieldStop()
14525 
    oprot.writeStructEnd()
14526 
 
3431 rajveer 14527 
  def validate(self):
14528 
    return
14529 
 
14530 
 
1627 ankur.sing 14531 
  def __repr__(self):
14532 
    L = ['%s=%r' % (key, value)
14533 
      for key, value in self.__dict__.iteritems()]
14534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14535 
 
14536 
  def __eq__(self, other):
14537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14538 
 
14539 
  def __ne__(self, other):
14540 
    return not (self == other)
14541 
 
4910 phani.kuma 14542 
class getRTOrders_args:
14543 
  """
14544 
  Attributes:
14545 
   - providerId
14546 
  """
14547 
 
14548 
  thrift_spec = (
14549 
    None, # 0
14550 
    (1, TType.I64, 'providerId', None, None, ), # 1
14551 
  )
14552 
 
14553 
  def __init__(self, providerId=None,):
14554 
    self.providerId = providerId
14555 
 
14556 
  def read(self, iprot):
14557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14559 
      return
14560 
    iprot.readStructBegin()
14561 
    while True:
14562 
      (fname, ftype, fid) = iprot.readFieldBegin()
14563 
      if ftype == TType.STOP:
14564 
        break
14565 
      if fid == 1:
14566 
        if ftype == TType.I64:
14567 
          self.providerId = iprot.readI64();
14568 
        else:
14569 
          iprot.skip(ftype)
14570 
      else:
14571 
        iprot.skip(ftype)
14572 
      iprot.readFieldEnd()
14573 
    iprot.readStructEnd()
14574 
 
14575 
  def write(self, oprot):
14576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14578 
      return
14579 
    oprot.writeStructBegin('getRTOrders_args')
14580 
    if self.providerId is not None:
14581 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14582 
      oprot.writeI64(self.providerId)
14583 
      oprot.writeFieldEnd()
14584 
    oprot.writeFieldStop()
14585 
    oprot.writeStructEnd()
14586 
 
14587 
  def validate(self):
14588 
    return
14589 
 
14590 
 
14591 
  def __repr__(self):
14592 
    L = ['%s=%r' % (key, value)
14593 
      for key, value in self.__dict__.iteritems()]
14594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14595 
 
14596 
  def __eq__(self, other):
14597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14598 
 
14599 
  def __ne__(self, other):
14600 
    return not (self == other)
14601 
 
14602 
class getRTOrders_result:
14603 
  """
14604 
  Attributes:
14605 
   - success
14606 
  """
14607 
 
14608 
  thrift_spec = (
14609 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14610 
  )
14611 
 
14612 
  def __init__(self, success=None,):
14613 
    self.success = success
14614 
 
14615 
  def read(self, iprot):
14616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14618 
      return
14619 
    iprot.readStructBegin()
14620 
    while True:
14621 
      (fname, ftype, fid) = iprot.readFieldBegin()
14622 
      if ftype == TType.STOP:
14623 
        break
14624 
      if fid == 0:
14625 
        if ftype == TType.LIST:
14626 
          self.success = []
6188 rajveer 14627 
          (_etype339, _size336) = iprot.readListBegin()
14628 
          for _i340 in xrange(_size336):
14629 
            _elem341 = Order()
14630 
            _elem341.read(iprot)
14631 
            self.success.append(_elem341)
4910 phani.kuma 14632 
          iprot.readListEnd()
14633 
        else:
14634 
          iprot.skip(ftype)
14635 
      else:
14636 
        iprot.skip(ftype)
14637 
      iprot.readFieldEnd()
14638 
    iprot.readStructEnd()
14639 
 
14640 
  def write(self, oprot):
14641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14643 
      return
14644 
    oprot.writeStructBegin('getRTOrders_result')
14645 
    if self.success is not None:
14646 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14647 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14648 
      for iter342 in self.success:
14649 
        iter342.write(oprot)
4910 phani.kuma 14650 
      oprot.writeListEnd()
14651 
      oprot.writeFieldEnd()
14652 
    oprot.writeFieldStop()
14653 
    oprot.writeStructEnd()
14654 
 
14655 
  def validate(self):
14656 
    return
14657 
 
14658 
 
14659 
  def __repr__(self):
14660 
    L = ['%s=%r' % (key, value)
14661 
      for key, value in self.__dict__.iteritems()]
14662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14663 
 
14664 
  def __eq__(self, other):
14665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14666 
 
14667 
  def __ne__(self, other):
14668 
    return not (self == other)
14669 
 
3064 chandransh 14670 
class updateNonDeliveryReason_args:
1627 ankur.sing 14671 
  """
14672 
  Attributes:
3064 chandransh 14673 
   - providerId
14674 
   - undeliveredOrders
1627 ankur.sing 14675 
  """
14676 
 
14677 
  thrift_spec = (
3064 chandransh 14678 
    None, # 0
14679 
    (1, TType.I64, 'providerId', None, None, ), # 1
14680 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14681 
  )
14682 
 
3064 chandransh 14683 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14684 
    self.providerId = providerId
14685 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14686 
 
14687 
  def read(self, iprot):
14688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14690 
      return
14691 
    iprot.readStructBegin()
14692 
    while True:
14693 
      (fname, ftype, fid) = iprot.readFieldBegin()
14694 
      if ftype == TType.STOP:
14695 
        break
3064 chandransh 14696 
      if fid == 1:
1627 ankur.sing 14697 
        if ftype == TType.I64:
3064 chandransh 14698 
          self.providerId = iprot.readI64();
1627 ankur.sing 14699 
        else:
14700 
          iprot.skip(ftype)
3064 chandransh 14701 
      elif fid == 2:
14702 
        if ftype == TType.MAP:
14703 
          self.undeliveredOrders = {}
6188 rajveer 14704 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14705 
          for _i347 in xrange(_size343):
14706 
            _key348 = iprot.readString();
14707 
            _val349 = iprot.readString();
14708 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14709 
          iprot.readMapEnd()
14710 
        else:
14711 
          iprot.skip(ftype)
1627 ankur.sing 14712 
      else:
14713 
        iprot.skip(ftype)
14714 
      iprot.readFieldEnd()
14715 
    iprot.readStructEnd()
14716 
 
14717 
  def write(self, oprot):
14718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14720 
      return
3064 chandransh 14721 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14722 
    if self.providerId is not None:
3064 chandransh 14723 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14724 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14725 
      oprot.writeFieldEnd()
3431 rajveer 14726 
    if self.undeliveredOrders is not None:
3064 chandransh 14727 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14728 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14729 
      for kiter350,viter351 in self.undeliveredOrders.items():
14730 
        oprot.writeString(kiter350)
14731 
        oprot.writeString(viter351)
3064 chandransh 14732 
      oprot.writeMapEnd()
14733 
      oprot.writeFieldEnd()
1627 ankur.sing 14734 
    oprot.writeFieldStop()
14735 
    oprot.writeStructEnd()
14736 
 
3431 rajveer 14737 
  def validate(self):
14738 
    return
14739 
 
14740 
 
1627 ankur.sing 14741 
  def __repr__(self):
14742 
    L = ['%s=%r' % (key, value)
14743 
      for key, value in self.__dict__.iteritems()]
14744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14745 
 
14746 
  def __eq__(self, other):
14747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14748 
 
14749 
  def __ne__(self, other):
14750 
    return not (self == other)
14751 
 
3064 chandransh 14752 
class updateNonDeliveryReason_result:
1627 ankur.sing 14753 
  """
14754 
  Attributes:
3064 chandransh 14755 
   - ex
1627 ankur.sing 14756 
  """
14757 
 
14758 
  thrift_spec = (
4910 phani.kuma 14759 
    None, # 0
3064 chandransh 14760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14761 
  )
14762 
 
4910 phani.kuma 14763 
  def __init__(self, ex=None,):
3064 chandransh 14764 
    self.ex = ex
1627 ankur.sing 14765 
 
14766 
  def read(self, iprot):
14767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14769 
      return
14770 
    iprot.readStructBegin()
14771 
    while True:
14772 
      (fname, ftype, fid) = iprot.readFieldBegin()
14773 
      if ftype == TType.STOP:
14774 
        break
4910 phani.kuma 14775 
      if fid == 1:
14776 
        if ftype == TType.STRUCT:
14777 
          self.ex = TransactionServiceException()
14778 
          self.ex.read(iprot)
14779 
        else:
14780 
          iprot.skip(ftype)
14781 
      else:
14782 
        iprot.skip(ftype)
14783 
      iprot.readFieldEnd()
14784 
    iprot.readStructEnd()
14785 
 
14786 
  def write(self, oprot):
14787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14789 
      return
14790 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14791 
    if self.ex is not None:
14792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14793 
      self.ex.write(oprot)
14794 
      oprot.writeFieldEnd()
14795 
    oprot.writeFieldStop()
14796 
    oprot.writeStructEnd()
14797 
 
14798 
  def validate(self):
14799 
    return
14800 
 
14801 
 
14802 
  def __repr__(self):
14803 
    L = ['%s=%r' % (key, value)
14804 
      for key, value in self.__dict__.iteritems()]
14805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14806 
 
14807 
  def __eq__(self, other):
14808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14809 
 
14810 
  def __ne__(self, other):
14811 
    return not (self == other)
14812 
 
14813 
class getNonDeliveredOrdersbyCourier_args:
14814 
  """
14815 
  Attributes:
14816 
   - providerId
14817 
  """
14818 
 
14819 
  thrift_spec = (
14820 
    None, # 0
14821 
    (1, TType.I64, 'providerId', None, None, ), # 1
14822 
  )
14823 
 
14824 
  def __init__(self, providerId=None,):
14825 
    self.providerId = providerId
14826 
 
14827 
  def read(self, iprot):
14828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14830 
      return
14831 
    iprot.readStructBegin()
14832 
    while True:
14833 
      (fname, ftype, fid) = iprot.readFieldBegin()
14834 
      if ftype == TType.STOP:
14835 
        break
14836 
      if fid == 1:
14837 
        if ftype == TType.I64:
14838 
          self.providerId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      else:
14842 
        iprot.skip(ftype)
14843 
      iprot.readFieldEnd()
14844 
    iprot.readStructEnd()
14845 
 
14846 
  def write(self, oprot):
14847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14849 
      return
14850 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14851 
    if self.providerId is not None:
14852 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14853 
      oprot.writeI64(self.providerId)
14854 
      oprot.writeFieldEnd()
14855 
    oprot.writeFieldStop()
14856 
    oprot.writeStructEnd()
14857 
 
14858 
  def validate(self):
14859 
    return
14860 
 
14861 
 
14862 
  def __repr__(self):
14863 
    L = ['%s=%r' % (key, value)
14864 
      for key, value in self.__dict__.iteritems()]
14865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14866 
 
14867 
  def __eq__(self, other):
14868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14869 
 
14870 
  def __ne__(self, other):
14871 
    return not (self == other)
14872 
 
14873 
class getNonDeliveredOrdersbyCourier_result:
14874 
  """
14875 
  Attributes:
14876 
   - success
14877 
  """
14878 
 
14879 
  thrift_spec = (
14880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14881 
  )
14882 
 
14883 
  def __init__(self, success=None,):
14884 
    self.success = success
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
4581 phani.kuma 14895 
      if fid == 0:
14896 
        if ftype == TType.LIST:
14897 
          self.success = []
6188 rajveer 14898 
          (_etype355, _size352) = iprot.readListBegin()
14899 
          for _i356 in xrange(_size352):
14900 
            _elem357 = Order()
14901 
            _elem357.read(iprot)
14902 
            self.success.append(_elem357)
4581 phani.kuma 14903 
          iprot.readListEnd()
14904 
        else:
14905 
          iprot.skip(ftype)
4910 phani.kuma 14906 
      else:
14907 
        iprot.skip(ftype)
14908 
      iprot.readFieldEnd()
14909 
    iprot.readStructEnd()
14910 
 
14911 
  def write(self, oprot):
14912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14914 
      return
14915 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14916 
    if self.success is not None:
14917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14919 
      for iter358 in self.success:
14920 
        iter358.write(oprot)
4910 phani.kuma 14921 
      oprot.writeListEnd()
14922 
      oprot.writeFieldEnd()
14923 
    oprot.writeFieldStop()
14924 
    oprot.writeStructEnd()
14925 
 
14926 
  def validate(self):
14927 
    return
14928 
 
14929 
 
14930 
  def __repr__(self):
14931 
    L = ['%s=%r' % (key, value)
14932 
      for key, value in self.__dict__.iteritems()]
14933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14934 
 
14935 
  def __eq__(self, other):
14936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14937 
 
14938 
  def __ne__(self, other):
14939 
    return not (self == other)
14940 
 
14941 
class markOrdersAsLocalConnected_args:
14942 
  """
14943 
  Attributes:
14944 
   - providerId
14945 
   - local_connected_orders
14946 
  """
14947 
 
14948 
  thrift_spec = (
14949 
    None, # 0
14950 
    (1, TType.I64, 'providerId', None, None, ), # 1
14951 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14952 
  )
14953 
 
14954 
  def __init__(self, providerId=None, local_connected_orders=None,):
14955 
    self.providerId = providerId
14956 
    self.local_connected_orders = local_connected_orders
14957 
 
14958 
  def read(self, iprot):
14959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14961 
      return
14962 
    iprot.readStructBegin()
14963 
    while True:
14964 
      (fname, ftype, fid) = iprot.readFieldBegin()
14965 
      if ftype == TType.STOP:
14966 
        break
14967 
      if fid == 1:
14968 
        if ftype == TType.I64:
14969 
          self.providerId = iprot.readI64();
14970 
        else:
14971 
          iprot.skip(ftype)
14972 
      elif fid == 2:
14973 
        if ftype == TType.MAP:
14974 
          self.local_connected_orders = {}
6188 rajveer 14975 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
14976 
          for _i363 in xrange(_size359):
14977 
            _key364 = iprot.readString();
14978 
            _val365 = iprot.readString();
14979 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 14980 
          iprot.readMapEnd()
14981 
        else:
14982 
          iprot.skip(ftype)
14983 
      else:
14984 
        iprot.skip(ftype)
14985 
      iprot.readFieldEnd()
14986 
    iprot.readStructEnd()
14987 
 
14988 
  def write(self, oprot):
14989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14991 
      return
14992 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14993 
    if self.providerId is not None:
14994 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14995 
      oprot.writeI64(self.providerId)
14996 
      oprot.writeFieldEnd()
14997 
    if self.local_connected_orders is not None:
14998 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14999 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15000 
      for kiter366,viter367 in self.local_connected_orders.items():
15001 
        oprot.writeString(kiter366)
15002 
        oprot.writeString(viter367)
4910 phani.kuma 15003 
      oprot.writeMapEnd()
15004 
      oprot.writeFieldEnd()
15005 
    oprot.writeFieldStop()
15006 
    oprot.writeStructEnd()
15007 
 
15008 
  def validate(self):
15009 
    return
15010 
 
15011 
 
15012 
  def __repr__(self):
15013 
    L = ['%s=%r' % (key, value)
15014 
      for key, value in self.__dict__.iteritems()]
15015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15016 
 
15017 
  def __eq__(self, other):
15018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15019 
 
15020 
  def __ne__(self, other):
15021 
    return not (self == other)
15022 
 
15023 
class markOrdersAsLocalConnected_result:
15024 
  """
15025 
  Attributes:
15026 
   - ex
15027 
  """
15028 
 
15029 
  thrift_spec = (
15030 
    None, # 0
15031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15032 
  )
15033 
 
15034 
  def __init__(self, ex=None,):
15035 
    self.ex = ex
15036 
 
15037 
  def read(self, iprot):
15038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15040 
      return
15041 
    iprot.readStructBegin()
15042 
    while True:
15043 
      (fname, ftype, fid) = iprot.readFieldBegin()
15044 
      if ftype == TType.STOP:
15045 
        break
15046 
      if fid == 1:
3064 chandransh 15047 
        if ftype == TType.STRUCT:
15048 
          self.ex = TransactionServiceException()
15049 
          self.ex.read(iprot)
1627 ankur.sing 15050 
        else:
15051 
          iprot.skip(ftype)
15052 
      else:
15053 
        iprot.skip(ftype)
15054 
      iprot.readFieldEnd()
15055 
    iprot.readStructEnd()
15056 
 
15057 
  def write(self, oprot):
15058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15060 
      return
4910 phani.kuma 15061 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15062 
    if self.ex is not None:
15063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15064 
      self.ex.write(oprot)
15065 
      oprot.writeFieldEnd()
15066 
    oprot.writeFieldStop()
15067 
    oprot.writeStructEnd()
15068 
 
15069 
  def validate(self):
15070 
    return
15071 
 
15072 
 
15073 
  def __repr__(self):
15074 
    L = ['%s=%r' % (key, value)
15075 
      for key, value in self.__dict__.iteritems()]
15076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15077 
 
15078 
  def __eq__(self, other):
15079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15080 
 
15081 
  def __ne__(self, other):
15082 
    return not (self == other)
15083 
 
15084 
class getOrdersNotLocalConnected_args:
15085 
  """
15086 
  Attributes:
15087 
   - providerId
15088 
  """
15089 
 
15090 
  thrift_spec = (
15091 
    None, # 0
15092 
    (1, TType.I64, 'providerId', None, None, ), # 1
15093 
  )
15094 
 
15095 
  def __init__(self, providerId=None,):
15096 
    self.providerId = providerId
15097 
 
15098 
  def read(self, iprot):
15099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15101 
      return
15102 
    iprot.readStructBegin()
15103 
    while True:
15104 
      (fname, ftype, fid) = iprot.readFieldBegin()
15105 
      if ftype == TType.STOP:
15106 
        break
15107 
      if fid == 1:
15108 
        if ftype == TType.I64:
15109 
          self.providerId = iprot.readI64();
15110 
        else:
15111 
          iprot.skip(ftype)
15112 
      else:
15113 
        iprot.skip(ftype)
15114 
      iprot.readFieldEnd()
15115 
    iprot.readStructEnd()
15116 
 
15117 
  def write(self, oprot):
15118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15120 
      return
15121 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15122 
    if self.providerId is not None:
15123 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15124 
      oprot.writeI64(self.providerId)
15125 
      oprot.writeFieldEnd()
15126 
    oprot.writeFieldStop()
15127 
    oprot.writeStructEnd()
15128 
 
15129 
  def validate(self):
15130 
    return
15131 
 
15132 
 
15133 
  def __repr__(self):
15134 
    L = ['%s=%r' % (key, value)
15135 
      for key, value in self.__dict__.iteritems()]
15136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15137 
 
15138 
  def __eq__(self, other):
15139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15140 
 
15141 
  def __ne__(self, other):
15142 
    return not (self == other)
15143 
 
15144 
class getOrdersNotLocalConnected_result:
15145 
  """
15146 
  Attributes:
15147 
   - success
15148 
  """
15149 
 
15150 
  thrift_spec = (
15151 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15152 
  )
15153 
 
15154 
  def __init__(self, success=None,):
15155 
    self.success = success
15156 
 
15157 
  def read(self, iprot):
15158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15160 
      return
15161 
    iprot.readStructBegin()
15162 
    while True:
15163 
      (fname, ftype, fid) = iprot.readFieldBegin()
15164 
      if ftype == TType.STOP:
15165 
        break
15166 
      if fid == 0:
15167 
        if ftype == TType.LIST:
15168 
          self.success = []
6188 rajveer 15169 
          (_etype371, _size368) = iprot.readListBegin()
15170 
          for _i372 in xrange(_size368):
15171 
            _elem373 = Order()
15172 
            _elem373.read(iprot)
15173 
            self.success.append(_elem373)
4910 phani.kuma 15174 
          iprot.readListEnd()
15175 
        else:
15176 
          iprot.skip(ftype)
15177 
      else:
15178 
        iprot.skip(ftype)
15179 
      iprot.readFieldEnd()
15180 
    iprot.readStructEnd()
15181 
 
15182 
  def write(self, oprot):
15183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15185 
      return
15186 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15187 
    if self.success is not None:
15188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15189 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15190 
      for iter374 in self.success:
15191 
        iter374.write(oprot)
4581 phani.kuma 15192 
      oprot.writeListEnd()
15193 
      oprot.writeFieldEnd()
4910 phani.kuma 15194 
    oprot.writeFieldStop()
15195 
    oprot.writeStructEnd()
15196 
 
15197 
  def validate(self):
15198 
    return
15199 
 
15200 
 
15201 
  def __repr__(self):
15202 
    L = ['%s=%r' % (key, value)
15203 
      for key, value in self.__dict__.iteritems()]
15204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15205 
 
15206 
  def __eq__(self, other):
15207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15208 
 
15209 
  def __ne__(self, other):
15210 
    return not (self == other)
15211 
 
15212 
class markOrdersAsDestinationCityReached_args:
15213 
  """
15214 
  Attributes:
15215 
   - providerId
15216 
   - destination_city_reached_orders
15217 
  """
15218 
 
15219 
  thrift_spec = (
15220 
    None, # 0
15221 
    (1, TType.I64, 'providerId', None, None, ), # 1
15222 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15223 
  )
15224 
 
15225 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15226 
    self.providerId = providerId
15227 
    self.destination_city_reached_orders = destination_city_reached_orders
15228 
 
15229 
  def read(self, iprot):
15230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15232 
      return
15233 
    iprot.readStructBegin()
15234 
    while True:
15235 
      (fname, ftype, fid) = iprot.readFieldBegin()
15236 
      if ftype == TType.STOP:
15237 
        break
15238 
      if fid == 1:
15239 
        if ftype == TType.I64:
15240 
          self.providerId = iprot.readI64();
15241 
        else:
15242 
          iprot.skip(ftype)
15243 
      elif fid == 2:
15244 
        if ftype == TType.MAP:
15245 
          self.destination_city_reached_orders = {}
6188 rajveer 15246 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15247 
          for _i379 in xrange(_size375):
15248 
            _key380 = iprot.readString();
15249 
            _val381 = iprot.readString();
15250 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15251 
          iprot.readMapEnd()
15252 
        else:
15253 
          iprot.skip(ftype)
15254 
      else:
15255 
        iprot.skip(ftype)
15256 
      iprot.readFieldEnd()
15257 
    iprot.readStructEnd()
15258 
 
15259 
  def write(self, oprot):
15260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15262 
      return
15263 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15264 
    if self.providerId is not None:
15265 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15266 
      oprot.writeI64(self.providerId)
15267 
      oprot.writeFieldEnd()
15268 
    if self.destination_city_reached_orders is not None:
15269 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15270 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15271 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15272 
        oprot.writeString(kiter382)
15273 
        oprot.writeString(viter383)
4910 phani.kuma 15274 
      oprot.writeMapEnd()
15275 
      oprot.writeFieldEnd()
15276 
    oprot.writeFieldStop()
15277 
    oprot.writeStructEnd()
15278 
 
15279 
  def validate(self):
15280 
    return
15281 
 
15282 
 
15283 
  def __repr__(self):
15284 
    L = ['%s=%r' % (key, value)
15285 
      for key, value in self.__dict__.iteritems()]
15286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15287 
 
15288 
  def __eq__(self, other):
15289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15290 
 
15291 
  def __ne__(self, other):
15292 
    return not (self == other)
15293 
 
15294 
class markOrdersAsDestinationCityReached_result:
15295 
  """
15296 
  Attributes:
15297 
   - ex
15298 
  """
15299 
 
15300 
  thrift_spec = (
15301 
    None, # 0
15302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15303 
  )
15304 
 
15305 
  def __init__(self, ex=None,):
15306 
    self.ex = ex
15307 
 
15308 
  def read(self, iprot):
15309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15311 
      return
15312 
    iprot.readStructBegin()
15313 
    while True:
15314 
      (fname, ftype, fid) = iprot.readFieldBegin()
15315 
      if ftype == TType.STOP:
15316 
        break
15317 
      if fid == 1:
15318 
        if ftype == TType.STRUCT:
15319 
          self.ex = TransactionServiceException()
15320 
          self.ex.read(iprot)
15321 
        else:
15322 
          iprot.skip(ftype)
15323 
      else:
15324 
        iprot.skip(ftype)
15325 
      iprot.readFieldEnd()
15326 
    iprot.readStructEnd()
15327 
 
15328 
  def write(self, oprot):
15329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15331 
      return
15332 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15333 
    if self.ex is not None:
3064 chandransh 15334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15335 
      self.ex.write(oprot)
1627 ankur.sing 15336 
      oprot.writeFieldEnd()
15337 
    oprot.writeFieldStop()
15338 
    oprot.writeStructEnd()
15339 
 
3431 rajveer 15340 
  def validate(self):
15341 
    return
15342 
 
15343 
 
1627 ankur.sing 15344 
  def __repr__(self):
15345 
    L = ['%s=%r' % (key, value)
15346 
      for key, value in self.__dict__.iteritems()]
15347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15348 
 
15349 
  def __eq__(self, other):
15350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15351 
 
15352 
  def __ne__(self, other):
15353 
    return not (self == other)
15354 
 
4910 phani.kuma 15355 
class markOrdersAsFirstDeliveryAttempted_args:
15356 
  """
15357 
  Attributes:
15358 
   - providerId
15359 
   - first_atdl_orders
15360 
  """
15361 
 
15362 
  thrift_spec = (
15363 
    None, # 0
15364 
    (1, TType.I64, 'providerId', None, None, ), # 1
15365 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15366 
  )
15367 
 
15368 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15369 
    self.providerId = providerId
15370 
    self.first_atdl_orders = first_atdl_orders
15371 
 
15372 
  def read(self, iprot):
15373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15375 
      return
15376 
    iprot.readStructBegin()
15377 
    while True:
15378 
      (fname, ftype, fid) = iprot.readFieldBegin()
15379 
      if ftype == TType.STOP:
15380 
        break
15381 
      if fid == 1:
15382 
        if ftype == TType.I64:
15383 
          self.providerId = iprot.readI64();
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      elif fid == 2:
15387 
        if ftype == TType.MAP:
15388 
          self.first_atdl_orders = {}
6188 rajveer 15389 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15390 
          for _i388 in xrange(_size384):
15391 
            _key389 = iprot.readString();
15392 
            _val390 = iprot.readString();
15393 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15394 
          iprot.readMapEnd()
15395 
        else:
15396 
          iprot.skip(ftype)
15397 
      else:
15398 
        iprot.skip(ftype)
15399 
      iprot.readFieldEnd()
15400 
    iprot.readStructEnd()
15401 
 
15402 
  def write(self, oprot):
15403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15405 
      return
15406 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15407 
    if self.providerId is not None:
15408 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15409 
      oprot.writeI64(self.providerId)
15410 
      oprot.writeFieldEnd()
15411 
    if self.first_atdl_orders is not None:
15412 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15413 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15414 
      for kiter391,viter392 in self.first_atdl_orders.items():
15415 
        oprot.writeString(kiter391)
15416 
        oprot.writeString(viter392)
4910 phani.kuma 15417 
      oprot.writeMapEnd()
15418 
      oprot.writeFieldEnd()
15419 
    oprot.writeFieldStop()
15420 
    oprot.writeStructEnd()
15421 
 
15422 
  def validate(self):
15423 
    return
15424 
 
15425 
 
15426 
  def __repr__(self):
15427 
    L = ['%s=%r' % (key, value)
15428 
      for key, value in self.__dict__.iteritems()]
15429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15430 
 
15431 
  def __eq__(self, other):
15432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15433 
 
15434 
  def __ne__(self, other):
15435 
    return not (self == other)
15436 
 
15437 
class markOrdersAsFirstDeliveryAttempted_result:
15438 
  """
15439 
  Attributes:
15440 
   - ex
15441 
  """
15442 
 
15443 
  thrift_spec = (
15444 
    None, # 0
15445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15446 
  )
15447 
 
15448 
  def __init__(self, ex=None,):
15449 
    self.ex = ex
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
15460 
      if fid == 1:
15461 
        if ftype == TType.STRUCT:
15462 
          self.ex = TransactionServiceException()
15463 
          self.ex.read(iprot)
15464 
        else:
15465 
          iprot.skip(ftype)
15466 
      else:
15467 
        iprot.skip(ftype)
15468 
      iprot.readFieldEnd()
15469 
    iprot.readStructEnd()
15470 
 
15471 
  def write(self, oprot):
15472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15474 
      return
15475 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15476 
    if self.ex is not None:
15477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15478 
      self.ex.write(oprot)
15479 
      oprot.writeFieldEnd()
15480 
    oprot.writeFieldStop()
15481 
    oprot.writeStructEnd()
15482 
 
15483 
  def validate(self):
15484 
    return
15485 
 
15486 
 
15487 
  def __repr__(self):
15488 
    L = ['%s=%r' % (key, value)
15489 
      for key, value in self.__dict__.iteritems()]
15490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15491 
 
15492 
  def __eq__(self, other):
15493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15494 
 
15495 
  def __ne__(self, other):
15496 
    return not (self == other)
15497 
 
3064 chandransh 15498 
class getUndeliveredOrders_args:
1886 ankur.sing 15499 
  """
15500 
  Attributes:
3064 chandransh 15501 
   - providerId
15502 
   - warehouseId
1886 ankur.sing 15503 
  """
1627 ankur.sing 15504 
 
1886 ankur.sing 15505 
  thrift_spec = (
15506 
    None, # 0
3064 chandransh 15507 
    (1, TType.I64, 'providerId', None, None, ), # 1
15508 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15509 
  )
15510 
 
3064 chandransh 15511 
  def __init__(self, providerId=None, warehouseId=None,):
15512 
    self.providerId = providerId
15513 
    self.warehouseId = warehouseId
1886 ankur.sing 15514 
 
15515 
  def read(self, iprot):
15516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15518 
      return
15519 
    iprot.readStructBegin()
15520 
    while True:
15521 
      (fname, ftype, fid) = iprot.readFieldBegin()
15522 
      if ftype == TType.STOP:
15523 
        break
15524 
      if fid == 1:
15525 
        if ftype == TType.I64:
3064 chandransh 15526 
          self.providerId = iprot.readI64();
1886 ankur.sing 15527 
        else:
15528 
          iprot.skip(ftype)
3064 chandransh 15529 
      elif fid == 2:
15530 
        if ftype == TType.I64:
15531 
          self.warehouseId = iprot.readI64();
15532 
        else:
15533 
          iprot.skip(ftype)
1886 ankur.sing 15534 
      else:
15535 
        iprot.skip(ftype)
15536 
      iprot.readFieldEnd()
15537 
    iprot.readStructEnd()
15538 
 
15539 
  def write(self, oprot):
15540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15542 
      return
3064 chandransh 15543 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15544 
    if self.providerId is not None:
3064 chandransh 15545 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15546 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15547 
      oprot.writeFieldEnd()
3431 rajveer 15548 
    if self.warehouseId is not None:
3064 chandransh 15549 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15550 
      oprot.writeI64(self.warehouseId)
15551 
      oprot.writeFieldEnd()
1886 ankur.sing 15552 
    oprot.writeFieldStop()
15553 
    oprot.writeStructEnd()
15554 
 
3431 rajveer 15555 
  def validate(self):
15556 
    return
15557 
 
15558 
 
1886 ankur.sing 15559 
  def __repr__(self):
15560 
    L = ['%s=%r' % (key, value)
15561 
      for key, value in self.__dict__.iteritems()]
15562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15563 
 
15564 
  def __eq__(self, other):
15565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15566 
 
15567 
  def __ne__(self, other):
15568 
    return not (self == other)
15569 
 
3064 chandransh 15570 
class getUndeliveredOrders_result:
1886 ankur.sing 15571 
  """
15572 
  Attributes:
15573 
   - success
15574 
  """
15575 
 
15576 
  thrift_spec = (
15577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15578 
  )
15579 
 
15580 
  def __init__(self, success=None,):
15581 
    self.success = success
15582 
 
15583 
  def read(self, iprot):
15584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15586 
      return
15587 
    iprot.readStructBegin()
15588 
    while True:
15589 
      (fname, ftype, fid) = iprot.readFieldBegin()
15590 
      if ftype == TType.STOP:
15591 
        break
15592 
      if fid == 0:
15593 
        if ftype == TType.LIST:
15594 
          self.success = []
6188 rajveer 15595 
          (_etype396, _size393) = iprot.readListBegin()
15596 
          for _i397 in xrange(_size393):
15597 
            _elem398 = Order()
15598 
            _elem398.read(iprot)
15599 
            self.success.append(_elem398)
1886 ankur.sing 15600 
          iprot.readListEnd()
15601 
        else:
15602 
          iprot.skip(ftype)
15603 
      else:
15604 
        iprot.skip(ftype)
15605 
      iprot.readFieldEnd()
15606 
    iprot.readStructEnd()
15607 
 
15608 
  def write(self, oprot):
15609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15611 
      return
3064 chandransh 15612 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15613 
    if self.success is not None:
1886 ankur.sing 15614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15616 
      for iter399 in self.success:
15617 
        iter399.write(oprot)
1886 ankur.sing 15618 
      oprot.writeListEnd()
15619 
      oprot.writeFieldEnd()
15620 
    oprot.writeFieldStop()
15621 
    oprot.writeStructEnd()
15622 
 
3431 rajveer 15623 
  def validate(self):
15624 
    return
15625 
 
15626 
 
1886 ankur.sing 15627 
  def __repr__(self):
15628 
    L = ['%s=%r' % (key, value)
15629 
      for key, value in self.__dict__.iteritems()]
15630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15631 
 
15632 
  def __eq__(self, other):
15633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15634 
 
15635 
  def __ne__(self, other):
15636 
    return not (self == other)
15637 
 
4783 phani.kuma 15638 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15639 
 
15640 
  thrift_spec = (
15641 
  )
15642 
 
15643 
  def read(self, iprot):
15644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15646 
      return
15647 
    iprot.readStructBegin()
15648 
    while True:
15649 
      (fname, ftype, fid) = iprot.readFieldBegin()
15650 
      if ftype == TType.STOP:
15651 
        break
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15662 
    oprot.writeFieldStop()
15663 
    oprot.writeStructEnd()
15664 
 
15665 
  def validate(self):
15666 
    return
15667 
 
15668 
 
15669 
  def __repr__(self):
15670 
    L = ['%s=%r' % (key, value)
15671 
      for key, value in self.__dict__.iteritems()]
15672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15673 
 
15674 
  def __eq__(self, other):
15675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15676 
 
15677 
  def __ne__(self, other):
15678 
    return not (self == other)
15679 
 
15680 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15681 
  """
15682 
  Attributes:
15683 
   - success
15684 
  """
15685 
 
15686 
  thrift_spec = (
15687 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15688 
  )
15689 
 
15690 
  def __init__(self, success=None,):
15691 
    self.success = success
15692 
 
15693 
  def read(self, iprot):
15694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15696 
      return
15697 
    iprot.readStructBegin()
15698 
    while True:
15699 
      (fname, ftype, fid) = iprot.readFieldBegin()
15700 
      if ftype == TType.STOP:
15701 
        break
15702 
      if fid == 0:
15703 
        if ftype == TType.LIST:
15704 
          self.success = []
6188 rajveer 15705 
          (_etype403, _size400) = iprot.readListBegin()
15706 
          for _i404 in xrange(_size400):
15707 
            _elem405 = Order()
15708 
            _elem405.read(iprot)
15709 
            self.success.append(_elem405)
4783 phani.kuma 15710 
          iprot.readListEnd()
15711 
        else:
15712 
          iprot.skip(ftype)
15713 
      else:
15714 
        iprot.skip(ftype)
15715 
      iprot.readFieldEnd()
15716 
    iprot.readStructEnd()
15717 
 
15718 
  def write(self, oprot):
15719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15721 
      return
15722 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15723 
    if self.success is not None:
15724 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15725 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15726 
      for iter406 in self.success:
15727 
        iter406.write(oprot)
4783 phani.kuma 15728 
      oprot.writeListEnd()
15729 
      oprot.writeFieldEnd()
15730 
    oprot.writeFieldStop()
15731 
    oprot.writeStructEnd()
15732 
 
15733 
  def validate(self):
15734 
    return
15735 
 
15736 
 
15737 
  def __repr__(self):
15738 
    L = ['%s=%r' % (key, value)
15739 
      for key, value in self.__dict__.iteritems()]
15740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15741 
 
15742 
  def __eq__(self, other):
15743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15744 
 
15745 
  def __ne__(self, other):
15746 
    return not (self == other)
15747 
 
2536 chandransh 15748 
class toggleDOAFlag_args:
15749 
  """
15750 
  Attributes:
15751 
   - orderId
15752 
  """
1886 ankur.sing 15753 
 
2536 chandransh 15754 
  thrift_spec = (
15755 
    None, # 0
15756 
    (1, TType.I64, 'orderId', None, None, ), # 1
15757 
  )
15758 
 
15759 
  def __init__(self, orderId=None,):
15760 
    self.orderId = orderId
15761 
 
15762 
  def read(self, iprot):
15763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15765 
      return
15766 
    iprot.readStructBegin()
15767 
    while True:
15768 
      (fname, ftype, fid) = iprot.readFieldBegin()
15769 
      if ftype == TType.STOP:
15770 
        break
15771 
      if fid == 1:
15772 
        if ftype == TType.I64:
15773 
          self.orderId = iprot.readI64();
15774 
        else:
15775 
          iprot.skip(ftype)
15776 
      else:
15777 
        iprot.skip(ftype)
15778 
      iprot.readFieldEnd()
15779 
    iprot.readStructEnd()
15780 
 
15781 
  def write(self, oprot):
15782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15784 
      return
15785 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15786 
    if self.orderId is not None:
2536 chandransh 15787 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15788 
      oprot.writeI64(self.orderId)
15789 
      oprot.writeFieldEnd()
15790 
    oprot.writeFieldStop()
15791 
    oprot.writeStructEnd()
15792 
 
3431 rajveer 15793 
  def validate(self):
15794 
    return
15795 
 
15796 
 
2536 chandransh 15797 
  def __repr__(self):
15798 
    L = ['%s=%r' % (key, value)
15799 
      for key, value in self.__dict__.iteritems()]
15800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15801 
 
15802 
  def __eq__(self, other):
15803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15804 
 
15805 
  def __ne__(self, other):
15806 
    return not (self == other)
15807 
 
15808 
class toggleDOAFlag_result:
15809 
  """
15810 
  Attributes:
15811 
   - success
15812 
   - ex
15813 
  """
15814 
 
15815 
  thrift_spec = (
15816 
    (0, TType.BOOL, 'success', None, None, ), # 0
15817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15818 
  )
15819 
 
15820 
  def __init__(self, success=None, ex=None,):
15821 
    self.success = success
15822 
    self.ex = ex
15823 
 
15824 
  def read(self, iprot):
15825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15827 
      return
15828 
    iprot.readStructBegin()
15829 
    while True:
15830 
      (fname, ftype, fid) = iprot.readFieldBegin()
15831 
      if ftype == TType.STOP:
15832 
        break
15833 
      if fid == 0:
15834 
        if ftype == TType.BOOL:
15835 
          self.success = iprot.readBool();
15836 
        else:
15837 
          iprot.skip(ftype)
15838 
      elif fid == 1:
15839 
        if ftype == TType.STRUCT:
15840 
          self.ex = TransactionServiceException()
15841 
          self.ex.read(iprot)
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      else:
15845 
        iprot.skip(ftype)
15846 
      iprot.readFieldEnd()
15847 
    iprot.readStructEnd()
15848 
 
15849 
  def write(self, oprot):
15850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15852 
      return
15853 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15854 
    if self.success is not None:
2536 chandransh 15855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15856 
      oprot.writeBool(self.success)
15857 
      oprot.writeFieldEnd()
3431 rajveer 15858 
    if self.ex is not None:
2536 chandransh 15859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15860 
      self.ex.write(oprot)
15861 
      oprot.writeFieldEnd()
15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
3431 rajveer 15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
2536 chandransh 15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
4712 rajveer 15880 
class markOrderAsDelivered_args:
15881 
  """
15882 
  Attributes:
15883 
   - orderId
15884 
   - deliveryTimestamp
15885 
   - receiver
15886 
  """
15887 
 
15888 
  thrift_spec = None
15889 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15890 
    self.orderId = orderId
15891 
    self.deliveryTimestamp = deliveryTimestamp
15892 
    self.receiver = receiver
15893 
 
15894 
  def read(self, iprot):
15895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15897 
      return
15898 
    iprot.readStructBegin()
15899 
    while True:
15900 
      (fname, ftype, fid) = iprot.readFieldBegin()
15901 
      if ftype == TType.STOP:
15902 
        break
15903 
      if fid == 1:
15904 
        if ftype == TType.I64:
15905 
          self.orderId = iprot.readI64();
15906 
        else:
15907 
          iprot.skip(ftype)
15908 
      elif fid == 2:
15909 
        if ftype == TType.I64:
15910 
          self.deliveryTimestamp = iprot.readI64();
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      elif fid == -1:
15914 
        if ftype == TType.STRING:
15915 
          self.receiver = iprot.readString();
15916 
        else:
15917 
          iprot.skip(ftype)
15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
15927 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15928 
    if self.receiver is not None:
15929 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15930 
      oprot.writeString(self.receiver)
15931 
      oprot.writeFieldEnd()
15932 
    if self.orderId is not None:
15933 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15934 
      oprot.writeI64(self.orderId)
15935 
      oprot.writeFieldEnd()
15936 
    if self.deliveryTimestamp is not None:
15937 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15938 
      oprot.writeI64(self.deliveryTimestamp)
15939 
      oprot.writeFieldEnd()
15940 
    oprot.writeFieldStop()
15941 
    oprot.writeStructEnd()
15942 
 
15943 
  def validate(self):
15944 
    return
15945 
 
15946 
 
15947 
  def __repr__(self):
15948 
    L = ['%s=%r' % (key, value)
15949 
      for key, value in self.__dict__.iteritems()]
15950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15951 
 
15952 
  def __eq__(self, other):
15953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15954 
 
15955 
  def __ne__(self, other):
15956 
    return not (self == other)
15957 
 
15958 
class markOrderAsDelivered_result:
15959 
  """
15960 
  Attributes:
15961 
   - ex
15962 
  """
15963 
 
15964 
  thrift_spec = (
15965 
    None, # 0
15966 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15967 
  )
15968 
 
15969 
  def __init__(self, ex=None,):
15970 
    self.ex = ex
15971 
 
15972 
  def read(self, iprot):
15973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15975 
      return
15976 
    iprot.readStructBegin()
15977 
    while True:
15978 
      (fname, ftype, fid) = iprot.readFieldBegin()
15979 
      if ftype == TType.STOP:
15980 
        break
15981 
      if fid == 1:
15982 
        if ftype == TType.STRUCT:
15983 
          self.ex = TransactionServiceException()
15984 
          self.ex.read(iprot)
15985 
        else:
15986 
          iprot.skip(ftype)
15987 
      else:
15988 
        iprot.skip(ftype)
15989 
      iprot.readFieldEnd()
15990 
    iprot.readStructEnd()
15991 
 
15992 
  def write(self, oprot):
15993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15995 
      return
15996 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15997 
    if self.ex is not None:
15998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15999 
      self.ex.write(oprot)
16000 
      oprot.writeFieldEnd()
16001 
    oprot.writeFieldStop()
16002 
    oprot.writeStructEnd()
16003 
 
16004 
  def validate(self):
16005 
    return
16006 
 
16007 
 
16008 
  def __repr__(self):
16009 
    L = ['%s=%r' % (key, value)
16010 
      for key, value in self.__dict__.iteritems()]
16011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16012 
 
16013 
  def __eq__(self, other):
16014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16015 
 
16016 
  def __ne__(self, other):
16017 
    return not (self == other)
16018 
 
5553 rajveer 16019 
class markOrderAsReceivedAtStore_args:
16020 
  """
16021 
  Attributes:
16022 
   - orderId
16023 
   - deliveryTimestamp
16024 
  """
16025 
 
16026 
  thrift_spec = (
16027 
    None, # 0
16028 
    (1, TType.I64, 'orderId', None, None, ), # 1
16029 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16030 
  )
16031 
 
16032 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16033 
    self.orderId = orderId
16034 
    self.deliveryTimestamp = deliveryTimestamp
16035 
 
16036 
  def read(self, iprot):
16037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16039 
      return
16040 
    iprot.readStructBegin()
16041 
    while True:
16042 
      (fname, ftype, fid) = iprot.readFieldBegin()
16043 
      if ftype == TType.STOP:
16044 
        break
16045 
      if fid == 1:
16046 
        if ftype == TType.I64:
16047 
          self.orderId = iprot.readI64();
16048 
        else:
16049 
          iprot.skip(ftype)
16050 
      elif fid == 2:
16051 
        if ftype == TType.I64:
16052 
          self.deliveryTimestamp = iprot.readI64();
16053 
        else:
16054 
          iprot.skip(ftype)
16055 
      else:
16056 
        iprot.skip(ftype)
16057 
      iprot.readFieldEnd()
16058 
    iprot.readStructEnd()
16059 
 
16060 
  def write(self, oprot):
16061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16063 
      return
16064 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16065 
    if self.orderId is not None:
16066 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16067 
      oprot.writeI64(self.orderId)
16068 
      oprot.writeFieldEnd()
16069 
    if self.deliveryTimestamp is not None:
16070 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16071 
      oprot.writeI64(self.deliveryTimestamp)
16072 
      oprot.writeFieldEnd()
16073 
    oprot.writeFieldStop()
16074 
    oprot.writeStructEnd()
16075 
 
16076 
  def validate(self):
16077 
    return
16078 
 
16079 
 
16080 
  def __repr__(self):
16081 
    L = ['%s=%r' % (key, value)
16082 
      for key, value in self.__dict__.iteritems()]
16083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16084 
 
16085 
  def __eq__(self, other):
16086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16087 
 
16088 
  def __ne__(self, other):
16089 
    return not (self == other)
16090 
 
16091 
class markOrderAsReceivedAtStore_result:
16092 
  """
16093 
  Attributes:
16094 
   - ex
16095 
  """
16096 
 
16097 
  thrift_spec = (
16098 
    None, # 0
16099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16100 
  )
16101 
 
16102 
  def __init__(self, ex=None,):
16103 
    self.ex = ex
16104 
 
16105 
  def read(self, iprot):
16106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16108 
      return
16109 
    iprot.readStructBegin()
16110 
    while True:
16111 
      (fname, ftype, fid) = iprot.readFieldBegin()
16112 
      if ftype == TType.STOP:
16113 
        break
16114 
      if fid == 1:
16115 
        if ftype == TType.STRUCT:
16116 
          self.ex = TransactionServiceException()
16117 
          self.ex.read(iprot)
16118 
        else:
16119 
          iprot.skip(ftype)
16120 
      else:
16121 
        iprot.skip(ftype)
16122 
      iprot.readFieldEnd()
16123 
    iprot.readStructEnd()
16124 
 
16125 
  def write(self, oprot):
16126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16128 
      return
16129 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16130 
    if self.ex is not None:
16131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16132 
      self.ex.write(oprot)
16133 
      oprot.writeFieldEnd()
16134 
    oprot.writeFieldStop()
16135 
    oprot.writeStructEnd()
16136 
 
16137 
  def validate(self):
16138 
    return
16139 
 
16140 
 
16141 
  def __repr__(self):
16142 
    L = ['%s=%r' % (key, value)
16143 
      for key, value in self.__dict__.iteritems()]
16144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16145 
 
16146 
  def __eq__(self, other):
16147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16148 
 
16149 
  def __ne__(self, other):
16150 
    return not (self == other)
16151 
 
4454 rajveer 16152 
class markOrderDoaRequestReceived_args:
16153 
  """
16154 
  Attributes:
16155 
   - orderId
16156 
  """
16157 
 
16158 
  thrift_spec = (
16159 
    None, # 0
16160 
    (1, TType.I64, 'orderId', None, None, ), # 1
16161 
  )
16162 
 
16163 
  def __init__(self, orderId=None,):
16164 
    self.orderId = orderId
16165 
 
16166 
  def read(self, iprot):
16167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16169 
      return
16170 
    iprot.readStructBegin()
16171 
    while True:
16172 
      (fname, ftype, fid) = iprot.readFieldBegin()
16173 
      if ftype == TType.STOP:
16174 
        break
16175 
      if fid == 1:
16176 
        if ftype == TType.I64:
16177 
          self.orderId = iprot.readI64();
16178 
        else:
16179 
          iprot.skip(ftype)
16180 
      else:
16181 
        iprot.skip(ftype)
16182 
      iprot.readFieldEnd()
16183 
    iprot.readStructEnd()
16184 
 
16185 
  def write(self, oprot):
16186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16188 
      return
16189 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16190 
    if self.orderId is not None:
16191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16192 
      oprot.writeI64(self.orderId)
16193 
      oprot.writeFieldEnd()
16194 
    oprot.writeFieldStop()
16195 
    oprot.writeStructEnd()
16196 
 
16197 
  def validate(self):
16198 
    return
16199 
 
16200 
 
16201 
  def __repr__(self):
16202 
    L = ['%s=%r' % (key, value)
16203 
      for key, value in self.__dict__.iteritems()]
16204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16205 
 
16206 
  def __eq__(self, other):
16207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16208 
 
16209 
  def __ne__(self, other):
16210 
    return not (self == other)
16211 
 
16212 
class markOrderDoaRequestReceived_result:
16213 
  """
16214 
  Attributes:
16215 
   - success
16216 
   - ex
16217 
  """
16218 
 
16219 
  thrift_spec = (
16220 
    (0, TType.BOOL, 'success', None, None, ), # 0
16221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16222 
  )
16223 
 
16224 
  def __init__(self, success=None, ex=None,):
16225 
    self.success = success
16226 
    self.ex = ex
16227 
 
16228 
  def read(self, iprot):
16229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16231 
      return
16232 
    iprot.readStructBegin()
16233 
    while True:
16234 
      (fname, ftype, fid) = iprot.readFieldBegin()
16235 
      if ftype == TType.STOP:
16236 
        break
16237 
      if fid == 0:
16238 
        if ftype == TType.BOOL:
16239 
          self.success = iprot.readBool();
16240 
        else:
16241 
          iprot.skip(ftype)
16242 
      elif fid == 1:
16243 
        if ftype == TType.STRUCT:
16244 
          self.ex = TransactionServiceException()
16245 
          self.ex.read(iprot)
16246 
        else:
16247 
          iprot.skip(ftype)
16248 
      else:
16249 
        iprot.skip(ftype)
16250 
      iprot.readFieldEnd()
16251 
    iprot.readStructEnd()
16252 
 
16253 
  def write(self, oprot):
16254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16256 
      return
16257 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16258 
    if self.success is not None:
16259 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16260 
      oprot.writeBool(self.success)
16261 
      oprot.writeFieldEnd()
16262 
    if self.ex is not None:
16263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16264 
      self.ex.write(oprot)
16265 
      oprot.writeFieldEnd()
16266 
    oprot.writeFieldStop()
16267 
    oprot.writeStructEnd()
16268 
 
16269 
  def validate(self):
16270 
    return
16271 
 
16272 
 
16273 
  def __repr__(self):
16274 
    L = ['%s=%r' % (key, value)
16275 
      for key, value in self.__dict__.iteritems()]
16276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16277 
 
16278 
  def __eq__(self, other):
16279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16280 
 
16281 
  def __ne__(self, other):
16282 
    return not (self == other)
16283 
 
16284 
class markOrderDoaRequestAuthorized_args:
16285 
  """
16286 
  Attributes:
16287 
   - orderId
16288 
   - isAuthorized
16289 
  """
16290 
 
16291 
  thrift_spec = (
16292 
    None, # 0
16293 
    (1, TType.I64, 'orderId', None, None, ), # 1
16294 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16295 
  )
16296 
 
16297 
  def __init__(self, orderId=None, isAuthorized=None,):
16298 
    self.orderId = orderId
16299 
    self.isAuthorized = isAuthorized
16300 
 
16301 
  def read(self, iprot):
16302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16304 
      return
16305 
    iprot.readStructBegin()
16306 
    while True:
16307 
      (fname, ftype, fid) = iprot.readFieldBegin()
16308 
      if ftype == TType.STOP:
16309 
        break
16310 
      if fid == 1:
16311 
        if ftype == TType.I64:
16312 
          self.orderId = iprot.readI64();
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      elif fid == 2:
16316 
        if ftype == TType.BOOL:
16317 
          self.isAuthorized = iprot.readBool();
16318 
        else:
16319 
          iprot.skip(ftype)
16320 
      else:
16321 
        iprot.skip(ftype)
16322 
      iprot.readFieldEnd()
16323 
    iprot.readStructEnd()
16324 
 
16325 
  def write(self, oprot):
16326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16328 
      return
16329 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16330 
    if self.orderId is not None:
16331 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16332 
      oprot.writeI64(self.orderId)
16333 
      oprot.writeFieldEnd()
16334 
    if self.isAuthorized is not None:
16335 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16336 
      oprot.writeBool(self.isAuthorized)
16337 
      oprot.writeFieldEnd()
16338 
    oprot.writeFieldStop()
16339 
    oprot.writeStructEnd()
16340 
 
16341 
  def validate(self):
16342 
    return
16343 
 
16344 
 
16345 
  def __repr__(self):
16346 
    L = ['%s=%r' % (key, value)
16347 
      for key, value in self.__dict__.iteritems()]
16348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16349 
 
16350 
  def __eq__(self, other):
16351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16352 
 
16353 
  def __ne__(self, other):
16354 
    return not (self == other)
16355 
 
16356 
class markOrderDoaRequestAuthorized_result:
16357 
  """
16358 
  Attributes:
16359 
   - success
16360 
   - ex
16361 
  """
16362 
 
16363 
  thrift_spec = (
16364 
    (0, TType.BOOL, 'success', None, None, ), # 0
16365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16366 
  )
16367 
 
16368 
  def __init__(self, success=None, ex=None,):
16369 
    self.success = success
16370 
    self.ex = ex
16371 
 
16372 
  def read(self, iprot):
16373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16375 
      return
16376 
    iprot.readStructBegin()
16377 
    while True:
16378 
      (fname, ftype, fid) = iprot.readFieldBegin()
16379 
      if ftype == TType.STOP:
16380 
        break
16381 
      if fid == 0:
16382 
        if ftype == TType.BOOL:
16383 
          self.success = iprot.readBool();
16384 
        else:
16385 
          iprot.skip(ftype)
16386 
      elif fid == 1:
16387 
        if ftype == TType.STRUCT:
16388 
          self.ex = TransactionServiceException()
16389 
          self.ex.read(iprot)
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16402 
    if self.success is not None:
16403 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16404 
      oprot.writeBool(self.success)
16405 
      oprot.writeFieldEnd()
16406 
    if self.ex is not None:
16407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16408 
      self.ex.write(oprot)
16409 
      oprot.writeFieldEnd()
16410 
    oprot.writeFieldStop()
16411 
    oprot.writeStructEnd()
16412 
 
16413 
  def validate(self):
16414 
    return
16415 
 
16416 
 
16417 
  def __repr__(self):
16418 
    L = ['%s=%r' % (key, value)
16419 
      for key, value in self.__dict__.iteritems()]
16420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16421 
 
16422 
  def __eq__(self, other):
16423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16424 
 
16425 
  def __ne__(self, other):
16426 
    return not (self == other)
16427 
 
4488 rajveer 16428 
class markOrderReturnRequestReceived_args:
16429 
  """
16430 
  Attributes:
16431 
   - orderId
16432 
  """
16433 
 
16434 
  thrift_spec = (
16435 
    None, # 0
16436 
    (1, TType.I64, 'orderId', None, None, ), # 1
16437 
  )
16438 
 
16439 
  def __init__(self, orderId=None,):
16440 
    self.orderId = orderId
16441 
 
16442 
  def read(self, iprot):
16443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16445 
      return
16446 
    iprot.readStructBegin()
16447 
    while True:
16448 
      (fname, ftype, fid) = iprot.readFieldBegin()
16449 
      if ftype == TType.STOP:
16450 
        break
16451 
      if fid == 1:
16452 
        if ftype == TType.I64:
16453 
          self.orderId = iprot.readI64();
16454 
        else:
16455 
          iprot.skip(ftype)
16456 
      else:
16457 
        iprot.skip(ftype)
16458 
      iprot.readFieldEnd()
16459 
    iprot.readStructEnd()
16460 
 
16461 
  def write(self, oprot):
16462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16464 
      return
16465 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16466 
    if self.orderId is not None:
16467 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16468 
      oprot.writeI64(self.orderId)
16469 
      oprot.writeFieldEnd()
16470 
    oprot.writeFieldStop()
16471 
    oprot.writeStructEnd()
16472 
 
16473 
  def validate(self):
16474 
    return
16475 
 
16476 
 
16477 
  def __repr__(self):
16478 
    L = ['%s=%r' % (key, value)
16479 
      for key, value in self.__dict__.iteritems()]
16480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16481 
 
16482 
  def __eq__(self, other):
16483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16484 
 
16485 
  def __ne__(self, other):
16486 
    return not (self == other)
16487 
 
16488 
class markOrderReturnRequestReceived_result:
16489 
  """
16490 
  Attributes:
16491 
   - success
16492 
   - ex
16493 
  """
16494 
 
16495 
  thrift_spec = (
16496 
    (0, TType.BOOL, 'success', None, None, ), # 0
16497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16498 
  )
16499 
 
16500 
  def __init__(self, success=None, ex=None,):
16501 
    self.success = success
16502 
    self.ex = ex
16503 
 
16504 
  def read(self, iprot):
16505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16507 
      return
16508 
    iprot.readStructBegin()
16509 
    while True:
16510 
      (fname, ftype, fid) = iprot.readFieldBegin()
16511 
      if ftype == TType.STOP:
16512 
        break
16513 
      if fid == 0:
16514 
        if ftype == TType.BOOL:
16515 
          self.success = iprot.readBool();
16516 
        else:
16517 
          iprot.skip(ftype)
16518 
      elif fid == 1:
16519 
        if ftype == TType.STRUCT:
16520 
          self.ex = TransactionServiceException()
16521 
          self.ex.read(iprot)
16522 
        else:
16523 
          iprot.skip(ftype)
16524 
      else:
16525 
        iprot.skip(ftype)
16526 
      iprot.readFieldEnd()
16527 
    iprot.readStructEnd()
16528 
 
16529 
  def write(self, oprot):
16530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16532 
      return
16533 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16534 
    if self.success is not None:
16535 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16536 
      oprot.writeBool(self.success)
16537 
      oprot.writeFieldEnd()
16538 
    if self.ex is not None:
16539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16540 
      self.ex.write(oprot)
16541 
      oprot.writeFieldEnd()
16542 
    oprot.writeFieldStop()
16543 
    oprot.writeStructEnd()
16544 
 
16545 
  def validate(self):
16546 
    return
16547 
 
16548 
 
16549 
  def __repr__(self):
16550 
    L = ['%s=%r' % (key, value)
16551 
      for key, value in self.__dict__.iteritems()]
16552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16553 
 
16554 
  def __eq__(self, other):
16555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16556 
 
16557 
  def __ne__(self, other):
16558 
    return not (self == other)
16559 
 
16560 
class markOrderReturnRequestAuthorized_args:
16561 
  """
16562 
  Attributes:
16563 
   - orderId
16564 
   - isAuthorized
16565 
  """
16566 
 
16567 
  thrift_spec = (
16568 
    None, # 0
16569 
    (1, TType.I64, 'orderId', None, None, ), # 1
16570 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16571 
  )
16572 
 
16573 
  def __init__(self, orderId=None, isAuthorized=None,):
16574 
    self.orderId = orderId
16575 
    self.isAuthorized = isAuthorized
16576 
 
16577 
  def read(self, iprot):
16578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16580 
      return
16581 
    iprot.readStructBegin()
16582 
    while True:
16583 
      (fname, ftype, fid) = iprot.readFieldBegin()
16584 
      if ftype == TType.STOP:
16585 
        break
16586 
      if fid == 1:
16587 
        if ftype == TType.I64:
16588 
          self.orderId = iprot.readI64();
16589 
        else:
16590 
          iprot.skip(ftype)
16591 
      elif fid == 2:
16592 
        if ftype == TType.BOOL:
16593 
          self.isAuthorized = iprot.readBool();
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      else:
16597 
        iprot.skip(ftype)
16598 
      iprot.readFieldEnd()
16599 
    iprot.readStructEnd()
16600 
 
16601 
  def write(self, oprot):
16602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16604 
      return
16605 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16606 
    if self.orderId is not None:
16607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16608 
      oprot.writeI64(self.orderId)
16609 
      oprot.writeFieldEnd()
16610 
    if self.isAuthorized is not None:
16611 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16612 
      oprot.writeBool(self.isAuthorized)
16613 
      oprot.writeFieldEnd()
16614 
    oprot.writeFieldStop()
16615 
    oprot.writeStructEnd()
16616 
 
16617 
  def validate(self):
16618 
    return
16619 
 
16620 
 
16621 
  def __repr__(self):
16622 
    L = ['%s=%r' % (key, value)
16623 
      for key, value in self.__dict__.iteritems()]
16624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16625 
 
16626 
  def __eq__(self, other):
16627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16628 
 
16629 
  def __ne__(self, other):
16630 
    return not (self == other)
16631 
 
16632 
class markOrderReturnRequestAuthorized_result:
16633 
  """
16634 
  Attributes:
16635 
   - success
16636 
   - ex
16637 
  """
16638 
 
16639 
  thrift_spec = (
16640 
    (0, TType.BOOL, 'success', None, None, ), # 0
16641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16642 
  )
16643 
 
16644 
  def __init__(self, success=None, ex=None,):
16645 
    self.success = success
16646 
    self.ex = ex
16647 
 
16648 
  def read(self, iprot):
16649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16651 
      return
16652 
    iprot.readStructBegin()
16653 
    while True:
16654 
      (fname, ftype, fid) = iprot.readFieldBegin()
16655 
      if ftype == TType.STOP:
16656 
        break
16657 
      if fid == 0:
16658 
        if ftype == TType.BOOL:
16659 
          self.success = iprot.readBool();
16660 
        else:
16661 
          iprot.skip(ftype)
16662 
      elif fid == 1:
16663 
        if ftype == TType.STRUCT:
16664 
          self.ex = TransactionServiceException()
16665 
          self.ex.read(iprot)
16666 
        else:
16667 
          iprot.skip(ftype)
16668 
      else:
16669 
        iprot.skip(ftype)
16670 
      iprot.readFieldEnd()
16671 
    iprot.readStructEnd()
16672 
 
16673 
  def write(self, oprot):
16674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16676 
      return
16677 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16678 
    if self.success is not None:
16679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16680 
      oprot.writeBool(self.success)
16681 
      oprot.writeFieldEnd()
16682 
    if self.ex is not None:
16683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16684 
      self.ex.write(oprot)
16685 
      oprot.writeFieldEnd()
16686 
    oprot.writeFieldStop()
16687 
    oprot.writeStructEnd()
16688 
 
16689 
  def validate(self):
16690 
    return
16691 
 
16692 
 
16693 
  def __repr__(self):
16694 
    L = ['%s=%r' % (key, value)
16695 
      for key, value in self.__dict__.iteritems()]
16696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16697 
 
16698 
  def __eq__(self, other):
16699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16700 
 
16701 
  def __ne__(self, other):
16702 
    return not (self == other)
16703 
 
2536 chandransh 16704 
class requestPickupNumber_args:
16705 
  """
16706 
  Attributes:
16707 
   - orderId
4579 rajveer 16708 
   - providerId
2536 chandransh 16709 
  """
16710 
 
16711 
  thrift_spec = (
16712 
    None, # 0
16713 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16714 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16715 
  )
16716 
 
4579 rajveer 16717 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16718 
    self.orderId = orderId
4579 rajveer 16719 
    self.providerId = providerId
2536 chandransh 16720 
 
16721 
  def read(self, iprot):
16722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16724 
      return
16725 
    iprot.readStructBegin()
16726 
    while True:
16727 
      (fname, ftype, fid) = iprot.readFieldBegin()
16728 
      if ftype == TType.STOP:
16729 
        break
16730 
      if fid == 1:
16731 
        if ftype == TType.I64:
16732 
          self.orderId = iprot.readI64();
16733 
        else:
16734 
          iprot.skip(ftype)
4579 rajveer 16735 
      elif fid == 2:
16736 
        if ftype == TType.I64:
16737 
          self.providerId = iprot.readI64();
16738 
        else:
16739 
          iprot.skip(ftype)
2536 chandransh 16740 
      else:
16741 
        iprot.skip(ftype)
16742 
      iprot.readFieldEnd()
16743 
    iprot.readStructEnd()
16744 
 
16745 
  def write(self, oprot):
16746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16748 
      return
16749 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16750 
    if self.orderId is not None:
2536 chandransh 16751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16752 
      oprot.writeI64(self.orderId)
16753 
      oprot.writeFieldEnd()
4579 rajveer 16754 
    if self.providerId is not None:
16755 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16756 
      oprot.writeI64(self.providerId)
16757 
      oprot.writeFieldEnd()
2536 chandransh 16758 
    oprot.writeFieldStop()
16759 
    oprot.writeStructEnd()
16760 
 
3431 rajveer 16761 
  def validate(self):
16762 
    return
16763 
 
16764 
 
2536 chandransh 16765 
  def __repr__(self):
16766 
    L = ['%s=%r' % (key, value)
16767 
      for key, value in self.__dict__.iteritems()]
16768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16769 
 
16770 
  def __eq__(self, other):
16771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16772 
 
16773 
  def __ne__(self, other):
16774 
    return not (self == other)
16775 
 
16776 
class requestPickupNumber_result:
16777 
  """
16778 
  Attributes:
16779 
   - success
16780 
   - ex
16781 
  """
16782 
 
16783 
  thrift_spec = (
16784 
    (0, TType.BOOL, 'success', None, None, ), # 0
16785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16786 
  )
16787 
 
16788 
  def __init__(self, success=None, ex=None,):
16789 
    self.success = success
16790 
    self.ex = ex
16791 
 
16792 
  def read(self, iprot):
16793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16795 
      return
16796 
    iprot.readStructBegin()
16797 
    while True:
16798 
      (fname, ftype, fid) = iprot.readFieldBegin()
16799 
      if ftype == TType.STOP:
16800 
        break
16801 
      if fid == 0:
16802 
        if ftype == TType.BOOL:
16803 
          self.success = iprot.readBool();
16804 
        else:
16805 
          iprot.skip(ftype)
16806 
      elif fid == 1:
16807 
        if ftype == TType.STRUCT:
16808 
          self.ex = TransactionServiceException()
16809 
          self.ex.read(iprot)
16810 
        else:
16811 
          iprot.skip(ftype)
16812 
      else:
16813 
        iprot.skip(ftype)
16814 
      iprot.readFieldEnd()
16815 
    iprot.readStructEnd()
16816 
 
16817 
  def write(self, oprot):
16818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16820 
      return
16821 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16822 
    if self.success is not None:
2536 chandransh 16823 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16824 
      oprot.writeBool(self.success)
16825 
      oprot.writeFieldEnd()
3431 rajveer 16826 
    if self.ex is not None:
2536 chandransh 16827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16828 
      self.ex.write(oprot)
16829 
      oprot.writeFieldEnd()
16830 
    oprot.writeFieldStop()
16831 
    oprot.writeStructEnd()
16832 
 
3431 rajveer 16833 
  def validate(self):
16834 
    return
16835 
 
16836 
 
2536 chandransh 16837 
  def __repr__(self):
16838 
    L = ['%s=%r' % (key, value)
16839 
      for key, value in self.__dict__.iteritems()]
16840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16841 
 
16842 
  def __eq__(self, other):
16843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16844 
 
16845 
  def __ne__(self, other):
16846 
    return not (self == other)
16847 
 
16848 
class authorizePickup_args:
16849 
  """
16850 
  Attributes:
16851 
   - orderId
16852 
   - pickupNumber
4602 rajveer 16853 
   - providerId
2536 chandransh 16854 
  """
16855 
 
16856 
  thrift_spec = (
16857 
    None, # 0
16858 
    (1, TType.I64, 'orderId', None, None, ), # 1
16859 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16860 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16861 
  )
16862 
 
4602 rajveer 16863 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16864 
    self.orderId = orderId
16865 
    self.pickupNumber = pickupNumber
4602 rajveer 16866 
    self.providerId = providerId
2536 chandransh 16867 
 
16868 
  def read(self, iprot):
16869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16871 
      return
16872 
    iprot.readStructBegin()
16873 
    while True:
16874 
      (fname, ftype, fid) = iprot.readFieldBegin()
16875 
      if ftype == TType.STOP:
16876 
        break
16877 
      if fid == 1:
16878 
        if ftype == TType.I64:
16879 
          self.orderId = iprot.readI64();
16880 
        else:
16881 
          iprot.skip(ftype)
16882 
      elif fid == 2:
16883 
        if ftype == TType.STRING:
16884 
          self.pickupNumber = iprot.readString();
16885 
        else:
16886 
          iprot.skip(ftype)
4602 rajveer 16887 
      elif fid == 3:
16888 
        if ftype == TType.I64:
16889 
          self.providerId = iprot.readI64();
16890 
        else:
16891 
          iprot.skip(ftype)
2536 chandransh 16892 
      else:
16893 
        iprot.skip(ftype)
16894 
      iprot.readFieldEnd()
16895 
    iprot.readStructEnd()
16896 
 
16897 
  def write(self, oprot):
16898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16900 
      return
16901 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16902 
    if self.orderId is not None:
2536 chandransh 16903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16904 
      oprot.writeI64(self.orderId)
16905 
      oprot.writeFieldEnd()
3431 rajveer 16906 
    if self.pickupNumber is not None:
2536 chandransh 16907 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16908 
      oprot.writeString(self.pickupNumber)
16909 
      oprot.writeFieldEnd()
4602 rajveer 16910 
    if self.providerId is not None:
16911 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16912 
      oprot.writeI64(self.providerId)
16913 
      oprot.writeFieldEnd()
2536 chandransh 16914 
    oprot.writeFieldStop()
16915 
    oprot.writeStructEnd()
16916 
 
3431 rajveer 16917 
  def validate(self):
16918 
    return
16919 
 
16920 
 
2536 chandransh 16921 
  def __repr__(self):
16922 
    L = ['%s=%r' % (key, value)
16923 
      for key, value in self.__dict__.iteritems()]
16924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16925 
 
16926 
  def __eq__(self, other):
16927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16928 
 
16929 
  def __ne__(self, other):
16930 
    return not (self == other)
16931 
 
16932 
class authorizePickup_result:
16933 
  """
16934 
  Attributes:
16935 
   - success
16936 
   - ex
16937 
  """
16938 
 
16939 
  thrift_spec = (
16940 
    (0, TType.BOOL, 'success', None, None, ), # 0
16941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16942 
  )
16943 
 
16944 
  def __init__(self, success=None, ex=None,):
16945 
    self.success = success
16946 
    self.ex = ex
16947 
 
16948 
  def read(self, iprot):
16949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16951 
      return
16952 
    iprot.readStructBegin()
16953 
    while True:
16954 
      (fname, ftype, fid) = iprot.readFieldBegin()
16955 
      if ftype == TType.STOP:
16956 
        break
16957 
      if fid == 0:
16958 
        if ftype == TType.BOOL:
16959 
          self.success = iprot.readBool();
16960 
        else:
16961 
          iprot.skip(ftype)
16962 
      elif fid == 1:
16963 
        if ftype == TType.STRUCT:
16964 
          self.ex = TransactionServiceException()
16965 
          self.ex.read(iprot)
16966 
        else:
16967 
          iprot.skip(ftype)
16968 
      else:
16969 
        iprot.skip(ftype)
16970 
      iprot.readFieldEnd()
16971 
    iprot.readStructEnd()
16972 
 
16973 
  def write(self, oprot):
16974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16976 
      return
16977 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16978 
    if self.success is not None:
2536 chandransh 16979 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16980 
      oprot.writeBool(self.success)
16981 
      oprot.writeFieldEnd()
3431 rajveer 16982 
    if self.ex is not None:
2536 chandransh 16983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16984 
      self.ex.write(oprot)
16985 
      oprot.writeFieldEnd()
16986 
    oprot.writeFieldStop()
16987 
    oprot.writeStructEnd()
16988 
 
3431 rajveer 16989 
  def validate(self):
16990 
    return
16991 
 
16992 
 
2536 chandransh 16993 
  def __repr__(self):
16994 
    L = ['%s=%r' % (key, value)
16995 
      for key, value in self.__dict__.iteritems()]
16996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16997 
 
16998 
  def __eq__(self, other):
16999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17000 
 
17001 
  def __ne__(self, other):
17002 
    return not (self == other)
17003 
 
2764 chandransh 17004 
class markDoasAsPickedUp_args:
17005 
  """
17006 
  Attributes:
17007 
   - providerId
17008 
   - pickupDetails
17009 
  """
17010 
 
17011 
  thrift_spec = (
17012 
    None, # 0
17013 
    (1, TType.I64, 'providerId', None, None, ), # 1
17014 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17015 
  )
17016 
 
17017 
  def __init__(self, providerId=None, pickupDetails=None,):
17018 
    self.providerId = providerId
17019 
    self.pickupDetails = pickupDetails
17020 
 
17021 
  def read(self, iprot):
17022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17024 
      return
17025 
    iprot.readStructBegin()
17026 
    while True:
17027 
      (fname, ftype, fid) = iprot.readFieldBegin()
17028 
      if ftype == TType.STOP:
17029 
        break
17030 
      if fid == 1:
17031 
        if ftype == TType.I64:
17032 
          self.providerId = iprot.readI64();
17033 
        else:
17034 
          iprot.skip(ftype)
17035 
      elif fid == 2:
17036 
        if ftype == TType.MAP:
17037 
          self.pickupDetails = {}
6188 rajveer 17038 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17039 
          for _i411 in xrange(_size407):
17040 
            _key412 = iprot.readString();
17041 
            _val413 = iprot.readString();
17042 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17043 
          iprot.readMapEnd()
17044 
        else:
17045 
          iprot.skip(ftype)
17046 
      else:
17047 
        iprot.skip(ftype)
17048 
      iprot.readFieldEnd()
17049 
    iprot.readStructEnd()
17050 
 
17051 
  def write(self, oprot):
17052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17054 
      return
17055 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17056 
    if self.providerId is not None:
2764 chandransh 17057 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17058 
      oprot.writeI64(self.providerId)
17059 
      oprot.writeFieldEnd()
3431 rajveer 17060 
    if self.pickupDetails is not None:
2764 chandransh 17061 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17062 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17063 
      for kiter414,viter415 in self.pickupDetails.items():
17064 
        oprot.writeString(kiter414)
17065 
        oprot.writeString(viter415)
2764 chandransh 17066 
      oprot.writeMapEnd()
17067 
      oprot.writeFieldEnd()
17068 
    oprot.writeFieldStop()
17069 
    oprot.writeStructEnd()
17070 
 
3431 rajveer 17071 
  def validate(self):
17072 
    return
17073 
 
17074 
 
2764 chandransh 17075 
  def __repr__(self):
17076 
    L = ['%s=%r' % (key, value)
17077 
      for key, value in self.__dict__.iteritems()]
17078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17079 
 
17080 
  def __eq__(self, other):
17081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17082 
 
17083 
  def __ne__(self, other):
17084 
    return not (self == other)
17085 
 
17086 
class markDoasAsPickedUp_result:
4910 phani.kuma 17087 
 
17088 
  thrift_spec = (
17089 
  )
17090 
 
17091 
  def read(self, iprot):
17092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17094 
      return
17095 
    iprot.readStructBegin()
17096 
    while True:
17097 
      (fname, ftype, fid) = iprot.readFieldBegin()
17098 
      if ftype == TType.STOP:
17099 
        break
17100 
      else:
17101 
        iprot.skip(ftype)
17102 
      iprot.readFieldEnd()
17103 
    iprot.readStructEnd()
17104 
 
17105 
  def write(self, oprot):
17106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17108 
      return
17109 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17110 
    oprot.writeFieldStop()
17111 
    oprot.writeStructEnd()
17112 
 
17113 
  def validate(self):
17114 
    return
17115 
 
17116 
 
17117 
  def __repr__(self):
17118 
    L = ['%s=%r' % (key, value)
17119 
      for key, value in self.__dict__.iteritems()]
17120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17121 
 
17122 
  def __eq__(self, other):
17123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17124 
 
17125 
  def __ne__(self, other):
17126 
    return not (self == other)
17127 
 
17128 
class getDoasNotPickedUp_args:
2764 chandransh 17129 
  """
17130 
  Attributes:
4910 phani.kuma 17131 
   - providerId
17132 
  """
17133 
 
17134 
  thrift_spec = (
17135 
    None, # 0
17136 
    (1, TType.I64, 'providerId', None, None, ), # 1
17137 
  )
17138 
 
17139 
  def __init__(self, providerId=None,):
17140 
    self.providerId = providerId
17141 
 
17142 
  def read(self, iprot):
17143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17145 
      return
17146 
    iprot.readStructBegin()
17147 
    while True:
17148 
      (fname, ftype, fid) = iprot.readFieldBegin()
17149 
      if ftype == TType.STOP:
17150 
        break
17151 
      if fid == 1:
17152 
        if ftype == TType.I64:
17153 
          self.providerId = iprot.readI64();
17154 
        else:
17155 
          iprot.skip(ftype)
17156 
      else:
17157 
        iprot.skip(ftype)
17158 
      iprot.readFieldEnd()
17159 
    iprot.readStructEnd()
17160 
 
17161 
  def write(self, oprot):
17162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17164 
      return
17165 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17166 
    if self.providerId is not None:
17167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17168 
      oprot.writeI64(self.providerId)
17169 
      oprot.writeFieldEnd()
17170 
    oprot.writeFieldStop()
17171 
    oprot.writeStructEnd()
17172 
 
17173 
  def validate(self):
17174 
    return
17175 
 
17176 
 
17177 
  def __repr__(self):
17178 
    L = ['%s=%r' % (key, value)
17179 
      for key, value in self.__dict__.iteritems()]
17180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17181 
 
17182 
  def __eq__(self, other):
17183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17184 
 
17185 
  def __ne__(self, other):
17186 
    return not (self == other)
17187 
 
17188 
class getDoasNotPickedUp_result:
17189 
  """
17190 
  Attributes:
2764 chandransh 17191 
   - success
17192 
  """
17193 
 
17194 
  thrift_spec = (
17195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17196 
  )
17197 
 
17198 
  def __init__(self, success=None,):
17199 
    self.success = success
17200 
 
17201 
  def read(self, iprot):
17202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17204 
      return
17205 
    iprot.readStructBegin()
17206 
    while True:
17207 
      (fname, ftype, fid) = iprot.readFieldBegin()
17208 
      if ftype == TType.STOP:
17209 
        break
17210 
      if fid == 0:
17211 
        if ftype == TType.LIST:
17212 
          self.success = []
6188 rajveer 17213 
          (_etype419, _size416) = iprot.readListBegin()
17214 
          for _i420 in xrange(_size416):
17215 
            _elem421 = Order()
17216 
            _elem421.read(iprot)
17217 
            self.success.append(_elem421)
2764 chandransh 17218 
          iprot.readListEnd()
17219 
        else:
17220 
          iprot.skip(ftype)
17221 
      else:
17222 
        iprot.skip(ftype)
17223 
      iprot.readFieldEnd()
17224 
    iprot.readStructEnd()
17225 
 
17226 
  def write(self, oprot):
17227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17229 
      return
4910 phani.kuma 17230 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17231 
    if self.success is not None:
2764 chandransh 17232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17234 
      for iter422 in self.success:
17235 
        iter422.write(oprot)
2764 chandransh 17236 
      oprot.writeListEnd()
17237 
      oprot.writeFieldEnd()
17238 
    oprot.writeFieldStop()
17239 
    oprot.writeStructEnd()
17240 
 
3431 rajveer 17241 
  def validate(self):
17242 
    return
17243 
 
17244 
 
2764 chandransh 17245 
  def __repr__(self):
17246 
    L = ['%s=%r' % (key, value)
17247 
      for key, value in self.__dict__.iteritems()]
17248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17249 
 
17250 
  def __eq__(self, other):
17251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17252 
 
17253 
  def __ne__(self, other):
17254 
    return not (self == other)
17255 
 
4741 phani.kuma 17256 
class markReturnOrdersAsPickedUp_args:
17257 
  """
17258 
  Attributes:
17259 
   - providerId
17260 
   - pickupDetails
17261 
  """
17262 
 
17263 
  thrift_spec = (
17264 
    None, # 0
17265 
    (1, TType.I64, 'providerId', None, None, ), # 1
17266 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17267 
  )
17268 
 
17269 
  def __init__(self, providerId=None, pickupDetails=None,):
17270 
    self.providerId = providerId
17271 
    self.pickupDetails = pickupDetails
17272 
 
17273 
  def read(self, iprot):
17274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17276 
      return
17277 
    iprot.readStructBegin()
17278 
    while True:
17279 
      (fname, ftype, fid) = iprot.readFieldBegin()
17280 
      if ftype == TType.STOP:
17281 
        break
17282 
      if fid == 1:
17283 
        if ftype == TType.I64:
17284 
          self.providerId = iprot.readI64();
17285 
        else:
17286 
          iprot.skip(ftype)
17287 
      elif fid == 2:
17288 
        if ftype == TType.MAP:
17289 
          self.pickupDetails = {}
6188 rajveer 17290 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17291 
          for _i427 in xrange(_size423):
17292 
            _key428 = iprot.readString();
17293 
            _val429 = iprot.readString();
17294 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17295 
          iprot.readMapEnd()
17296 
        else:
17297 
          iprot.skip(ftype)
17298 
      else:
17299 
        iprot.skip(ftype)
17300 
      iprot.readFieldEnd()
17301 
    iprot.readStructEnd()
17302 
 
17303 
  def write(self, oprot):
17304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17306 
      return
17307 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17308 
    if self.providerId is not None:
17309 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17310 
      oprot.writeI64(self.providerId)
17311 
      oprot.writeFieldEnd()
17312 
    if self.pickupDetails is not None:
17313 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17314 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17315 
      for kiter430,viter431 in self.pickupDetails.items():
17316 
        oprot.writeString(kiter430)
17317 
        oprot.writeString(viter431)
4741 phani.kuma 17318 
      oprot.writeMapEnd()
17319 
      oprot.writeFieldEnd()
17320 
    oprot.writeFieldStop()
17321 
    oprot.writeStructEnd()
17322 
 
17323 
  def validate(self):
17324 
    return
17325 
 
17326 
 
17327 
  def __repr__(self):
17328 
    L = ['%s=%r' % (key, value)
17329 
      for key, value in self.__dict__.iteritems()]
17330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17331 
 
17332 
  def __eq__(self, other):
17333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17334 
 
17335 
  def __ne__(self, other):
17336 
    return not (self == other)
17337 
 
17338 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17339 
 
17340 
  thrift_spec = (
17341 
  )
17342 
 
17343 
  def read(self, iprot):
17344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17346 
      return
17347 
    iprot.readStructBegin()
17348 
    while True:
17349 
      (fname, ftype, fid) = iprot.readFieldBegin()
17350 
      if ftype == TType.STOP:
17351 
        break
17352 
      else:
17353 
        iprot.skip(ftype)
17354 
      iprot.readFieldEnd()
17355 
    iprot.readStructEnd()
17356 
 
17357 
  def write(self, oprot):
17358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17360 
      return
17361 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17362 
    oprot.writeFieldStop()
17363 
    oprot.writeStructEnd()
17364 
 
17365 
  def validate(self):
17366 
    return
17367 
 
17368 
 
17369 
  def __repr__(self):
17370 
    L = ['%s=%r' % (key, value)
17371 
      for key, value in self.__dict__.iteritems()]
17372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17373 
 
17374 
  def __eq__(self, other):
17375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17376 
 
17377 
  def __ne__(self, other):
17378 
    return not (self == other)
17379 
 
17380 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17381 
  """
17382 
  Attributes:
4910 phani.kuma 17383 
   - providerId
17384 
  """
17385 
 
17386 
  thrift_spec = (
17387 
    None, # 0
17388 
    (1, TType.I64, 'providerId', None, None, ), # 1
17389 
  )
17390 
 
17391 
  def __init__(self, providerId=None,):
17392 
    self.providerId = providerId
17393 
 
17394 
  def read(self, iprot):
17395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17397 
      return
17398 
    iprot.readStructBegin()
17399 
    while True:
17400 
      (fname, ftype, fid) = iprot.readFieldBegin()
17401 
      if ftype == TType.STOP:
17402 
        break
17403 
      if fid == 1:
17404 
        if ftype == TType.I64:
17405 
          self.providerId = iprot.readI64();
17406 
        else:
17407 
          iprot.skip(ftype)
17408 
      else:
17409 
        iprot.skip(ftype)
17410 
      iprot.readFieldEnd()
17411 
    iprot.readStructEnd()
17412 
 
17413 
  def write(self, oprot):
17414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17416 
      return
17417 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17418 
    if self.providerId is not None:
17419 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17420 
      oprot.writeI64(self.providerId)
17421 
      oprot.writeFieldEnd()
17422 
    oprot.writeFieldStop()
17423 
    oprot.writeStructEnd()
17424 
 
17425 
  def validate(self):
17426 
    return
17427 
 
17428 
 
17429 
  def __repr__(self):
17430 
    L = ['%s=%r' % (key, value)
17431 
      for key, value in self.__dict__.iteritems()]
17432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17433 
 
17434 
  def __eq__(self, other):
17435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17436 
 
17437 
  def __ne__(self, other):
17438 
    return not (self == other)
17439 
 
17440 
class getReturnOrdersNotPickedUp_result:
17441 
  """
17442 
  Attributes:
4741 phani.kuma 17443 
   - success
17444 
  """
17445 
 
17446 
  thrift_spec = (
17447 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17448 
  )
17449 
 
17450 
  def __init__(self, success=None,):
17451 
    self.success = success
17452 
 
17453 
  def read(self, iprot):
17454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17456 
      return
17457 
    iprot.readStructBegin()
17458 
    while True:
17459 
      (fname, ftype, fid) = iprot.readFieldBegin()
17460 
      if ftype == TType.STOP:
17461 
        break
17462 
      if fid == 0:
17463 
        if ftype == TType.LIST:
17464 
          self.success = []
6188 rajveer 17465 
          (_etype435, _size432) = iprot.readListBegin()
17466 
          for _i436 in xrange(_size432):
17467 
            _elem437 = Order()
17468 
            _elem437.read(iprot)
17469 
            self.success.append(_elem437)
4741 phani.kuma 17470 
          iprot.readListEnd()
17471 
        else:
17472 
          iprot.skip(ftype)
17473 
      else:
17474 
        iprot.skip(ftype)
17475 
      iprot.readFieldEnd()
17476 
    iprot.readStructEnd()
17477 
 
17478 
  def write(self, oprot):
17479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17481 
      return
4910 phani.kuma 17482 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17483 
    if self.success is not None:
17484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17486 
      for iter438 in self.success:
17487 
        iter438.write(oprot)
4741 phani.kuma 17488 
      oprot.writeListEnd()
17489 
      oprot.writeFieldEnd()
17490 
    oprot.writeFieldStop()
17491 
    oprot.writeStructEnd()
17492 
 
17493 
  def validate(self):
17494 
    return
17495 
 
17496 
 
17497 
  def __repr__(self):
17498 
    L = ['%s=%r' % (key, value)
17499 
      for key, value in self.__dict__.iteritems()]
17500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17501 
 
17502 
  def __eq__(self, other):
17503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17504 
 
17505 
  def __ne__(self, other):
17506 
    return not (self == other)
17507 
 
2616 chandransh 17508 
class receiveReturn_args:
2591 chandransh 17509 
  """
17510 
  Attributes:
17511 
   - orderId
4479 rajveer 17512 
   - receiveCondition
2591 chandransh 17513 
  """
2536 chandransh 17514 
 
2591 chandransh 17515 
  thrift_spec = (
17516 
    None, # 0
17517 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17518 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17519 
  )
17520 
 
4479 rajveer 17521 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17522 
    self.orderId = orderId
4479 rajveer 17523 
    self.receiveCondition = receiveCondition
2591 chandransh 17524 
 
17525 
  def read(self, iprot):
17526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17528 
      return
17529 
    iprot.readStructBegin()
17530 
    while True:
17531 
      (fname, ftype, fid) = iprot.readFieldBegin()
17532 
      if ftype == TType.STOP:
17533 
        break
17534 
      if fid == 1:
17535 
        if ftype == TType.I64:
17536 
          self.orderId = iprot.readI64();
17537 
        else:
17538 
          iprot.skip(ftype)
4479 rajveer 17539 
      elif fid == 2:
17540 
        if ftype == TType.I64:
17541 
          self.receiveCondition = iprot.readI64();
17542 
        else:
17543 
          iprot.skip(ftype)
2591 chandransh 17544 
      else:
17545 
        iprot.skip(ftype)
17546 
      iprot.readFieldEnd()
17547 
    iprot.readStructEnd()
17548 
 
17549 
  def write(self, oprot):
17550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17552 
      return
2616 chandransh 17553 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17554 
    if self.orderId is not None:
2591 chandransh 17555 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17556 
      oprot.writeI64(self.orderId)
17557 
      oprot.writeFieldEnd()
4479 rajveer 17558 
    if self.receiveCondition is not None:
17559 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17560 
      oprot.writeI64(self.receiveCondition)
17561 
      oprot.writeFieldEnd()
2591 chandransh 17562 
    oprot.writeFieldStop()
17563 
    oprot.writeStructEnd()
17564 
 
3431 rajveer 17565 
  def validate(self):
17566 
    return
17567 
 
17568 
 
2591 chandransh 17569 
  def __repr__(self):
17570 
    L = ['%s=%r' % (key, value)
17571 
      for key, value in self.__dict__.iteritems()]
17572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17573 
 
17574 
  def __eq__(self, other):
17575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17576 
 
17577 
  def __ne__(self, other):
17578 
    return not (self == other)
17579 
 
2616 chandransh 17580 
class receiveReturn_result:
2591 chandransh 17581 
  """
17582 
  Attributes:
17583 
   - success
17584 
   - ex
17585 
  """
17586 
 
17587 
  thrift_spec = (
17588 
    (0, TType.BOOL, 'success', None, None, ), # 0
17589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17590 
  )
17591 
 
17592 
  def __init__(self, success=None, ex=None,):
17593 
    self.success = success
17594 
    self.ex = ex
17595 
 
17596 
  def read(self, iprot):
17597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17599 
      return
17600 
    iprot.readStructBegin()
17601 
    while True:
17602 
      (fname, ftype, fid) = iprot.readFieldBegin()
17603 
      if ftype == TType.STOP:
17604 
        break
17605 
      if fid == 0:
17606 
        if ftype == TType.BOOL:
17607 
          self.success = iprot.readBool();
17608 
        else:
17609 
          iprot.skip(ftype)
17610 
      elif fid == 1:
17611 
        if ftype == TType.STRUCT:
17612 
          self.ex = TransactionServiceException()
17613 
          self.ex.read(iprot)
17614 
        else:
17615 
          iprot.skip(ftype)
17616 
      else:
17617 
        iprot.skip(ftype)
17618 
      iprot.readFieldEnd()
17619 
    iprot.readStructEnd()
17620 
 
17621 
  def write(self, oprot):
17622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17624 
      return
2616 chandransh 17625 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17626 
    if self.success is not None:
2591 chandransh 17627 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17628 
      oprot.writeBool(self.success)
17629 
      oprot.writeFieldEnd()
3431 rajveer 17630 
    if self.ex is not None:
2591 chandransh 17631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17632 
      self.ex.write(oprot)
17633 
      oprot.writeFieldEnd()
17634 
    oprot.writeFieldStop()
17635 
    oprot.writeStructEnd()
17636 
 
3431 rajveer 17637 
  def validate(self):
17638 
    return
17639 
 
17640 
 
2591 chandransh 17641 
  def __repr__(self):
17642 
    L = ['%s=%r' % (key, value)
17643 
      for key, value in self.__dict__.iteritems()]
17644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17645 
 
17646 
  def __eq__(self, other):
17647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17648 
 
17649 
  def __ne__(self, other):
17650 
    return not (self == other)
17651 
 
17652 
class validateDoa_args:
17653 
  """
17654 
  Attributes:
17655 
   - orderId
17656 
   - isValid
17657 
  """
17658 
 
17659 
  thrift_spec = (
17660 
    None, # 0
17661 
    (1, TType.I64, 'orderId', None, None, ), # 1
17662 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17663 
  )
17664 
 
17665 
  def __init__(self, orderId=None, isValid=None,):
17666 
    self.orderId = orderId
17667 
    self.isValid = isValid
17668 
 
17669 
  def read(self, iprot):
17670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17672 
      return
17673 
    iprot.readStructBegin()
17674 
    while True:
17675 
      (fname, ftype, fid) = iprot.readFieldBegin()
17676 
      if ftype == TType.STOP:
17677 
        break
17678 
      if fid == 1:
17679 
        if ftype == TType.I64:
17680 
          self.orderId = iprot.readI64();
17681 
        else:
17682 
          iprot.skip(ftype)
17683 
      elif fid == 2:
17684 
        if ftype == TType.BOOL:
17685 
          self.isValid = iprot.readBool();
17686 
        else:
17687 
          iprot.skip(ftype)
17688 
      else:
17689 
        iprot.skip(ftype)
17690 
      iprot.readFieldEnd()
17691 
    iprot.readStructEnd()
17692 
 
17693 
  def write(self, oprot):
17694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17696 
      return
17697 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17698 
    if self.orderId is not None:
2591 chandransh 17699 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17700 
      oprot.writeI64(self.orderId)
17701 
      oprot.writeFieldEnd()
3431 rajveer 17702 
    if self.isValid is not None:
2591 chandransh 17703 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17704 
      oprot.writeBool(self.isValid)
17705 
      oprot.writeFieldEnd()
17706 
    oprot.writeFieldStop()
17707 
    oprot.writeStructEnd()
17708 
 
3431 rajveer 17709 
  def validate(self):
17710 
    return
17711 
 
17712 
 
2591 chandransh 17713 
  def __repr__(self):
17714 
    L = ['%s=%r' % (key, value)
17715 
      for key, value in self.__dict__.iteritems()]
17716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17717 
 
17718 
  def __eq__(self, other):
17719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17720 
 
17721 
  def __ne__(self, other):
17722 
    return not (self == other)
17723 
 
17724 
class validateDoa_result:
17725 
  """
17726 
  Attributes:
17727 
   - success
17728 
   - ex
17729 
  """
17730 
 
17731 
  thrift_spec = (
17732 
    (0, TType.BOOL, 'success', None, None, ), # 0
17733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17734 
  )
17735 
 
17736 
  def __init__(self, success=None, ex=None,):
17737 
    self.success = success
17738 
    self.ex = ex
17739 
 
17740 
  def read(self, iprot):
17741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17743 
      return
17744 
    iprot.readStructBegin()
17745 
    while True:
17746 
      (fname, ftype, fid) = iprot.readFieldBegin()
17747 
      if ftype == TType.STOP:
17748 
        break
17749 
      if fid == 0:
17750 
        if ftype == TType.BOOL:
17751 
          self.success = iprot.readBool();
17752 
        else:
17753 
          iprot.skip(ftype)
17754 
      elif fid == 1:
17755 
        if ftype == TType.STRUCT:
17756 
          self.ex = TransactionServiceException()
17757 
          self.ex.read(iprot)
17758 
        else:
17759 
          iprot.skip(ftype)
17760 
      else:
17761 
        iprot.skip(ftype)
17762 
      iprot.readFieldEnd()
17763 
    iprot.readStructEnd()
17764 
 
17765 
  def write(self, oprot):
17766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17768 
      return
17769 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17770 
    if self.success is not None:
2591 chandransh 17771 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17772 
      oprot.writeBool(self.success)
17773 
      oprot.writeFieldEnd()
3431 rajveer 17774 
    if self.ex is not None:
2591 chandransh 17775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17776 
      self.ex.write(oprot)
17777 
      oprot.writeFieldEnd()
17778 
    oprot.writeFieldStop()
17779 
    oprot.writeStructEnd()
17780 
 
3431 rajveer 17781 
  def validate(self):
17782 
    return
17783 
 
17784 
 
2591 chandransh 17785 
  def __repr__(self):
17786 
    L = ['%s=%r' % (key, value)
17787 
      for key, value in self.__dict__.iteritems()]
17788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17789 
 
17790 
  def __eq__(self, other):
17791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17792 
 
17793 
  def __ne__(self, other):
17794 
    return not (self == other)
17795 
 
4495 rajveer 17796 
class validateReturnProduct_args:
17797 
  """
17798 
  Attributes:
17799 
   - orderId
17800 
   - isUsable
17801 
  """
17802 
 
17803 
  thrift_spec = (
17804 
    None, # 0
17805 
    (1, TType.I64, 'orderId', None, None, ), # 1
17806 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17807 
  )
17808 
 
17809 
  def __init__(self, orderId=None, isUsable=None,):
17810 
    self.orderId = orderId
17811 
    self.isUsable = isUsable
17812 
 
17813 
  def read(self, iprot):
17814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17816 
      return
17817 
    iprot.readStructBegin()
17818 
    while True:
17819 
      (fname, ftype, fid) = iprot.readFieldBegin()
17820 
      if ftype == TType.STOP:
17821 
        break
17822 
      if fid == 1:
17823 
        if ftype == TType.I64:
17824 
          self.orderId = iprot.readI64();
17825 
        else:
17826 
          iprot.skip(ftype)
17827 
      elif fid == 2:
17828 
        if ftype == TType.BOOL:
17829 
          self.isUsable = iprot.readBool();
17830 
        else:
17831 
          iprot.skip(ftype)
17832 
      else:
17833 
        iprot.skip(ftype)
17834 
      iprot.readFieldEnd()
17835 
    iprot.readStructEnd()
17836 
 
17837 
  def write(self, oprot):
17838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17840 
      return
17841 
    oprot.writeStructBegin('validateReturnProduct_args')
17842 
    if self.orderId is not None:
17843 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17844 
      oprot.writeI64(self.orderId)
17845 
      oprot.writeFieldEnd()
17846 
    if self.isUsable is not None:
17847 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17848 
      oprot.writeBool(self.isUsable)
17849 
      oprot.writeFieldEnd()
17850 
    oprot.writeFieldStop()
17851 
    oprot.writeStructEnd()
17852 
 
17853 
  def validate(self):
17854 
    return
17855 
 
17856 
 
17857 
  def __repr__(self):
17858 
    L = ['%s=%r' % (key, value)
17859 
      for key, value in self.__dict__.iteritems()]
17860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17861 
 
17862 
  def __eq__(self, other):
17863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17864 
 
17865 
  def __ne__(self, other):
17866 
    return not (self == other)
17867 
 
17868 
class validateReturnProduct_result:
17869 
  """
17870 
  Attributes:
17871 
   - success
17872 
   - ex
17873 
  """
17874 
 
17875 
  thrift_spec = (
17876 
    (0, TType.BOOL, 'success', None, None, ), # 0
17877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17878 
  )
17879 
 
17880 
  def __init__(self, success=None, ex=None,):
17881 
    self.success = success
17882 
    self.ex = ex
17883 
 
17884 
  def read(self, iprot):
17885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17887 
      return
17888 
    iprot.readStructBegin()
17889 
    while True:
17890 
      (fname, ftype, fid) = iprot.readFieldBegin()
17891 
      if ftype == TType.STOP:
17892 
        break
17893 
      if fid == 0:
17894 
        if ftype == TType.BOOL:
17895 
          self.success = iprot.readBool();
17896 
        else:
17897 
          iprot.skip(ftype)
17898 
      elif fid == 1:
17899 
        if ftype == TType.STRUCT:
17900 
          self.ex = TransactionServiceException()
17901 
          self.ex.read(iprot)
17902 
        else:
17903 
          iprot.skip(ftype)
17904 
      else:
17905 
        iprot.skip(ftype)
17906 
      iprot.readFieldEnd()
17907 
    iprot.readStructEnd()
17908 
 
17909 
  def write(self, oprot):
17910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17912 
      return
17913 
    oprot.writeStructBegin('validateReturnProduct_result')
17914 
    if self.success is not None:
17915 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17916 
      oprot.writeBool(self.success)
17917 
      oprot.writeFieldEnd()
17918 
    if self.ex is not None:
17919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17920 
      self.ex.write(oprot)
17921 
      oprot.writeFieldEnd()
17922 
    oprot.writeFieldStop()
17923 
    oprot.writeStructEnd()
17924 
 
17925 
  def validate(self):
17926 
    return
17927 
 
17928 
 
17929 
  def __repr__(self):
17930 
    L = ['%s=%r' % (key, value)
17931 
      for key, value in self.__dict__.iteritems()]
17932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17933 
 
17934 
  def __eq__(self, other):
17935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17936 
 
17937 
  def __ne__(self, other):
17938 
    return not (self == other)
17939 
 
2616 chandransh 17940 
class reshipOrder_args:
17941 
  """
17942 
  Attributes:
17943 
   - orderId
17944 
  """
2591 chandransh 17945 
 
2616 chandransh 17946 
  thrift_spec = (
17947 
    None, # 0
17948 
    (1, TType.I64, 'orderId', None, None, ), # 1
17949 
  )
17950 
 
17951 
  def __init__(self, orderId=None,):
17952 
    self.orderId = orderId
17953 
 
17954 
  def read(self, iprot):
17955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17957 
      return
17958 
    iprot.readStructBegin()
17959 
    while True:
17960 
      (fname, ftype, fid) = iprot.readFieldBegin()
17961 
      if ftype == TType.STOP:
17962 
        break
17963 
      if fid == 1:
17964 
        if ftype == TType.I64:
17965 
          self.orderId = iprot.readI64();
17966 
        else:
17967 
          iprot.skip(ftype)
17968 
      else:
17969 
        iprot.skip(ftype)
17970 
      iprot.readFieldEnd()
17971 
    iprot.readStructEnd()
17972 
 
17973 
  def write(self, oprot):
17974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17976 
      return
17977 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17978 
    if self.orderId is not None:
2616 chandransh 17979 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17980 
      oprot.writeI64(self.orderId)
17981 
      oprot.writeFieldEnd()
17982 
    oprot.writeFieldStop()
17983 
    oprot.writeStructEnd()
17984 
 
3431 rajveer 17985 
  def validate(self):
17986 
    return
17987 
 
17988 
 
2616 chandransh 17989 
  def __repr__(self):
17990 
    L = ['%s=%r' % (key, value)
17991 
      for key, value in self.__dict__.iteritems()]
17992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17993 
 
17994 
  def __eq__(self, other):
17995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17996 
 
17997 
  def __ne__(self, other):
17998 
    return not (self == other)
17999 
 
18000 
class reshipOrder_result:
18001 
  """
18002 
  Attributes:
18003 
   - success
18004 
   - ex
18005 
  """
18006 
 
18007 
  thrift_spec = (
18008 
    (0, TType.I64, 'success', None, None, ), # 0
18009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18010 
  )
18011 
 
18012 
  def __init__(self, success=None, ex=None,):
18013 
    self.success = success
18014 
    self.ex = ex
18015 
 
18016 
  def read(self, iprot):
18017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18019 
      return
18020 
    iprot.readStructBegin()
18021 
    while True:
18022 
      (fname, ftype, fid) = iprot.readFieldBegin()
18023 
      if ftype == TType.STOP:
18024 
        break
18025 
      if fid == 0:
18026 
        if ftype == TType.I64:
18027 
          self.success = iprot.readI64();
18028 
        else:
18029 
          iprot.skip(ftype)
18030 
      elif fid == 1:
18031 
        if ftype == TType.STRUCT:
18032 
          self.ex = TransactionServiceException()
18033 
          self.ex.read(iprot)
18034 
        else:
18035 
          iprot.skip(ftype)
18036 
      else:
18037 
        iprot.skip(ftype)
18038 
      iprot.readFieldEnd()
18039 
    iprot.readStructEnd()
18040 
 
18041 
  def write(self, oprot):
18042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18044 
      return
18045 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18046 
    if self.success is not None:
2616 chandransh 18047 
      oprot.writeFieldBegin('success', TType.I64, 0)
18048 
      oprot.writeI64(self.success)
18049 
      oprot.writeFieldEnd()
3431 rajveer 18050 
    if self.ex is not None:
2616 chandransh 18051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18052 
      self.ex.write(oprot)
18053 
      oprot.writeFieldEnd()
18054 
    oprot.writeFieldStop()
18055 
    oprot.writeStructEnd()
18056 
 
3431 rajveer 18057 
  def validate(self):
18058 
    return
18059 
 
18060 
 
2616 chandransh 18061 
  def __repr__(self):
18062 
    L = ['%s=%r' % (key, value)
18063 
      for key, value in self.__dict__.iteritems()]
18064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18065 
 
18066 
  def __eq__(self, other):
18067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18068 
 
18069 
  def __ne__(self, other):
18070 
    return not (self == other)
18071 
 
18072 
class refundOrder_args:
18073 
  """
18074 
  Attributes:
18075 
   - orderId
3226 chandransh 18076 
   - refundedBy
18077 
   - reason
2616 chandransh 18078 
  """
18079 
 
18080 
  thrift_spec = (
18081 
    None, # 0
18082 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18083 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18084 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18085 
  )
18086 
 
3226 chandransh 18087 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18088 
    self.orderId = orderId
3226 chandransh 18089 
    self.refundedBy = refundedBy
18090 
    self.reason = reason
2616 chandransh 18091 
 
18092 
  def read(self, iprot):
18093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18095 
      return
18096 
    iprot.readStructBegin()
18097 
    while True:
18098 
      (fname, ftype, fid) = iprot.readFieldBegin()
18099 
      if ftype == TType.STOP:
18100 
        break
18101 
      if fid == 1:
18102 
        if ftype == TType.I64:
18103 
          self.orderId = iprot.readI64();
18104 
        else:
18105 
          iprot.skip(ftype)
3226 chandransh 18106 
      elif fid == 2:
18107 
        if ftype == TType.STRING:
18108 
          self.refundedBy = iprot.readString();
18109 
        else:
18110 
          iprot.skip(ftype)
18111 
      elif fid == 3:
18112 
        if ftype == TType.STRING:
18113 
          self.reason = iprot.readString();
18114 
        else:
18115 
          iprot.skip(ftype)
2616 chandransh 18116 
      else:
18117 
        iprot.skip(ftype)
18118 
      iprot.readFieldEnd()
18119 
    iprot.readStructEnd()
18120 
 
18121 
  def write(self, oprot):
18122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18124 
      return
18125 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18126 
    if self.orderId is not None:
2616 chandransh 18127 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18128 
      oprot.writeI64(self.orderId)
18129 
      oprot.writeFieldEnd()
3431 rajveer 18130 
    if self.refundedBy is not None:
3226 chandransh 18131 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18132 
      oprot.writeString(self.refundedBy)
18133 
      oprot.writeFieldEnd()
3431 rajveer 18134 
    if self.reason is not None:
3226 chandransh 18135 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18136 
      oprot.writeString(self.reason)
18137 
      oprot.writeFieldEnd()
2616 chandransh 18138 
    oprot.writeFieldStop()
18139 
    oprot.writeStructEnd()
18140 
 
3431 rajveer 18141 
  def validate(self):
18142 
    return
18143 
 
18144 
 
2616 chandransh 18145 
  def __repr__(self):
18146 
    L = ['%s=%r' % (key, value)
18147 
      for key, value in self.__dict__.iteritems()]
18148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18149 
 
18150 
  def __eq__(self, other):
18151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18152 
 
18153 
  def __ne__(self, other):
18154 
    return not (self == other)
18155 
 
18156 
class refundOrder_result:
18157 
  """
18158 
  Attributes:
18159 
   - success
18160 
   - ex
18161 
  """
18162 
 
18163 
  thrift_spec = (
18164 
    (0, TType.BOOL, 'success', None, None, ), # 0
18165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18166 
  )
18167 
 
18168 
  def __init__(self, success=None, ex=None,):
18169 
    self.success = success
18170 
    self.ex = ex
18171 
 
18172 
  def read(self, iprot):
18173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18175 
      return
18176 
    iprot.readStructBegin()
18177 
    while True:
18178 
      (fname, ftype, fid) = iprot.readFieldBegin()
18179 
      if ftype == TType.STOP:
18180 
        break
18181 
      if fid == 0:
18182 
        if ftype == TType.BOOL:
18183 
          self.success = iprot.readBool();
18184 
        else:
18185 
          iprot.skip(ftype)
18186 
      elif fid == 1:
18187 
        if ftype == TType.STRUCT:
18188 
          self.ex = TransactionServiceException()
18189 
          self.ex.read(iprot)
18190 
        else:
18191 
          iprot.skip(ftype)
18192 
      else:
18193 
        iprot.skip(ftype)
18194 
      iprot.readFieldEnd()
18195 
    iprot.readStructEnd()
18196 
 
18197 
  def write(self, oprot):
18198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18200 
      return
18201 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18202 
    if self.success is not None:
2616 chandransh 18203 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18204 
      oprot.writeBool(self.success)
18205 
      oprot.writeFieldEnd()
3431 rajveer 18206 
    if self.ex is not None:
2616 chandransh 18207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18208 
      self.ex.write(oprot)
18209 
      oprot.writeFieldEnd()
18210 
    oprot.writeFieldStop()
18211 
    oprot.writeStructEnd()
18212 
 
3431 rajveer 18213 
  def validate(self):
18214 
    return
18215 
 
18216 
 
2616 chandransh 18217 
  def __repr__(self):
18218 
    L = ['%s=%r' % (key, value)
18219 
      for key, value in self.__dict__.iteritems()]
18220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18221 
 
18222 
  def __eq__(self, other):
18223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18224 
 
18225 
  def __ne__(self, other):
18226 
    return not (self == other)
18227 
 
2690 chandransh 18228 
class getReturnOrders_args:
18229 
  """
18230 
  Attributes:
18231 
   - warehouseId
18232 
   - fromDate
18233 
   - toDate
18234 
  """
2616 chandransh 18235 
 
2690 chandransh 18236 
  thrift_spec = (
18237 
    None, # 0
18238 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18239 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18240 
    (3, TType.I64, 'toDate', None, None, ), # 3
18241 
  )
18242 
 
18243 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18244 
    self.warehouseId = warehouseId
18245 
    self.fromDate = fromDate
18246 
    self.toDate = toDate
18247 
 
18248 
  def read(self, iprot):
18249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18251 
      return
18252 
    iprot.readStructBegin()
18253 
    while True:
18254 
      (fname, ftype, fid) = iprot.readFieldBegin()
18255 
      if ftype == TType.STOP:
18256 
        break
18257 
      if fid == 1:
18258 
        if ftype == TType.I64:
18259 
          self.warehouseId = iprot.readI64();
18260 
        else:
18261 
          iprot.skip(ftype)
18262 
      elif fid == 2:
18263 
        if ftype == TType.I64:
18264 
          self.fromDate = iprot.readI64();
18265 
        else:
18266 
          iprot.skip(ftype)
18267 
      elif fid == 3:
18268 
        if ftype == TType.I64:
18269 
          self.toDate = iprot.readI64();
18270 
        else:
18271 
          iprot.skip(ftype)
18272 
      else:
18273 
        iprot.skip(ftype)
18274 
      iprot.readFieldEnd()
18275 
    iprot.readStructEnd()
18276 
 
18277 
  def write(self, oprot):
18278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18280 
      return
18281 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18282 
    if self.warehouseId is not None:
2690 chandransh 18283 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18284 
      oprot.writeI64(self.warehouseId)
18285 
      oprot.writeFieldEnd()
3431 rajveer 18286 
    if self.fromDate is not None:
2690 chandransh 18287 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18288 
      oprot.writeI64(self.fromDate)
18289 
      oprot.writeFieldEnd()
3431 rajveer 18290 
    if self.toDate is not None:
2690 chandransh 18291 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18292 
      oprot.writeI64(self.toDate)
18293 
      oprot.writeFieldEnd()
18294 
    oprot.writeFieldStop()
18295 
    oprot.writeStructEnd()
18296 
 
3431 rajveer 18297 
  def validate(self):
18298 
    return
18299 
 
18300 
 
2690 chandransh 18301 
  def __repr__(self):
18302 
    L = ['%s=%r' % (key, value)
18303 
      for key, value in self.__dict__.iteritems()]
18304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18305 
 
18306 
  def __eq__(self, other):
18307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18308 
 
18309 
  def __ne__(self, other):
18310 
    return not (self == other)
18311 
 
18312 
class getReturnOrders_result:
18313 
  """
18314 
  Attributes:
18315 
   - success
18316 
  """
18317 
 
18318 
  thrift_spec = (
18319 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18320 
  )
18321 
 
18322 
  def __init__(self, success=None,):
18323 
    self.success = success
18324 
 
18325 
  def read(self, iprot):
18326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18328 
      return
18329 
    iprot.readStructBegin()
18330 
    while True:
18331 
      (fname, ftype, fid) = iprot.readFieldBegin()
18332 
      if ftype == TType.STOP:
18333 
        break
18334 
      if fid == 0:
18335 
        if ftype == TType.LIST:
18336 
          self.success = []
6188 rajveer 18337 
          (_etype442, _size439) = iprot.readListBegin()
18338 
          for _i443 in xrange(_size439):
18339 
            _elem444 = ReturnOrder()
18340 
            _elem444.read(iprot)
18341 
            self.success.append(_elem444)
2690 chandransh 18342 
          iprot.readListEnd()
18343 
        else:
18344 
          iprot.skip(ftype)
18345 
      else:
18346 
        iprot.skip(ftype)
18347 
      iprot.readFieldEnd()
18348 
    iprot.readStructEnd()
18349 
 
18350 
  def write(self, oprot):
18351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18353 
      return
18354 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18355 
    if self.success is not None:
2690 chandransh 18356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18358 
      for iter445 in self.success:
18359 
        iter445.write(oprot)
2690 chandransh 18360 
      oprot.writeListEnd()
18361 
      oprot.writeFieldEnd()
18362 
    oprot.writeFieldStop()
18363 
    oprot.writeStructEnd()
18364 
 
3431 rajveer 18365 
  def validate(self):
18366 
    return
18367 
 
18368 
 
2690 chandransh 18369 
  def __repr__(self):
18370 
    L = ['%s=%r' % (key, value)
18371 
      for key, value in self.__dict__.iteritems()]
18372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18373 
 
18374 
  def __eq__(self, other):
18375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18376 
 
18377 
  def __ne__(self, other):
18378 
    return not (self == other)
18379 
 
5481 phani.kuma 18380 
class getAllReturnOrders_args:
18381 
  """
18382 
  Attributes:
18383 
   - onlyNotProcessed
18384 
   - fromDate
18385 
   - toDate
18386 
  """
18387 
 
18388 
  thrift_spec = (
18389 
    None, # 0
18390 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18391 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18392 
    (3, TType.I64, 'toDate', None, None, ), # 3
18393 
  )
18394 
 
18395 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18396 
    self.onlyNotProcessed = onlyNotProcessed
18397 
    self.fromDate = fromDate
18398 
    self.toDate = toDate
18399 
 
18400 
  def read(self, iprot):
18401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18403 
      return
18404 
    iprot.readStructBegin()
18405 
    while True:
18406 
      (fname, ftype, fid) = iprot.readFieldBegin()
18407 
      if ftype == TType.STOP:
18408 
        break
18409 
      if fid == 1:
18410 
        if ftype == TType.BOOL:
18411 
          self.onlyNotProcessed = iprot.readBool();
18412 
        else:
18413 
          iprot.skip(ftype)
18414 
      elif fid == 2:
18415 
        if ftype == TType.I64:
18416 
          self.fromDate = iprot.readI64();
18417 
        else:
18418 
          iprot.skip(ftype)
18419 
      elif fid == 3:
18420 
        if ftype == TType.I64:
18421 
          self.toDate = iprot.readI64();
18422 
        else:
18423 
          iprot.skip(ftype)
18424 
      else:
18425 
        iprot.skip(ftype)
18426 
      iprot.readFieldEnd()
18427 
    iprot.readStructEnd()
18428 
 
18429 
  def write(self, oprot):
18430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18432 
      return
18433 
    oprot.writeStructBegin('getAllReturnOrders_args')
18434 
    if self.onlyNotProcessed is not None:
18435 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18436 
      oprot.writeBool(self.onlyNotProcessed)
18437 
      oprot.writeFieldEnd()
18438 
    if self.fromDate is not None:
18439 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18440 
      oprot.writeI64(self.fromDate)
18441 
      oprot.writeFieldEnd()
18442 
    if self.toDate is not None:
18443 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18444 
      oprot.writeI64(self.toDate)
18445 
      oprot.writeFieldEnd()
18446 
    oprot.writeFieldStop()
18447 
    oprot.writeStructEnd()
18448 
 
18449 
  def validate(self):
18450 
    return
18451 
 
18452 
 
18453 
  def __repr__(self):
18454 
    L = ['%s=%r' % (key, value)
18455 
      for key, value in self.__dict__.iteritems()]
18456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18457 
 
18458 
  def __eq__(self, other):
18459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18460 
 
18461 
  def __ne__(self, other):
18462 
    return not (self == other)
18463 
 
18464 
class getAllReturnOrders_result:
18465 
  """
18466 
  Attributes:
18467 
   - success
18468 
  """
18469 
 
18470 
  thrift_spec = (
18471 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18472 
  )
18473 
 
18474 
  def __init__(self, success=None,):
18475 
    self.success = success
18476 
 
18477 
  def read(self, iprot):
18478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18480 
      return
18481 
    iprot.readStructBegin()
18482 
    while True:
18483 
      (fname, ftype, fid) = iprot.readFieldBegin()
18484 
      if ftype == TType.STOP:
18485 
        break
18486 
      if fid == 0:
18487 
        if ftype == TType.LIST:
18488 
          self.success = []
6188 rajveer 18489 
          (_etype449, _size446) = iprot.readListBegin()
18490 
          for _i450 in xrange(_size446):
18491 
            _elem451 = ReturnOrder()
18492 
            _elem451.read(iprot)
18493 
            self.success.append(_elem451)
5481 phani.kuma 18494 
          iprot.readListEnd()
18495 
        else:
18496 
          iprot.skip(ftype)
18497 
      else:
18498 
        iprot.skip(ftype)
18499 
      iprot.readFieldEnd()
18500 
    iprot.readStructEnd()
18501 
 
18502 
  def write(self, oprot):
18503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18505 
      return
18506 
    oprot.writeStructBegin('getAllReturnOrders_result')
18507 
    if self.success is not None:
18508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18510 
      for iter452 in self.success:
18511 
        iter452.write(oprot)
5481 phani.kuma 18512 
      oprot.writeListEnd()
18513 
      oprot.writeFieldEnd()
18514 
    oprot.writeFieldStop()
18515 
    oprot.writeStructEnd()
18516 
 
18517 
  def validate(self):
18518 
    return
18519 
 
18520 
 
18521 
  def __repr__(self):
18522 
    L = ['%s=%r' % (key, value)
18523 
      for key, value in self.__dict__.iteritems()]
18524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18525 
 
18526 
  def __eq__(self, other):
18527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18528 
 
18529 
  def __ne__(self, other):
18530 
    return not (self == other)
18531 
 
2700 chandransh 18532 
class getReturnOrder_args:
18533 
  """
18534 
  Attributes:
18535 
   - id
18536 
  """
18537 
 
18538 
  thrift_spec = (
18539 
    None, # 0
18540 
    (1, TType.I64, 'id', None, None, ), # 1
18541 
  )
18542 
 
18543 
  def __init__(self, id=None,):
18544 
    self.id = id
18545 
 
18546 
  def read(self, iprot):
18547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18549 
      return
18550 
    iprot.readStructBegin()
18551 
    while True:
18552 
      (fname, ftype, fid) = iprot.readFieldBegin()
18553 
      if ftype == TType.STOP:
18554 
        break
18555 
      if fid == 1:
18556 
        if ftype == TType.I64:
18557 
          self.id = iprot.readI64();
18558 
        else:
18559 
          iprot.skip(ftype)
18560 
      else:
18561 
        iprot.skip(ftype)
18562 
      iprot.readFieldEnd()
18563 
    iprot.readStructEnd()
18564 
 
18565 
  def write(self, oprot):
18566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18568 
      return
18569 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18570 
    if self.id is not None:
2700 chandransh 18571 
      oprot.writeFieldBegin('id', TType.I64, 1)
18572 
      oprot.writeI64(self.id)
18573 
      oprot.writeFieldEnd()
18574 
    oprot.writeFieldStop()
18575 
    oprot.writeStructEnd()
18576 
 
3431 rajveer 18577 
  def validate(self):
18578 
    return
18579 
 
18580 
 
2700 chandransh 18581 
  def __repr__(self):
18582 
    L = ['%s=%r' % (key, value)
18583 
      for key, value in self.__dict__.iteritems()]
18584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18585 
 
18586 
  def __eq__(self, other):
18587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18588 
 
18589 
  def __ne__(self, other):
18590 
    return not (self == other)
18591 
 
18592 
class getReturnOrder_result:
18593 
  """
18594 
  Attributes:
18595 
   - success
18596 
   - ex
18597 
  """
18598 
 
18599 
  thrift_spec = (
18600 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18602 
  )
18603 
 
18604 
  def __init__(self, success=None, ex=None,):
18605 
    self.success = success
18606 
    self.ex = ex
18607 
 
18608 
  def read(self, iprot):
18609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18611 
      return
18612 
    iprot.readStructBegin()
18613 
    while True:
18614 
      (fname, ftype, fid) = iprot.readFieldBegin()
18615 
      if ftype == TType.STOP:
18616 
        break
18617 
      if fid == 0:
18618 
        if ftype == TType.STRUCT:
18619 
          self.success = ReturnOrder()
18620 
          self.success.read(iprot)
18621 
        else:
18622 
          iprot.skip(ftype)
18623 
      elif fid == 1:
18624 
        if ftype == TType.STRUCT:
18625 
          self.ex = TransactionServiceException()
18626 
          self.ex.read(iprot)
18627 
        else:
18628 
          iprot.skip(ftype)
18629 
      else:
18630 
        iprot.skip(ftype)
18631 
      iprot.readFieldEnd()
18632 
    iprot.readStructEnd()
18633 
 
18634 
  def write(self, oprot):
18635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18637 
      return
18638 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18639 
    if self.success is not None:
2700 chandransh 18640 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18641 
      self.success.write(oprot)
18642 
      oprot.writeFieldEnd()
3431 rajveer 18643 
    if self.ex is not None:
2700 chandransh 18644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18645 
      self.ex.write(oprot)
18646 
      oprot.writeFieldEnd()
18647 
    oprot.writeFieldStop()
18648 
    oprot.writeStructEnd()
18649 
 
3431 rajveer 18650 
  def validate(self):
18651 
    return
18652 
 
18653 
 
2700 chandransh 18654 
  def __repr__(self):
18655 
    L = ['%s=%r' % (key, value)
18656 
      for key, value in self.__dict__.iteritems()]
18657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18658 
 
18659 
  def __eq__(self, other):
18660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18661 
 
18662 
  def __ne__(self, other):
18663 
    return not (self == other)
18664 
 
2690 chandransh 18665 
class processReturn_args:
18666 
  """
18667 
  Attributes:
18668 
   - returnOrderId
18669 
  """
18670 
 
18671 
  thrift_spec = (
18672 
    None, # 0
18673 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18674 
  )
18675 
 
18676 
  def __init__(self, returnOrderId=None,):
18677 
    self.returnOrderId = returnOrderId
18678 
 
18679 
  def read(self, iprot):
18680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18682 
      return
18683 
    iprot.readStructBegin()
18684 
    while True:
18685 
      (fname, ftype, fid) = iprot.readFieldBegin()
18686 
      if ftype == TType.STOP:
18687 
        break
18688 
      if fid == 1:
18689 
        if ftype == TType.I64:
18690 
          self.returnOrderId = iprot.readI64();
18691 
        else:
18692 
          iprot.skip(ftype)
18693 
      else:
18694 
        iprot.skip(ftype)
18695 
      iprot.readFieldEnd()
18696 
    iprot.readStructEnd()
18697 
 
18698 
  def write(self, oprot):
18699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18701 
      return
18702 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18703 
    if self.returnOrderId is not None:
2690 chandransh 18704 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18705 
      oprot.writeI64(self.returnOrderId)
18706 
      oprot.writeFieldEnd()
18707 
    oprot.writeFieldStop()
18708 
    oprot.writeStructEnd()
18709 
 
3431 rajveer 18710 
  def validate(self):
18711 
    return
18712 
 
18713 
 
2690 chandransh 18714 
  def __repr__(self):
18715 
    L = ['%s=%r' % (key, value)
18716 
      for key, value in self.__dict__.iteritems()]
18717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18718 
 
18719 
  def __eq__(self, other):
18720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18721 
 
18722 
  def __ne__(self, other):
18723 
    return not (self == other)
18724 
 
18725 
class processReturn_result:
18726 
  """
18727 
  Attributes:
18728 
   - ex
18729 
  """
18730 
 
18731 
  thrift_spec = (
18732 
    None, # 0
18733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18734 
  )
18735 
 
18736 
  def __init__(self, ex=None,):
18737 
    self.ex = ex
18738 
 
18739 
  def read(self, iprot):
18740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18742 
      return
18743 
    iprot.readStructBegin()
18744 
    while True:
18745 
      (fname, ftype, fid) = iprot.readFieldBegin()
18746 
      if ftype == TType.STOP:
18747 
        break
18748 
      if fid == 1:
18749 
        if ftype == TType.STRUCT:
18750 
          self.ex = TransactionServiceException()
18751 
          self.ex.read(iprot)
18752 
        else:
18753 
          iprot.skip(ftype)
18754 
      else:
18755 
        iprot.skip(ftype)
18756 
      iprot.readFieldEnd()
18757 
    iprot.readStructEnd()
18758 
 
18759 
  def write(self, oprot):
18760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18762 
      return
18763 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18764 
    if self.ex is not None:
2690 chandransh 18765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18766 
      self.ex.write(oprot)
18767 
      oprot.writeFieldEnd()
18768 
    oprot.writeFieldStop()
18769 
    oprot.writeStructEnd()
18770 
 
3431 rajveer 18771 
  def validate(self):
18772 
    return
18773 
 
18774 
 
2690 chandransh 18775 
  def __repr__(self):
18776 
    L = ['%s=%r' % (key, value)
18777 
      for key, value in self.__dict__.iteritems()]
18778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18779 
 
18780 
  def __eq__(self, other):
18781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18782 
 
18783 
  def __ne__(self, other):
18784 
    return not (self == other)
18785 
 
3451 chandransh 18786 
class updateWeight_args:
18787 
  """
18788 
  Attributes:
18789 
   - orderId
18790 
   - weight
18791 
  """
18792 
 
18793 
  thrift_spec = (
18794 
    None, # 0
18795 
    (1, TType.I64, 'orderId', None, None, ), # 1
18796 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18797 
  )
18798 
 
18799 
  def __init__(self, orderId=None, weight=None,):
18800 
    self.orderId = orderId
18801 
    self.weight = weight
18802 
 
18803 
  def read(self, iprot):
18804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18806 
      return
18807 
    iprot.readStructBegin()
18808 
    while True:
18809 
      (fname, ftype, fid) = iprot.readFieldBegin()
18810 
      if ftype == TType.STOP:
18811 
        break
18812 
      if fid == 1:
18813 
        if ftype == TType.I64:
18814 
          self.orderId = iprot.readI64();
18815 
        else:
18816 
          iprot.skip(ftype)
18817 
      elif fid == 2:
18818 
        if ftype == TType.DOUBLE:
18819 
          self.weight = iprot.readDouble();
18820 
        else:
18821 
          iprot.skip(ftype)
18822 
      else:
18823 
        iprot.skip(ftype)
18824 
      iprot.readFieldEnd()
18825 
    iprot.readStructEnd()
18826 
 
18827 
  def write(self, oprot):
18828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18830 
      return
18831 
    oprot.writeStructBegin('updateWeight_args')
18832 
    if self.orderId is not None:
18833 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18834 
      oprot.writeI64(self.orderId)
18835 
      oprot.writeFieldEnd()
18836 
    if self.weight is not None:
18837 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18838 
      oprot.writeDouble(self.weight)
18839 
      oprot.writeFieldEnd()
18840 
    oprot.writeFieldStop()
18841 
    oprot.writeStructEnd()
18842 
 
18843 
  def validate(self):
18844 
    return
18845 
 
18846 
 
18847 
  def __repr__(self):
18848 
    L = ['%s=%r' % (key, value)
18849 
      for key, value in self.__dict__.iteritems()]
18850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18851 
 
18852 
  def __eq__(self, other):
18853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18854 
 
18855 
  def __ne__(self, other):
18856 
    return not (self == other)
18857 
 
18858 
class updateWeight_result:
18859 
  """
18860 
  Attributes:
18861 
   - success
18862 
   - ex
18863 
  """
18864 
 
18865 
  thrift_spec = (
18866 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18867 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18868 
  )
18869 
 
18870 
  def __init__(self, success=None, ex=None,):
18871 
    self.success = success
18872 
    self.ex = ex
18873 
 
18874 
  def read(self, iprot):
18875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18877 
      return
18878 
    iprot.readStructBegin()
18879 
    while True:
18880 
      (fname, ftype, fid) = iprot.readFieldBegin()
18881 
      if ftype == TType.STOP:
18882 
        break
18883 
      if fid == 0:
18884 
        if ftype == TType.STRUCT:
18885 
          self.success = Order()
18886 
          self.success.read(iprot)
18887 
        else:
18888 
          iprot.skip(ftype)
18889 
      elif fid == 1:
18890 
        if ftype == TType.STRUCT:
18891 
          self.ex = TransactionServiceException()
18892 
          self.ex.read(iprot)
18893 
        else:
18894 
          iprot.skip(ftype)
18895 
      else:
18896 
        iprot.skip(ftype)
18897 
      iprot.readFieldEnd()
18898 
    iprot.readStructEnd()
18899 
 
18900 
  def write(self, oprot):
18901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18903 
      return
18904 
    oprot.writeStructBegin('updateWeight_result')
18905 
    if self.success is not None:
18906 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18907 
      self.success.write(oprot)
18908 
      oprot.writeFieldEnd()
18909 
    if self.ex is not None:
18910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18911 
      self.ex.write(oprot)
18912 
      oprot.writeFieldEnd()
18913 
    oprot.writeFieldStop()
18914 
    oprot.writeStructEnd()
18915 
 
18916 
  def validate(self):
18917 
    return
18918 
 
18919 
 
18920 
  def __repr__(self):
18921 
    L = ['%s=%r' % (key, value)
18922 
      for key, value in self.__dict__.iteritems()]
18923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18924 
 
18925 
  def __eq__(self, other):
18926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18927 
 
18928 
  def __ne__(self, other):
18929 
    return not (self == other)
3469 chandransh 18930 
 
18931 
class changeItem_args:
18932 
  """
18933 
  Attributes:
18934 
   - orderId
18935 
   - itemId
18936 
  """
18937 
 
18938 
  thrift_spec = (
18939 
    None, # 0
18940 
    (1, TType.I64, 'orderId', None, None, ), # 1
18941 
    (2, TType.I64, 'itemId', None, None, ), # 2
18942 
  )
18943 
 
18944 
  def __init__(self, orderId=None, itemId=None,):
18945 
    self.orderId = orderId
18946 
    self.itemId = itemId
18947 
 
18948 
  def read(self, iprot):
18949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18951 
      return
18952 
    iprot.readStructBegin()
18953 
    while True:
18954 
      (fname, ftype, fid) = iprot.readFieldBegin()
18955 
      if ftype == TType.STOP:
18956 
        break
18957 
      if fid == 1:
18958 
        if ftype == TType.I64:
18959 
          self.orderId = iprot.readI64();
18960 
        else:
18961 
          iprot.skip(ftype)
18962 
      elif fid == 2:
18963 
        if ftype == TType.I64:
18964 
          self.itemId = iprot.readI64();
18965 
        else:
18966 
          iprot.skip(ftype)
18967 
      else:
18968 
        iprot.skip(ftype)
18969 
      iprot.readFieldEnd()
18970 
    iprot.readStructEnd()
18971 
 
18972 
  def write(self, oprot):
18973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18975 
      return
18976 
    oprot.writeStructBegin('changeItem_args')
18977 
    if self.orderId is not None:
18978 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18979 
      oprot.writeI64(self.orderId)
18980 
      oprot.writeFieldEnd()
18981 
    if self.itemId is not None:
18982 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18983 
      oprot.writeI64(self.itemId)
18984 
      oprot.writeFieldEnd()
18985 
    oprot.writeFieldStop()
18986 
    oprot.writeStructEnd()
18987 
 
18988 
  def validate(self):
18989 
    return
18990 
 
18991 
 
18992 
  def __repr__(self):
18993 
    L = ['%s=%r' % (key, value)
18994 
      for key, value in self.__dict__.iteritems()]
18995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18996 
 
18997 
  def __eq__(self, other):
18998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18999 
 
19000 
  def __ne__(self, other):
19001 
    return not (self == other)
19002 
 
19003 
class changeItem_result:
19004 
  """
19005 
  Attributes:
19006 
   - success
19007 
   - ex
19008 
  """
19009 
 
19010 
  thrift_spec = (
19011 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19013 
  )
19014 
 
19015 
  def __init__(self, success=None, ex=None,):
19016 
    self.success = success
19017 
    self.ex = ex
19018 
 
19019 
  def read(self, iprot):
19020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19022 
      return
19023 
    iprot.readStructBegin()
19024 
    while True:
19025 
      (fname, ftype, fid) = iprot.readFieldBegin()
19026 
      if ftype == TType.STOP:
19027 
        break
19028 
      if fid == 0:
19029 
        if ftype == TType.STRUCT:
19030 
          self.success = Order()
19031 
          self.success.read(iprot)
19032 
        else:
19033 
          iprot.skip(ftype)
19034 
      elif fid == 1:
19035 
        if ftype == TType.STRUCT:
19036 
          self.ex = TransactionServiceException()
19037 
          self.ex.read(iprot)
19038 
        else:
19039 
          iprot.skip(ftype)
19040 
      else:
19041 
        iprot.skip(ftype)
19042 
      iprot.readFieldEnd()
19043 
    iprot.readStructEnd()
19044 
 
19045 
  def write(self, oprot):
19046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19048 
      return
19049 
    oprot.writeStructBegin('changeItem_result')
19050 
    if self.success is not None:
19051 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19052 
      self.success.write(oprot)
19053 
      oprot.writeFieldEnd()
19054 
    if self.ex is not None:
19055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19056 
      self.ex.write(oprot)
19057 
      oprot.writeFieldEnd()
19058 
    oprot.writeFieldStop()
19059 
    oprot.writeStructEnd()
19060 
 
19061 
  def validate(self):
19062 
    return
19063 
 
19064 
 
19065 
  def __repr__(self):
19066 
    L = ['%s=%r' % (key, value)
19067 
      for key, value in self.__dict__.iteritems()]
19068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19069 
 
19070 
  def __eq__(self, other):
19071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19072 
 
19073 
  def __ne__(self, other):
19074 
    return not (self == other)
19075 
 
19076 
class shiftToWarehouse_args:
19077 
  """
19078 
  Attributes:
19079 
   - orderId
19080 
   - warehouseId
19081 
  """
19082 
 
19083 
  thrift_spec = (
19084 
    None, # 0
19085 
    (1, TType.I64, 'orderId', None, None, ), # 1
19086 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19087 
  )
19088 
 
19089 
  def __init__(self, orderId=None, warehouseId=None,):
19090 
    self.orderId = orderId
19091 
    self.warehouseId = warehouseId
19092 
 
19093 
  def read(self, iprot):
19094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19096 
      return
19097 
    iprot.readStructBegin()
19098 
    while True:
19099 
      (fname, ftype, fid) = iprot.readFieldBegin()
19100 
      if ftype == TType.STOP:
19101 
        break
19102 
      if fid == 1:
19103 
        if ftype == TType.I64:
19104 
          self.orderId = iprot.readI64();
19105 
        else:
19106 
          iprot.skip(ftype)
19107 
      elif fid == 2:
19108 
        if ftype == TType.I64:
19109 
          self.warehouseId = iprot.readI64();
19110 
        else:
19111 
          iprot.skip(ftype)
19112 
      else:
19113 
        iprot.skip(ftype)
19114 
      iprot.readFieldEnd()
19115 
    iprot.readStructEnd()
19116 
 
19117 
  def write(self, oprot):
19118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19120 
      return
19121 
    oprot.writeStructBegin('shiftToWarehouse_args')
19122 
    if self.orderId is not None:
19123 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19124 
      oprot.writeI64(self.orderId)
19125 
      oprot.writeFieldEnd()
19126 
    if self.warehouseId is not None:
19127 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19128 
      oprot.writeI64(self.warehouseId)
19129 
      oprot.writeFieldEnd()
19130 
    oprot.writeFieldStop()
19131 
    oprot.writeStructEnd()
19132 
 
19133 
  def validate(self):
19134 
    return
19135 
 
19136 
 
19137 
  def __repr__(self):
19138 
    L = ['%s=%r' % (key, value)
19139 
      for key, value in self.__dict__.iteritems()]
19140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19141 
 
19142 
  def __eq__(self, other):
19143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19144 
 
19145 
  def __ne__(self, other):
19146 
    return not (self == other)
19147 
 
19148 
class shiftToWarehouse_result:
19149 
  """
19150 
  Attributes:
19151 
   - success
19152 
   - ex
19153 
  """
19154 
 
19155 
  thrift_spec = (
19156 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19158 
  )
19159 
 
19160 
  def __init__(self, success=None, ex=None,):
19161 
    self.success = success
19162 
    self.ex = ex
19163 
 
19164 
  def read(self, iprot):
19165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19167 
      return
19168 
    iprot.readStructBegin()
19169 
    while True:
19170 
      (fname, ftype, fid) = iprot.readFieldBegin()
19171 
      if ftype == TType.STOP:
19172 
        break
19173 
      if fid == 0:
19174 
        if ftype == TType.STRUCT:
19175 
          self.success = Order()
19176 
          self.success.read(iprot)
19177 
        else:
19178 
          iprot.skip(ftype)
19179 
      elif fid == 1:
19180 
        if ftype == TType.STRUCT:
19181 
          self.ex = TransactionServiceException()
19182 
          self.ex.read(iprot)
19183 
        else:
19184 
          iprot.skip(ftype)
19185 
      else:
19186 
        iprot.skip(ftype)
19187 
      iprot.readFieldEnd()
19188 
    iprot.readStructEnd()
19189 
 
19190 
  def write(self, oprot):
19191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19193 
      return
19194 
    oprot.writeStructBegin('shiftToWarehouse_result')
19195 
    if self.success is not None:
19196 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19197 
      self.success.write(oprot)
19198 
      oprot.writeFieldEnd()
19199 
    if self.ex is not None:
19200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19201 
      self.ex.write(oprot)
19202 
      oprot.writeFieldEnd()
19203 
    oprot.writeFieldStop()
19204 
    oprot.writeStructEnd()
19205 
 
19206 
  def validate(self):
19207 
    return
19208 
 
19209 
 
19210 
  def __repr__(self):
19211 
    L = ['%s=%r' % (key, value)
19212 
      for key, value in self.__dict__.iteritems()]
19213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19214 
 
19215 
  def __eq__(self, other):
19216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19217 
 
19218 
  def __ne__(self, other):
19219 
    return not (self == other)
3553 chandransh 19220 
 
19221 
class addDelayReason_args:
19222 
  """
19223 
  Attributes:
19224 
   - orderId
19225 
   - delayReason
3986 chandransh 19226 
   - furtherDelay
4647 rajveer 19227 
   - delayReasonText
3553 chandransh 19228 
  """
19229 
 
19230 
  thrift_spec = (
19231 
    None, # 0
19232 
    (1, TType.I64, 'orderId', None, None, ), # 1
19233 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19234 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19235 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19236 
  )
19237 
 
4647 rajveer 19238 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19239 
    self.orderId = orderId
19240 
    self.delayReason = delayReason
3986 chandransh 19241 
    self.furtherDelay = furtherDelay
4647 rajveer 19242 
    self.delayReasonText = delayReasonText
3553 chandransh 19243 
 
19244 
  def read(self, iprot):
19245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19247 
      return
19248 
    iprot.readStructBegin()
19249 
    while True:
19250 
      (fname, ftype, fid) = iprot.readFieldBegin()
19251 
      if ftype == TType.STOP:
19252 
        break
19253 
      if fid == 1:
19254 
        if ftype == TType.I64:
19255 
          self.orderId = iprot.readI64();
19256 
        else:
19257 
          iprot.skip(ftype)
19258 
      elif fid == 2:
19259 
        if ftype == TType.I32:
19260 
          self.delayReason = iprot.readI32();
19261 
        else:
19262 
          iprot.skip(ftype)
3986 chandransh 19263 
      elif fid == 3:
19264 
        if ftype == TType.I64:
19265 
          self.furtherDelay = iprot.readI64();
19266 
        else:
19267 
          iprot.skip(ftype)
4647 rajveer 19268 
      elif fid == 4:
19269 
        if ftype == TType.STRING:
19270 
          self.delayReasonText = iprot.readString();
19271 
        else:
19272 
          iprot.skip(ftype)
3553 chandransh 19273 
      else:
19274 
        iprot.skip(ftype)
19275 
      iprot.readFieldEnd()
19276 
    iprot.readStructEnd()
19277 
 
19278 
  def write(self, oprot):
19279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19281 
      return
19282 
    oprot.writeStructBegin('addDelayReason_args')
19283 
    if self.orderId is not None:
19284 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19285 
      oprot.writeI64(self.orderId)
19286 
      oprot.writeFieldEnd()
19287 
    if self.delayReason is not None:
19288 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19289 
      oprot.writeI32(self.delayReason)
19290 
      oprot.writeFieldEnd()
3986 chandransh 19291 
    if self.furtherDelay is not None:
19292 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19293 
      oprot.writeI64(self.furtherDelay)
19294 
      oprot.writeFieldEnd()
4647 rajveer 19295 
    if self.delayReasonText is not None:
19296 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19297 
      oprot.writeString(self.delayReasonText)
19298 
      oprot.writeFieldEnd()
3553 chandransh 19299 
    oprot.writeFieldStop()
19300 
    oprot.writeStructEnd()
19301 
 
19302 
  def validate(self):
19303 
    return
19304 
 
19305 
 
19306 
  def __repr__(self):
19307 
    L = ['%s=%r' % (key, value)
19308 
      for key, value in self.__dict__.iteritems()]
19309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19310 
 
19311 
  def __eq__(self, other):
19312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19313 
 
19314 
  def __ne__(self, other):
19315 
    return not (self == other)
19316 
 
19317 
class addDelayReason_result:
19318 
  """
19319 
  Attributes:
19320 
   - success
19321 
   - ex
19322 
  """
19323 
 
19324 
  thrift_spec = (
19325 
    (0, TType.BOOL, 'success', None, None, ), # 0
19326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19327 
  )
19328 
 
19329 
  def __init__(self, success=None, ex=None,):
19330 
    self.success = success
19331 
    self.ex = ex
19332 
 
19333 
  def read(self, iprot):
19334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19336 
      return
19337 
    iprot.readStructBegin()
19338 
    while True:
19339 
      (fname, ftype, fid) = iprot.readFieldBegin()
19340 
      if ftype == TType.STOP:
19341 
        break
19342 
      if fid == 0:
19343 
        if ftype == TType.BOOL:
19344 
          self.success = iprot.readBool();
19345 
        else:
19346 
          iprot.skip(ftype)
19347 
      elif fid == 1:
19348 
        if ftype == TType.STRUCT:
19349 
          self.ex = TransactionServiceException()
19350 
          self.ex.read(iprot)
19351 
        else:
19352 
          iprot.skip(ftype)
19353 
      else:
19354 
        iprot.skip(ftype)
19355 
      iprot.readFieldEnd()
19356 
    iprot.readStructEnd()
19357 
 
19358 
  def write(self, oprot):
19359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19361 
      return
19362 
    oprot.writeStructBegin('addDelayReason_result')
19363 
    if self.success is not None:
19364 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19365 
      oprot.writeBool(self.success)
19366 
      oprot.writeFieldEnd()
19367 
    if self.ex is not None:
19368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19369 
      self.ex.write(oprot)
19370 
      oprot.writeFieldEnd()
19371 
    oprot.writeFieldStop()
19372 
    oprot.writeStructEnd()
19373 
 
19374 
  def validate(self):
19375 
    return
19376 
 
19377 
 
19378 
  def __repr__(self):
19379 
    L = ['%s=%r' % (key, value)
19380 
      for key, value in self.__dict__.iteritems()]
19381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19382 
 
19383 
  def __eq__(self, other):
19384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19385 
 
19386 
  def __ne__(self, other):
19387 
    return not (self == other)
3956 chandransh 19388 
 
19389 
class reconcileCodCollection_args:
19390 
  """
19391 
  Attributes:
19392 
   - collectedAmountMap
19393 
   - xferBy
19394 
   - xferTxnId
19395 
   - xferDate
19396 
  """
19397 
 
19398 
  thrift_spec = (
19399 
    None, # 0
19400 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19401 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19402 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19403 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19404 
  )
19405 
 
19406 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19407 
    self.collectedAmountMap = collectedAmountMap
19408 
    self.xferBy = xferBy
19409 
    self.xferTxnId = xferTxnId
19410 
    self.xferDate = xferDate
19411 
 
19412 
  def read(self, iprot):
19413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19415 
      return
19416 
    iprot.readStructBegin()
19417 
    while True:
19418 
      (fname, ftype, fid) = iprot.readFieldBegin()
19419 
      if ftype == TType.STOP:
19420 
        break
19421 
      if fid == 1:
19422 
        if ftype == TType.MAP:
19423 
          self.collectedAmountMap = {}
6188 rajveer 19424 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19425 
          for _i457 in xrange(_size453):
19426 
            _key458 = iprot.readString();
19427 
            _val459 = iprot.readDouble();
19428 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19429 
          iprot.readMapEnd()
19430 
        else:
19431 
          iprot.skip(ftype)
19432 
      elif fid == 2:
19433 
        if ftype == TType.STRING:
19434 
          self.xferBy = iprot.readString();
19435 
        else:
19436 
          iprot.skip(ftype)
19437 
      elif fid == 3:
19438 
        if ftype == TType.STRING:
19439 
          self.xferTxnId = iprot.readString();
19440 
        else:
19441 
          iprot.skip(ftype)
19442 
      elif fid == 4:
19443 
        if ftype == TType.I64:
19444 
          self.xferDate = iprot.readI64();
19445 
        else:
19446 
          iprot.skip(ftype)
19447 
      else:
19448 
        iprot.skip(ftype)
19449 
      iprot.readFieldEnd()
19450 
    iprot.readStructEnd()
19451 
 
19452 
  def write(self, oprot):
19453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19455 
      return
19456 
    oprot.writeStructBegin('reconcileCodCollection_args')
19457 
    if self.collectedAmountMap is not None:
19458 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19459 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19460 
      for kiter460,viter461 in self.collectedAmountMap.items():
19461 
        oprot.writeString(kiter460)
19462 
        oprot.writeDouble(viter461)
3956 chandransh 19463 
      oprot.writeMapEnd()
19464 
      oprot.writeFieldEnd()
19465 
    if self.xferBy is not None:
19466 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19467 
      oprot.writeString(self.xferBy)
19468 
      oprot.writeFieldEnd()
19469 
    if self.xferTxnId is not None:
19470 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19471 
      oprot.writeString(self.xferTxnId)
19472 
      oprot.writeFieldEnd()
19473 
    if self.xferDate is not None:
19474 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19475 
      oprot.writeI64(self.xferDate)
19476 
      oprot.writeFieldEnd()
19477 
    oprot.writeFieldStop()
19478 
    oprot.writeStructEnd()
19479 
 
19480 
  def validate(self):
19481 
    return
19482 
 
19483 
 
19484 
  def __repr__(self):
19485 
    L = ['%s=%r' % (key, value)
19486 
      for key, value in self.__dict__.iteritems()]
19487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19488 
 
19489 
  def __eq__(self, other):
19490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19491 
 
19492 
  def __ne__(self, other):
19493 
    return not (self == other)
19494 
 
19495 
class reconcileCodCollection_result:
19496 
  """
19497 
  Attributes:
19498 
   - success
19499 
   - ex
19500 
  """
19501 
 
19502 
  thrift_spec = (
19503 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19505 
  )
19506 
 
19507 
  def __init__(self, success=None, ex=None,):
19508 
    self.success = success
19509 
    self.ex = ex
19510 
 
19511 
  def read(self, iprot):
19512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19514 
      return
19515 
    iprot.readStructBegin()
19516 
    while True:
19517 
      (fname, ftype, fid) = iprot.readFieldBegin()
19518 
      if ftype == TType.STOP:
19519 
        break
19520 
      if fid == 0:
19521 
        if ftype == TType.MAP:
19522 
          self.success = {}
6188 rajveer 19523 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19524 
          for _i466 in xrange(_size462):
19525 
            _key467 = iprot.readString();
19526 
            _val468 = iprot.readString();
19527 
            self.success[_key467] = _val468
3956 chandransh 19528 
          iprot.readMapEnd()
19529 
        else:
19530 
          iprot.skip(ftype)
19531 
      elif fid == 1:
19532 
        if ftype == TType.STRUCT:
19533 
          self.ex = TransactionServiceException()
19534 
          self.ex.read(iprot)
19535 
        else:
19536 
          iprot.skip(ftype)
19537 
      else:
19538 
        iprot.skip(ftype)
19539 
      iprot.readFieldEnd()
19540 
    iprot.readStructEnd()
19541 
 
19542 
  def write(self, oprot):
19543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19545 
      return
19546 
    oprot.writeStructBegin('reconcileCodCollection_result')
19547 
    if self.success is not None:
19548 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19549 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19550 
      for kiter469,viter470 in self.success.items():
19551 
        oprot.writeString(kiter469)
19552 
        oprot.writeString(viter470)
3956 chandransh 19553 
      oprot.writeMapEnd()
19554 
      oprot.writeFieldEnd()
19555 
    if self.ex is not None:
19556 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19557 
      self.ex.write(oprot)
19558 
      oprot.writeFieldEnd()
19559 
    oprot.writeFieldStop()
19560 
    oprot.writeStructEnd()
19561 
 
19562 
  def validate(self):
19563 
    return
19564 
 
19565 
 
19566 
  def __repr__(self):
19567 
    L = ['%s=%r' % (key, value)
19568 
      for key, value in self.__dict__.iteritems()]
19569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19570 
 
19571 
  def __eq__(self, other):
19572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19573 
 
19574 
  def __ne__(self, other):
19575 
    return not (self == other)
4008 mandeep.dh 19576 
 
19577 
class getTransactionsRequiringExtraProcessing_args:
19578 
  """
19579 
  Attributes:
19580 
   - category
19581 
  """
19582 
 
19583 
  thrift_spec = (
19584 
    None, # 0
19585 
    (1, TType.I32, 'category', None, None, ), # 1
19586 
  )
19587 
 
19588 
  def __init__(self, category=None,):
19589 
    self.category = category
19590 
 
19591 
  def read(self, iprot):
19592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19594 
      return
19595 
    iprot.readStructBegin()
19596 
    while True:
19597 
      (fname, ftype, fid) = iprot.readFieldBegin()
19598 
      if ftype == TType.STOP:
19599 
        break
19600 
      if fid == 1:
19601 
        if ftype == TType.I32:
19602 
          self.category = iprot.readI32();
19603 
        else:
19604 
          iprot.skip(ftype)
19605 
      else:
19606 
        iprot.skip(ftype)
19607 
      iprot.readFieldEnd()
19608 
    iprot.readStructEnd()
19609 
 
19610 
  def write(self, oprot):
19611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19613 
      return
19614 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19615 
    if self.category is not None:
19616 
      oprot.writeFieldBegin('category', TType.I32, 1)
19617 
      oprot.writeI32(self.category)
19618 
      oprot.writeFieldEnd()
19619 
    oprot.writeFieldStop()
19620 
    oprot.writeStructEnd()
19621 
 
19622 
  def validate(self):
19623 
    return
19624 
 
19625 
 
19626 
  def __repr__(self):
19627 
    L = ['%s=%r' % (key, value)
19628 
      for key, value in self.__dict__.iteritems()]
19629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19630 
 
19631 
  def __eq__(self, other):
19632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19633 
 
19634 
  def __ne__(self, other):
19635 
    return not (self == other)
19636 
 
19637 
class getTransactionsRequiringExtraProcessing_result:
19638 
  """
19639 
  Attributes:
19640 
   - success
19641 
  """
19642 
 
19643 
  thrift_spec = (
19644 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19645 
  )
19646 
 
19647 
  def __init__(self, success=None,):
19648 
    self.success = success
19649 
 
19650 
  def read(self, iprot):
19651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19653 
      return
19654 
    iprot.readStructBegin()
19655 
    while True:
19656 
      (fname, ftype, fid) = iprot.readFieldBegin()
19657 
      if ftype == TType.STOP:
19658 
        break
19659 
      if fid == 0:
19660 
        if ftype == TType.LIST:
19661 
          self.success = []
6188 rajveer 19662 
          (_etype474, _size471) = iprot.readListBegin()
19663 
          for _i475 in xrange(_size471):
19664 
            _elem476 = iprot.readI64();
19665 
            self.success.append(_elem476)
4008 mandeep.dh 19666 
          iprot.readListEnd()
19667 
        else:
19668 
          iprot.skip(ftype)
19669 
      else:
19670 
        iprot.skip(ftype)
19671 
      iprot.readFieldEnd()
19672 
    iprot.readStructEnd()
19673 
 
19674 
  def write(self, oprot):
19675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19677 
      return
19678 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19679 
    if self.success is not None:
19680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19681 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19682 
      for iter477 in self.success:
19683 
        oprot.writeI64(iter477)
4008 mandeep.dh 19684 
      oprot.writeListEnd()
19685 
      oprot.writeFieldEnd()
19686 
    oprot.writeFieldStop()
19687 
    oprot.writeStructEnd()
19688 
 
19689 
  def validate(self):
19690 
    return
19691 
 
19692 
 
19693 
  def __repr__(self):
19694 
    L = ['%s=%r' % (key, value)
19695 
      for key, value in self.__dict__.iteritems()]
19696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19697 
 
19698 
  def __eq__(self, other):
19699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19700 
 
19701 
  def __ne__(self, other):
19702 
    return not (self == other)
19703 
 
19704 
class markTransactionAsProcessed_args:
19705 
  """
19706 
  Attributes:
19707 
   - transactionId
19708 
   - category
19709 
  """
19710 
 
19711 
  thrift_spec = (
19712 
    None, # 0
19713 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19714 
    (2, TType.I32, 'category', None, None, ), # 2
19715 
  )
19716 
 
19717 
  def __init__(self, transactionId=None, category=None,):
19718 
    self.transactionId = transactionId
19719 
    self.category = category
19720 
 
19721 
  def read(self, iprot):
19722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19724 
      return
19725 
    iprot.readStructBegin()
19726 
    while True:
19727 
      (fname, ftype, fid) = iprot.readFieldBegin()
19728 
      if ftype == TType.STOP:
19729 
        break
19730 
      if fid == 1:
19731 
        if ftype == TType.I64:
19732 
          self.transactionId = iprot.readI64();
19733 
        else:
19734 
          iprot.skip(ftype)
19735 
      elif fid == 2:
19736 
        if ftype == TType.I32:
19737 
          self.category = iprot.readI32();
19738 
        else:
19739 
          iprot.skip(ftype)
19740 
      else:
19741 
        iprot.skip(ftype)
19742 
      iprot.readFieldEnd()
19743 
    iprot.readStructEnd()
19744 
 
19745 
  def write(self, oprot):
19746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19748 
      return
19749 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19750 
    if self.transactionId is not None:
19751 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19752 
      oprot.writeI64(self.transactionId)
19753 
      oprot.writeFieldEnd()
19754 
    if self.category is not None:
19755 
      oprot.writeFieldBegin('category', TType.I32, 2)
19756 
      oprot.writeI32(self.category)
19757 
      oprot.writeFieldEnd()
19758 
    oprot.writeFieldStop()
19759 
    oprot.writeStructEnd()
19760 
 
19761 
  def validate(self):
19762 
    return
19763 
 
19764 
 
19765 
  def __repr__(self):
19766 
    L = ['%s=%r' % (key, value)
19767 
      for key, value in self.__dict__.iteritems()]
19768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19769 
 
19770 
  def __eq__(self, other):
19771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19772 
 
19773 
  def __ne__(self, other):
19774 
    return not (self == other)
19775 
 
19776 
class markTransactionAsProcessed_result:
19777 
 
19778 
  thrift_spec = (
19779 
  )
19780 
 
19781 
  def read(self, iprot):
19782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19784 
      return
19785 
    iprot.readStructBegin()
19786 
    while True:
19787 
      (fname, ftype, fid) = iprot.readFieldBegin()
19788 
      if ftype == TType.STOP:
19789 
        break
19790 
      else:
19791 
        iprot.skip(ftype)
19792 
      iprot.readFieldEnd()
19793 
    iprot.readStructEnd()
19794 
 
19795 
  def write(self, oprot):
19796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19798 
      return
19799 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19800 
    oprot.writeFieldStop()
19801 
    oprot.writeStructEnd()
19802 
 
19803 
  def validate(self):
19804 
    return
19805 
 
19806 
 
19807 
  def __repr__(self):
19808 
    L = ['%s=%r' % (key, value)
19809 
      for key, value in self.__dict__.iteritems()]
19810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19811 
 
19812 
  def __eq__(self, other):
19813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19814 
 
19815 
  def __ne__(self, other):
19816 
    return not (self == other)
4018 chandransh 19817 
 
19818 
class getItemWiseRiskyOrdersCount_args:
19819 
 
19820 
  thrift_spec = (
19821 
  )
19822 
 
19823 
  def read(self, iprot):
19824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19826 
      return
19827 
    iprot.readStructBegin()
19828 
    while True:
19829 
      (fname, ftype, fid) = iprot.readFieldBegin()
19830 
      if ftype == TType.STOP:
19831 
        break
19832 
      else:
19833 
        iprot.skip(ftype)
19834 
      iprot.readFieldEnd()
19835 
    iprot.readStructEnd()
19836 
 
19837 
  def write(self, oprot):
19838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19840 
      return
19841 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19842 
    oprot.writeFieldStop()
19843 
    oprot.writeStructEnd()
19844 
 
19845 
  def validate(self):
19846 
    return
19847 
 
19848 
 
19849 
  def __repr__(self):
19850 
    L = ['%s=%r' % (key, value)
19851 
      for key, value in self.__dict__.iteritems()]
19852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19853 
 
19854 
  def __eq__(self, other):
19855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19856 
 
19857 
  def __ne__(self, other):
19858 
    return not (self == other)
19859 
 
19860 
class getItemWiseRiskyOrdersCount_result:
19861 
  """
19862 
  Attributes:
19863 
   - success
19864 
  """
19865 
 
19866 
  thrift_spec = (
19867 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19868 
  )
19869 
 
19870 
  def __init__(self, success=None,):
19871 
    self.success = success
19872 
 
19873 
  def read(self, iprot):
19874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19876 
      return
19877 
    iprot.readStructBegin()
19878 
    while True:
19879 
      (fname, ftype, fid) = iprot.readFieldBegin()
19880 
      if ftype == TType.STOP:
19881 
        break
19882 
      if fid == 0:
19883 
        if ftype == TType.MAP:
19884 
          self.success = {}
6188 rajveer 19885 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
19886 
          for _i482 in xrange(_size478):
19887 
            _key483 = iprot.readI64();
19888 
            _val484 = iprot.readI64();
19889 
            self.success[_key483] = _val484
4018 chandransh 19890 
          iprot.readMapEnd()
19891 
        else:
19892 
          iprot.skip(ftype)
19893 
      else:
19894 
        iprot.skip(ftype)
19895 
      iprot.readFieldEnd()
19896 
    iprot.readStructEnd()
19897 
 
19898 
  def write(self, oprot):
19899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19901 
      return
19902 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19903 
    if self.success is not None:
19904 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19905 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 19906 
      for kiter485,viter486 in self.success.items():
19907 
        oprot.writeI64(kiter485)
19908 
        oprot.writeI64(viter486)
4018 chandransh 19909 
      oprot.writeMapEnd()
19910 
      oprot.writeFieldEnd()
19911 
    oprot.writeFieldStop()
19912 
    oprot.writeStructEnd()
19913 
 
19914 
  def validate(self):
19915 
    return
19916 
 
19917 
 
19918 
  def __repr__(self):
19919 
    L = ['%s=%r' % (key, value)
19920 
      for key, value in self.__dict__.iteritems()]
19921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19922 
 
19923 
  def __eq__(self, other):
19924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19925 
 
19926 
  def __ne__(self, other):
19927 
    return not (self == other)
4247 rajveer 19928 
 
4295 varun.gupt 19929 
class getOrdersForItemIds_args:
19930 
  """
19931 
  Attributes:
19932 
   - itemIds
19933 
  """
19934 
 
19935 
  thrift_spec = (
19936 
    None, # 0
19937 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19938 
  )
19939 
 
19940 
  def __init__(self, itemIds=None,):
19941 
    self.itemIds = itemIds
19942 
 
19943 
  def read(self, iprot):
19944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19946 
      return
19947 
    iprot.readStructBegin()
19948 
    while True:
19949 
      (fname, ftype, fid) = iprot.readFieldBegin()
19950 
      if ftype == TType.STOP:
19951 
        break
19952 
      if fid == 1:
19953 
        if ftype == TType.LIST:
19954 
          self.itemIds = []
6188 rajveer 19955 
          (_etype490, _size487) = iprot.readListBegin()
19956 
          for _i491 in xrange(_size487):
19957 
            _elem492 = iprot.readI64();
19958 
            self.itemIds.append(_elem492)
4295 varun.gupt 19959 
          iprot.readListEnd()
19960 
        else:
19961 
          iprot.skip(ftype)
19962 
      else:
19963 
        iprot.skip(ftype)
19964 
      iprot.readFieldEnd()
19965 
    iprot.readStructEnd()
19966 
 
19967 
  def write(self, oprot):
19968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19970 
      return
19971 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19972 
    if self.itemIds is not None:
19973 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19974 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 19975 
      for iter493 in self.itemIds:
19976 
        oprot.writeI64(iter493)
4295 varun.gupt 19977 
      oprot.writeListEnd()
19978 
      oprot.writeFieldEnd()
19979 
    oprot.writeFieldStop()
19980 
    oprot.writeStructEnd()
19981 
 
19982 
  def validate(self):
19983 
    return
19984 
 
19985 
 
19986 
  def __repr__(self):
19987 
    L = ['%s=%r' % (key, value)
19988 
      for key, value in self.__dict__.iteritems()]
19989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19990 
 
19991 
  def __eq__(self, other):
19992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19993 
 
19994 
  def __ne__(self, other):
19995 
    return not (self == other)
19996 
 
19997 
class getOrdersForItemIds_result:
19998 
  """
19999 
  Attributes:
20000 
   - success
20001 
  """
20002 
 
20003 
  thrift_spec = (
20004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20005 
  )
20006 
 
20007 
  def __init__(self, success=None,):
20008 
    self.success = success
20009 
 
20010 
  def read(self, iprot):
20011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20013 
      return
20014 
    iprot.readStructBegin()
20015 
    while True:
20016 
      (fname, ftype, fid) = iprot.readFieldBegin()
20017 
      if ftype == TType.STOP:
20018 
        break
20019 
      if fid == 0:
20020 
        if ftype == TType.LIST:
20021 
          self.success = []
6188 rajveer 20022 
          (_etype497, _size494) = iprot.readListBegin()
20023 
          for _i498 in xrange(_size494):
20024 
            _elem499 = Order()
20025 
            _elem499.read(iprot)
20026 
            self.success.append(_elem499)
4295 varun.gupt 20027 
          iprot.readListEnd()
20028 
        else:
20029 
          iprot.skip(ftype)
20030 
      else:
20031 
        iprot.skip(ftype)
20032 
      iprot.readFieldEnd()
20033 
    iprot.readStructEnd()
20034 
 
20035 
  def write(self, oprot):
20036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20038 
      return
20039 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20040 
    if self.success is not None:
20041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20043 
      for iter500 in self.success:
20044 
        iter500.write(oprot)
4295 varun.gupt 20045 
      oprot.writeListEnd()
20046 
      oprot.writeFieldEnd()
20047 
    oprot.writeFieldStop()
20048 
    oprot.writeStructEnd()
20049 
 
20050 
  def validate(self):
20051 
    return
20052 
 
20053 
 
20054 
  def __repr__(self):
20055 
    L = ['%s=%r' % (key, value)
20056 
      for key, value in self.__dict__.iteritems()]
20057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20058 
 
20059 
  def __eq__(self, other):
20060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20061 
 
20062 
  def __ne__(self, other):
20063 
    return not (self == other)
20064 
 
4247 rajveer 20065 
class markOrderCancellationRequestReceived_args:
20066 
  """
20067 
  Attributes:
20068 
   - orderId
20069 
  """
20070 
 
20071 
  thrift_spec = (
20072 
    None, # 0
20073 
    (1, TType.I64, 'orderId', None, None, ), # 1
20074 
  )
20075 
 
20076 
  def __init__(self, orderId=None,):
20077 
    self.orderId = orderId
20078 
 
20079 
  def read(self, iprot):
20080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20082 
      return
20083 
    iprot.readStructBegin()
20084 
    while True:
20085 
      (fname, ftype, fid) = iprot.readFieldBegin()
20086 
      if ftype == TType.STOP:
20087 
        break
20088 
      if fid == 1:
20089 
        if ftype == TType.I64:
20090 
          self.orderId = iprot.readI64();
20091 
        else:
20092 
          iprot.skip(ftype)
20093 
      else:
20094 
        iprot.skip(ftype)
20095 
      iprot.readFieldEnd()
20096 
    iprot.readStructEnd()
20097 
 
20098 
  def write(self, oprot):
20099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20101 
      return
20102 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20103 
    if self.orderId is not None:
20104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20105 
      oprot.writeI64(self.orderId)
20106 
      oprot.writeFieldEnd()
20107 
    oprot.writeFieldStop()
20108 
    oprot.writeStructEnd()
20109 
 
20110 
  def validate(self):
20111 
    return
20112 
 
20113 
 
20114 
  def __repr__(self):
20115 
    L = ['%s=%r' % (key, value)
20116 
      for key, value in self.__dict__.iteritems()]
20117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20118 
 
20119 
  def __eq__(self, other):
20120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20121 
 
20122 
  def __ne__(self, other):
20123 
    return not (self == other)
20124 
 
20125 
class markOrderCancellationRequestReceived_result:
20126 
  """
20127 
  Attributes:
20128 
   - ex
20129 
  """
20130 
 
20131 
  thrift_spec = (
20132 
    None, # 0
20133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20134 
  )
20135 
 
20136 
  def __init__(self, ex=None,):
20137 
    self.ex = ex
20138 
 
20139 
  def read(self, iprot):
20140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20142 
      return
20143 
    iprot.readStructBegin()
20144 
    while True:
20145 
      (fname, ftype, fid) = iprot.readFieldBegin()
20146 
      if ftype == TType.STOP:
20147 
        break
20148 
      if fid == 1:
20149 
        if ftype == TType.STRUCT:
20150 
          self.ex = TransactionServiceException()
20151 
          self.ex.read(iprot)
20152 
        else:
20153 
          iprot.skip(ftype)
20154 
      else:
20155 
        iprot.skip(ftype)
20156 
      iprot.readFieldEnd()
20157 
    iprot.readStructEnd()
20158 
 
20159 
  def write(self, oprot):
20160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20162 
      return
20163 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20164 
    if self.ex is not None:
20165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20166 
      self.ex.write(oprot)
20167 
      oprot.writeFieldEnd()
20168 
    oprot.writeFieldStop()
20169 
    oprot.writeStructEnd()
20170 
 
20171 
  def validate(self):
20172 
    return
20173 
 
20174 
 
20175 
  def __repr__(self):
20176 
    L = ['%s=%r' % (key, value)
20177 
      for key, value in self.__dict__.iteritems()]
20178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20179 
 
20180 
  def __eq__(self, other):
20181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20182 
 
20183 
  def __ne__(self, other):
20184 
    return not (self == other)
20185 
 
20186 
class markOrderCancellationRequestConfirmed_args:
20187 
  """
20188 
  Attributes:
20189 
   - orderId
20190 
  """
20191 
 
20192 
  thrift_spec = (
20193 
    None, # 0
20194 
    (1, TType.I64, 'orderId', None, None, ), # 1
20195 
  )
20196 
 
20197 
  def __init__(self, orderId=None,):
20198 
    self.orderId = orderId
20199 
 
20200 
  def read(self, iprot):
20201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20203 
      return
20204 
    iprot.readStructBegin()
20205 
    while True:
20206 
      (fname, ftype, fid) = iprot.readFieldBegin()
20207 
      if ftype == TType.STOP:
20208 
        break
20209 
      if fid == 1:
20210 
        if ftype == TType.I64:
20211 
          self.orderId = iprot.readI64();
20212 
        else:
20213 
          iprot.skip(ftype)
20214 
      else:
20215 
        iprot.skip(ftype)
20216 
      iprot.readFieldEnd()
20217 
    iprot.readStructEnd()
20218 
 
20219 
  def write(self, oprot):
20220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20222 
      return
20223 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20224 
    if self.orderId is not None:
20225 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20226 
      oprot.writeI64(self.orderId)
20227 
      oprot.writeFieldEnd()
20228 
    oprot.writeFieldStop()
20229 
    oprot.writeStructEnd()
20230 
 
20231 
  def validate(self):
20232 
    return
20233 
 
20234 
 
20235 
  def __repr__(self):
20236 
    L = ['%s=%r' % (key, value)
20237 
      for key, value in self.__dict__.iteritems()]
20238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20239 
 
20240 
  def __eq__(self, other):
20241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20242 
 
20243 
  def __ne__(self, other):
20244 
    return not (self == other)
20245 
 
20246 
class markOrderCancellationRequestConfirmed_result:
20247 
  """
20248 
  Attributes:
20249 
   - ex
20250 
  """
20251 
 
20252 
  thrift_spec = (
20253 
    None, # 0
20254 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20255 
  )
20256 
 
20257 
  def __init__(self, ex=None,):
20258 
    self.ex = ex
20259 
 
20260 
  def read(self, iprot):
20261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20263 
      return
20264 
    iprot.readStructBegin()
20265 
    while True:
20266 
      (fname, ftype, fid) = iprot.readFieldBegin()
20267 
      if ftype == TType.STOP:
20268 
        break
20269 
      if fid == 1:
20270 
        if ftype == TType.STRUCT:
20271 
          self.ex = TransactionServiceException()
20272 
          self.ex.read(iprot)
20273 
        else:
20274 
          iprot.skip(ftype)
20275 
      else:
20276 
        iprot.skip(ftype)
20277 
      iprot.readFieldEnd()
20278 
    iprot.readStructEnd()
20279 
 
20280 
  def write(self, oprot):
20281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20283 
      return
20284 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20285 
    if self.ex is not None:
20286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20287 
      self.ex.write(oprot)
20288 
      oprot.writeFieldEnd()
20289 
    oprot.writeFieldStop()
20290 
    oprot.writeStructEnd()
20291 
 
20292 
  def validate(self):
20293 
    return
20294 
 
20295 
 
20296 
  def __repr__(self):
20297 
    L = ['%s=%r' % (key, value)
20298 
      for key, value in self.__dict__.iteritems()]
20299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20300 
 
20301 
  def __eq__(self, other):
20302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20303 
 
20304 
  def __ne__(self, other):
20305 
    return not (self == other)
20306 
 
20307 
class markOrderCancellationRequestDenied_args:
20308 
  """
20309 
  Attributes:
20310 
   - orderId
20311 
  """
20312 
 
20313 
  thrift_spec = (
20314 
    None, # 0
20315 
    (1, TType.I64, 'orderId', None, None, ), # 1
20316 
  )
20317 
 
20318 
  def __init__(self, orderId=None,):
20319 
    self.orderId = orderId
20320 
 
20321 
  def read(self, iprot):
20322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20324 
      return
20325 
    iprot.readStructBegin()
20326 
    while True:
20327 
      (fname, ftype, fid) = iprot.readFieldBegin()
20328 
      if ftype == TType.STOP:
20329 
        break
20330 
      if fid == 1:
20331 
        if ftype == TType.I64:
20332 
          self.orderId = iprot.readI64();
20333 
        else:
20334 
          iprot.skip(ftype)
20335 
      else:
20336 
        iprot.skip(ftype)
20337 
      iprot.readFieldEnd()
20338 
    iprot.readStructEnd()
20339 
 
20340 
  def write(self, oprot):
20341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20343 
      return
20344 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20345 
    if self.orderId is not None:
20346 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20347 
      oprot.writeI64(self.orderId)
20348 
      oprot.writeFieldEnd()
20349 
    oprot.writeFieldStop()
20350 
    oprot.writeStructEnd()
20351 
 
20352 
  def validate(self):
20353 
    return
20354 
 
20355 
 
20356 
  def __repr__(self):
20357 
    L = ['%s=%r' % (key, value)
20358 
      for key, value in self.__dict__.iteritems()]
20359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20360 
 
20361 
  def __eq__(self, other):
20362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20363 
 
20364 
  def __ne__(self, other):
20365 
    return not (self == other)
20366 
 
20367 
class markOrderCancellationRequestDenied_result:
20368 
  """
20369 
  Attributes:
20370 
   - ex
20371 
  """
20372 
 
20373 
  thrift_spec = (
20374 
    None, # 0
20375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20376 
  )
20377 
 
20378 
  def __init__(self, ex=None,):
20379 
    self.ex = ex
20380 
 
20381 
  def read(self, iprot):
20382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20384 
      return
20385 
    iprot.readStructBegin()
20386 
    while True:
20387 
      (fname, ftype, fid) = iprot.readFieldBegin()
20388 
      if ftype == TType.STOP:
20389 
        break
20390 
      if fid == 1:
20391 
        if ftype == TType.STRUCT:
20392 
          self.ex = TransactionServiceException()
20393 
          self.ex.read(iprot)
20394 
        else:
20395 
          iprot.skip(ftype)
20396 
      else:
20397 
        iprot.skip(ftype)
20398 
      iprot.readFieldEnd()
20399 
    iprot.readStructEnd()
20400 
 
20401 
  def write(self, oprot):
20402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20404 
      return
20405 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20406 
    if self.ex is not None:
20407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20408 
      self.ex.write(oprot)
20409 
      oprot.writeFieldEnd()
20410 
    oprot.writeFieldStop()
20411 
    oprot.writeStructEnd()
20412 
 
20413 
  def validate(self):
20414 
    return
20415 
 
20416 
 
20417 
  def __repr__(self):
20418 
    L = ['%s=%r' % (key, value)
20419 
      for key, value in self.__dict__.iteritems()]
20420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20421 
 
20422 
  def __eq__(self, other):
20423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20424 
 
20425 
  def __ne__(self, other):
20426 
    return not (self == other)
20427 
 
4258 rajveer 20428 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20429 
  """
20430 
  Attributes:
4258 rajveer 20431 
   - transactionId
4247 rajveer 20432 
  """
20433 
 
20434 
  thrift_spec = (
20435 
    None, # 0
4258 rajveer 20436 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20437 
  )
20438 
 
4258 rajveer 20439 
  def __init__(self, transactionId=None,):
20440 
    self.transactionId = transactionId
4247 rajveer 20441 
 
20442 
  def read(self, iprot):
20443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20445 
      return
20446 
    iprot.readStructBegin()
20447 
    while True:
20448 
      (fname, ftype, fid) = iprot.readFieldBegin()
20449 
      if ftype == TType.STOP:
20450 
        break
20451 
      if fid == 1:
20452 
        if ftype == TType.I64:
4258 rajveer 20453 
          self.transactionId = iprot.readI64();
4247 rajveer 20454 
        else:
20455 
          iprot.skip(ftype)
20456 
      else:
20457 
        iprot.skip(ftype)
20458 
      iprot.readFieldEnd()
20459 
    iprot.readStructEnd()
20460 
 
20461 
  def write(self, oprot):
20462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20464 
      return
4258 rajveer 20465 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20466 
    if self.transactionId is not None:
20467 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20468 
      oprot.writeI64(self.transactionId)
4247 rajveer 20469 
      oprot.writeFieldEnd()
20470 
    oprot.writeFieldStop()
20471 
    oprot.writeStructEnd()
20472 
 
20473 
  def validate(self):
20474 
    return
20475 
 
20476 
 
20477 
  def __repr__(self):
20478 
    L = ['%s=%r' % (key, value)
20479 
      for key, value in self.__dict__.iteritems()]
20480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20481 
 
20482 
  def __eq__(self, other):
20483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20484 
 
20485 
  def __ne__(self, other):
20486 
    return not (self == other)
20487 
 
4258 rajveer 20488 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20489 
  """
20490 
  Attributes:
20491 
   - ex
20492 
  """
20493 
 
20494 
  thrift_spec = (
20495 
    None, # 0
20496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20497 
  )
20498 
 
20499 
  def __init__(self, ex=None,):
20500 
    self.ex = ex
20501 
 
20502 
  def read(self, iprot):
20503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20505 
      return
20506 
    iprot.readStructBegin()
20507 
    while True:
20508 
      (fname, ftype, fid) = iprot.readFieldBegin()
20509 
      if ftype == TType.STOP:
20510 
        break
20511 
      if fid == 1:
20512 
        if ftype == TType.STRUCT:
20513 
          self.ex = TransactionServiceException()
20514 
          self.ex.read(iprot)
20515 
        else:
20516 
          iprot.skip(ftype)
20517 
      else:
20518 
        iprot.skip(ftype)
20519 
      iprot.readFieldEnd()
20520 
    iprot.readStructEnd()
20521 
 
20522 
  def write(self, oprot):
20523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20525 
      return
4258 rajveer 20526 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20527 
    if self.ex is not None:
20528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20529 
      self.ex.write(oprot)
20530 
      oprot.writeFieldEnd()
20531 
    oprot.writeFieldStop()
20532 
    oprot.writeStructEnd()
20533 
 
20534 
  def validate(self):
20535 
    return
20536 
 
20537 
 
20538 
  def __repr__(self):
20539 
    L = ['%s=%r' % (key, value)
20540 
      for key, value in self.__dict__.iteritems()]
20541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20542 
 
20543 
  def __eq__(self, other):
20544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20545 
 
20546 
  def __ne__(self, other):
20547 
    return not (self == other)
4259 anupam.sin 20548 
 
20549 
class refundTransaction_args:
20550 
  """
20551 
  Attributes:
20552 
   - transactionId
20553 
   - refundedBy
20554 
   - reason
20555 
  """
20556 
 
20557 
  thrift_spec = (
20558 
    None, # 0
20559 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20560 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20561 
    (3, TType.STRING, 'reason', None, None, ), # 3
20562 
  )
20563 
 
20564 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20565 
    self.transactionId = transactionId
20566 
    self.refundedBy = refundedBy
20567 
    self.reason = reason
20568 
 
20569 
  def read(self, iprot):
20570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20572 
      return
20573 
    iprot.readStructBegin()
20574 
    while True:
20575 
      (fname, ftype, fid) = iprot.readFieldBegin()
20576 
      if ftype == TType.STOP:
20577 
        break
20578 
      if fid == 1:
20579 
        if ftype == TType.I64:
20580 
          self.transactionId = iprot.readI64();
20581 
        else:
20582 
          iprot.skip(ftype)
20583 
      elif fid == 2:
20584 
        if ftype == TType.STRING:
20585 
          self.refundedBy = iprot.readString();
20586 
        else:
20587 
          iprot.skip(ftype)
20588 
      elif fid == 3:
20589 
        if ftype == TType.STRING:
20590 
          self.reason = iprot.readString();
20591 
        else:
20592 
          iprot.skip(ftype)
20593 
      else:
20594 
        iprot.skip(ftype)
20595 
      iprot.readFieldEnd()
20596 
    iprot.readStructEnd()
20597 
 
20598 
  def write(self, oprot):
20599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20601 
      return
20602 
    oprot.writeStructBegin('refundTransaction_args')
20603 
    if self.transactionId is not None:
20604 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20605 
      oprot.writeI64(self.transactionId)
20606 
      oprot.writeFieldEnd()
20607 
    if self.refundedBy is not None:
20608 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20609 
      oprot.writeString(self.refundedBy)
20610 
      oprot.writeFieldEnd()
20611 
    if self.reason is not None:
20612 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20613 
      oprot.writeString(self.reason)
20614 
      oprot.writeFieldEnd()
20615 
    oprot.writeFieldStop()
20616 
    oprot.writeStructEnd()
20617 
 
20618 
  def validate(self):
20619 
    return
20620 
 
20621 
 
20622 
  def __repr__(self):
20623 
    L = ['%s=%r' % (key, value)
20624 
      for key, value in self.__dict__.iteritems()]
20625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20626 
 
20627 
  def __eq__(self, other):
20628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20629 
 
20630 
  def __ne__(self, other):
20631 
    return not (self == other)
20632 
 
20633 
class refundTransaction_result:
20634 
  """
20635 
  Attributes:
20636 
   - ex
20637 
  """
20638 
 
20639 
  thrift_spec = (
20640 
    None, # 0
20641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20642 
  )
20643 
 
20644 
  def __init__(self, ex=None,):
20645 
    self.ex = ex
20646 
 
20647 
  def read(self, iprot):
20648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20650 
      return
20651 
    iprot.readStructBegin()
20652 
    while True:
20653 
      (fname, ftype, fid) = iprot.readFieldBegin()
20654 
      if ftype == TType.STOP:
20655 
        break
20656 
      if fid == 1:
20657 
        if ftype == TType.STRUCT:
20658 
          self.ex = TransactionServiceException()
20659 
          self.ex.read(iprot)
20660 
        else:
20661 
          iprot.skip(ftype)
20662 
      else:
20663 
        iprot.skip(ftype)
20664 
      iprot.readFieldEnd()
20665 
    iprot.readStructEnd()
20666 
 
20667 
  def write(self, oprot):
20668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20670 
      return
20671 
    oprot.writeStructBegin('refundTransaction_result')
20672 
    if self.ex is not None:
20673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20674 
      self.ex.write(oprot)
20675 
      oprot.writeFieldEnd()
20676 
    oprot.writeFieldStop()
20677 
    oprot.writeStructEnd()
20678 
 
20679 
  def validate(self):
20680 
    return
20681 
 
20682 
 
20683 
  def __repr__(self):
20684 
    L = ['%s=%r' % (key, value)
20685 
      for key, value in self.__dict__.iteritems()]
20686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20687 
 
20688 
  def __eq__(self, other):
20689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20690 
 
20691 
  def __ne__(self, other):
20692 
    return not (self == other)
4285 rajveer 20693 
 
4324 mandeep.dh 20694 
class updateShipmentAddress_args:
20695 
  """
20696 
  Attributes:
20697 
   - orderId
20698 
   - addressId
20699 
  """
20700 
 
20701 
  thrift_spec = (
20702 
    None, # 0
20703 
    (1, TType.I64, 'orderId', None, None, ), # 1
20704 
    (2, TType.I64, 'addressId', None, None, ), # 2
20705 
  )
20706 
 
20707 
  def __init__(self, orderId=None, addressId=None,):
20708 
    self.orderId = orderId
20709 
    self.addressId = addressId
20710 
 
20711 
  def read(self, iprot):
20712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20714 
      return
20715 
    iprot.readStructBegin()
20716 
    while True:
20717 
      (fname, ftype, fid) = iprot.readFieldBegin()
20718 
      if ftype == TType.STOP:
20719 
        break
20720 
      if fid == 1:
20721 
        if ftype == TType.I64:
20722 
          self.orderId = iprot.readI64();
20723 
        else:
20724 
          iprot.skip(ftype)
20725 
      elif fid == 2:
20726 
        if ftype == TType.I64:
20727 
          self.addressId = iprot.readI64();
20728 
        else:
20729 
          iprot.skip(ftype)
20730 
      else:
20731 
        iprot.skip(ftype)
20732 
      iprot.readFieldEnd()
20733 
    iprot.readStructEnd()
20734 
 
20735 
  def write(self, oprot):
20736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20738 
      return
20739 
    oprot.writeStructBegin('updateShipmentAddress_args')
20740 
    if self.orderId is not None:
20741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20742 
      oprot.writeI64(self.orderId)
20743 
      oprot.writeFieldEnd()
20744 
    if self.addressId is not None:
20745 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20746 
      oprot.writeI64(self.addressId)
20747 
      oprot.writeFieldEnd()
20748 
    oprot.writeFieldStop()
20749 
    oprot.writeStructEnd()
20750 
 
20751 
  def validate(self):
20752 
    return
20753 
 
20754 
 
20755 
  def __repr__(self):
20756 
    L = ['%s=%r' % (key, value)
20757 
      for key, value in self.__dict__.iteritems()]
20758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20759 
 
20760 
  def __eq__(self, other):
20761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20762 
 
20763 
  def __ne__(self, other):
20764 
    return not (self == other)
20765 
 
20766 
class updateShipmentAddress_result:
20767 
  """
20768 
  Attributes:
20769 
   - ex
20770 
  """
20771 
 
20772 
  thrift_spec = (
20773 
    None, # 0
20774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20775 
  )
20776 
 
20777 
  def __init__(self, ex=None,):
20778 
    self.ex = ex
20779 
 
20780 
  def read(self, iprot):
20781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20783 
      return
20784 
    iprot.readStructBegin()
20785 
    while True:
20786 
      (fname, ftype, fid) = iprot.readFieldBegin()
20787 
      if ftype == TType.STOP:
20788 
        break
20789 
      if fid == 1:
20790 
        if ftype == TType.STRUCT:
20791 
          self.ex = TransactionServiceException()
20792 
          self.ex.read(iprot)
20793 
        else:
20794 
          iprot.skip(ftype)
20795 
      else:
20796 
        iprot.skip(ftype)
20797 
      iprot.readFieldEnd()
20798 
    iprot.readStructEnd()
20799 
 
20800 
  def write(self, oprot):
20801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20803 
      return
20804 
    oprot.writeStructBegin('updateShipmentAddress_result')
20805 
    if self.ex is not None:
20806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20807 
      self.ex.write(oprot)
20808 
      oprot.writeFieldEnd()
20809 
    oprot.writeFieldStop()
20810 
    oprot.writeStructEnd()
20811 
 
20812 
  def validate(self):
20813 
    return
20814 
 
20815 
 
20816 
  def __repr__(self):
20817 
    L = ['%s=%r' % (key, value)
20818 
      for key, value in self.__dict__.iteritems()]
20819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20820 
 
20821 
  def __eq__(self, other):
20822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20823 
 
20824 
  def __ne__(self, other):
20825 
    return not (self == other)
20826 
 
4285 rajveer 20827 
class acceptOrdersForItemId_args:
20828 
  """
20829 
  Attributes:
20830 
   - itemId
20831 
   - inventory
20832 
  """
20833 
 
20834 
  thrift_spec = (
20835 
    None, # 0
20836 
    (1, TType.I64, 'itemId', None, None, ), # 1
20837 
    (2, TType.I64, 'inventory', None, None, ), # 2
20838 
  )
20839 
 
20840 
  def __init__(self, itemId=None, inventory=None,):
20841 
    self.itemId = itemId
20842 
    self.inventory = inventory
20843 
 
20844 
  def read(self, iprot):
20845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20847 
      return
20848 
    iprot.readStructBegin()
20849 
    while True:
20850 
      (fname, ftype, fid) = iprot.readFieldBegin()
20851 
      if ftype == TType.STOP:
20852 
        break
20853 
      if fid == 1:
20854 
        if ftype == TType.I64:
20855 
          self.itemId = iprot.readI64();
20856 
        else:
20857 
          iprot.skip(ftype)
20858 
      elif fid == 2:
20859 
        if ftype == TType.I64:
20860 
          self.inventory = iprot.readI64();
20861 
        else:
20862 
          iprot.skip(ftype)
20863 
      else:
20864 
        iprot.skip(ftype)
20865 
      iprot.readFieldEnd()
20866 
    iprot.readStructEnd()
20867 
 
20868 
  def write(self, oprot):
20869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20871 
      return
20872 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20873 
    if self.itemId is not None:
20874 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20875 
      oprot.writeI64(self.itemId)
20876 
      oprot.writeFieldEnd()
20877 
    if self.inventory is not None:
20878 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20879 
      oprot.writeI64(self.inventory)
20880 
      oprot.writeFieldEnd()
20881 
    oprot.writeFieldStop()
20882 
    oprot.writeStructEnd()
20883 
 
20884 
  def validate(self):
20885 
    return
20886 
 
20887 
 
20888 
  def __repr__(self):
20889 
    L = ['%s=%r' % (key, value)
20890 
      for key, value in self.__dict__.iteritems()]
20891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20892 
 
20893 
  def __eq__(self, other):
20894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20895 
 
20896 
  def __ne__(self, other):
20897 
    return not (self == other)
20898 
 
20899 
class acceptOrdersForItemId_result:
20900 
  """
20901 
  Attributes:
20902 
   - success
20903 
   - ex
20904 
  """
20905 
 
20906 
  thrift_spec = (
20907 
    (0, TType.BOOL, 'success', None, None, ), # 0
20908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20909 
  )
20910 
 
20911 
  def __init__(self, success=None, ex=None,):
20912 
    self.success = success
20913 
    self.ex = ex
20914 
 
20915 
  def read(self, iprot):
20916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20918 
      return
20919 
    iprot.readStructBegin()
20920 
    while True:
20921 
      (fname, ftype, fid) = iprot.readFieldBegin()
20922 
      if ftype == TType.STOP:
20923 
        break
20924 
      if fid == 0:
20925 
        if ftype == TType.BOOL:
20926 
          self.success = iprot.readBool();
20927 
        else:
20928 
          iprot.skip(ftype)
20929 
      elif fid == 1:
20930 
        if ftype == TType.STRUCT:
20931 
          self.ex = TransactionServiceException()
20932 
          self.ex.read(iprot)
20933 
        else:
20934 
          iprot.skip(ftype)
20935 
      else:
20936 
        iprot.skip(ftype)
20937 
      iprot.readFieldEnd()
20938 
    iprot.readStructEnd()
20939 
 
20940 
  def write(self, oprot):
20941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20943 
      return
20944 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20945 
    if self.success is not None:
20946 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20947 
      oprot.writeBool(self.success)
20948 
      oprot.writeFieldEnd()
20949 
    if self.ex is not None:
20950 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20951 
      self.ex.write(oprot)
20952 
      oprot.writeFieldEnd()
20953 
    oprot.writeFieldStop()
20954 
    oprot.writeStructEnd()
20955 
 
20956 
  def validate(self):
20957 
    return
20958 
 
20959 
 
20960 
  def __repr__(self):
20961 
    L = ['%s=%r' % (key, value)
20962 
      for key, value in self.__dict__.iteritems()]
20963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20964 
 
20965 
  def __eq__(self, other):
20966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20967 
 
20968 
  def __ne__(self, other):
20969 
    return not (self == other)
4303 rajveer 20970 
 
20971 
class markOrdersAsPORaised_args:
20972 
  """
20973 
  Attributes:
20974 
   - vendorId
20975 
   - itemId
20976 
   - quantity
20977 
   - estimate
4369 rajveer 20978 
   - isReminder
4303 rajveer 20979 
  """
20980 
 
20981 
  thrift_spec = (
20982 
    None, # 0
20983 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20984 
    (2, TType.I64, 'itemId', None, None, ), # 2
20985 
    (3, TType.I64, 'quantity', None, None, ), # 3
20986 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20987 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20988 
  )
20989 
 
4369 rajveer 20990 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20991 
    self.vendorId = vendorId
20992 
    self.itemId = itemId
20993 
    self.quantity = quantity
20994 
    self.estimate = estimate
4369 rajveer 20995 
    self.isReminder = isReminder
4303 rajveer 20996 
 
20997 
  def read(self, iprot):
20998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21000 
      return
21001 
    iprot.readStructBegin()
21002 
    while True:
21003 
      (fname, ftype, fid) = iprot.readFieldBegin()
21004 
      if ftype == TType.STOP:
21005 
        break
21006 
      if fid == 1:
21007 
        if ftype == TType.I64:
21008 
          self.vendorId = iprot.readI64();
21009 
        else:
21010 
          iprot.skip(ftype)
21011 
      elif fid == 2:
21012 
        if ftype == TType.I64:
21013 
          self.itemId = iprot.readI64();
21014 
        else:
21015 
          iprot.skip(ftype)
21016 
      elif fid == 3:
21017 
        if ftype == TType.I64:
21018 
          self.quantity = iprot.readI64();
21019 
        else:
21020 
          iprot.skip(ftype)
21021 
      elif fid == 4:
21022 
        if ftype == TType.I64:
21023 
          self.estimate = iprot.readI64();
21024 
        else:
21025 
          iprot.skip(ftype)
4369 rajveer 21026 
      elif fid == 5:
21027 
        if ftype == TType.BOOL:
21028 
          self.isReminder = iprot.readBool();
21029 
        else:
21030 
          iprot.skip(ftype)
4303 rajveer 21031 
      else:
21032 
        iprot.skip(ftype)
21033 
      iprot.readFieldEnd()
21034 
    iprot.readStructEnd()
21035 
 
21036 
  def write(self, oprot):
21037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21039 
      return
21040 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21041 
    if self.vendorId is not None:
21042 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21043 
      oprot.writeI64(self.vendorId)
21044 
      oprot.writeFieldEnd()
21045 
    if self.itemId is not None:
21046 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21047 
      oprot.writeI64(self.itemId)
21048 
      oprot.writeFieldEnd()
21049 
    if self.quantity is not None:
21050 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21051 
      oprot.writeI64(self.quantity)
21052 
      oprot.writeFieldEnd()
21053 
    if self.estimate is not None:
21054 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21055 
      oprot.writeI64(self.estimate)
21056 
      oprot.writeFieldEnd()
4369 rajveer 21057 
    if self.isReminder is not None:
21058 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21059 
      oprot.writeBool(self.isReminder)
21060 
      oprot.writeFieldEnd()
4303 rajveer 21061 
    oprot.writeFieldStop()
21062 
    oprot.writeStructEnd()
21063 
 
21064 
  def validate(self):
21065 
    return
21066 
 
21067 
 
21068 
  def __repr__(self):
21069 
    L = ['%s=%r' % (key, value)
21070 
      for key, value in self.__dict__.iteritems()]
21071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21072 
 
21073 
  def __eq__(self, other):
21074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21075 
 
21076 
  def __ne__(self, other):
21077 
    return not (self == other)
21078 
 
21079 
class markOrdersAsPORaised_result:
21080 
  """
21081 
  Attributes:
21082 
   - ex
21083 
  """
21084 
 
21085 
  thrift_spec = (
21086 
    None, # 0
21087 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21088 
  )
21089 
 
21090 
  def __init__(self, ex=None,):
21091 
    self.ex = ex
21092 
 
21093 
  def read(self, iprot):
21094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21096 
      return
21097 
    iprot.readStructBegin()
21098 
    while True:
21099 
      (fname, ftype, fid) = iprot.readFieldBegin()
21100 
      if ftype == TType.STOP:
21101 
        break
21102 
      if fid == 1:
21103 
        if ftype == TType.STRUCT:
21104 
          self.ex = TransactionServiceException()
21105 
          self.ex.read(iprot)
21106 
        else:
21107 
          iprot.skip(ftype)
21108 
      else:
21109 
        iprot.skip(ftype)
21110 
      iprot.readFieldEnd()
21111 
    iprot.readStructEnd()
21112 
 
21113 
  def write(self, oprot):
21114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21116 
      return
21117 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21118 
    if self.ex is not None:
21119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21120 
      self.ex.write(oprot)
21121 
      oprot.writeFieldEnd()
21122 
    oprot.writeFieldStop()
21123 
    oprot.writeStructEnd()
21124 
 
21125 
  def validate(self):
21126 
    return
21127 
 
21128 
 
21129 
  def __repr__(self):
21130 
    L = ['%s=%r' % (key, value)
21131 
      for key, value in self.__dict__.iteritems()]
21132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21133 
 
21134 
  def __eq__(self, other):
21135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21136 
 
21137 
  def __ne__(self, other):
21138 
    return not (self == other)
21139 
 
21140 
class markOrdersAsReversalInitiated_args:
21141 
  """
21142 
  Attributes:
21143 
   - vendorId
21144 
   - itemId
21145 
   - quantity
21146 
   - estimate
4369 rajveer 21147 
   - isReminder
4303 rajveer 21148 
  """
21149 
 
21150 
  thrift_spec = (
21151 
    None, # 0
21152 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21153 
    (2, TType.I64, 'itemId', None, None, ), # 2
21154 
    (3, TType.I64, 'quantity', None, None, ), # 3
21155 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21156 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21157 
  )
21158 
 
4369 rajveer 21159 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21160 
    self.vendorId = vendorId
21161 
    self.itemId = itemId
21162 
    self.quantity = quantity
21163 
    self.estimate = estimate
4369 rajveer 21164 
    self.isReminder = isReminder
4303 rajveer 21165 
 
21166 
  def read(self, iprot):
21167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21169 
      return
21170 
    iprot.readStructBegin()
21171 
    while True:
21172 
      (fname, ftype, fid) = iprot.readFieldBegin()
21173 
      if ftype == TType.STOP:
21174 
        break
21175 
      if fid == 1:
21176 
        if ftype == TType.I64:
21177 
          self.vendorId = iprot.readI64();
21178 
        else:
21179 
          iprot.skip(ftype)
21180 
      elif fid == 2:
21181 
        if ftype == TType.I64:
21182 
          self.itemId = iprot.readI64();
21183 
        else:
21184 
          iprot.skip(ftype)
21185 
      elif fid == 3:
21186 
        if ftype == TType.I64:
21187 
          self.quantity = iprot.readI64();
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      elif fid == 4:
21191 
        if ftype == TType.I64:
21192 
          self.estimate = iprot.readI64();
21193 
        else:
21194 
          iprot.skip(ftype)
4369 rajveer 21195 
      elif fid == 5:
21196 
        if ftype == TType.BOOL:
21197 
          self.isReminder = iprot.readBool();
21198 
        else:
21199 
          iprot.skip(ftype)
4303 rajveer 21200 
      else:
21201 
        iprot.skip(ftype)
21202 
      iprot.readFieldEnd()
21203 
    iprot.readStructEnd()
21204 
 
21205 
  def write(self, oprot):
21206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21208 
      return
21209 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21210 
    if self.vendorId is not None:
21211 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21212 
      oprot.writeI64(self.vendorId)
21213 
      oprot.writeFieldEnd()
21214 
    if self.itemId is not None:
21215 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21216 
      oprot.writeI64(self.itemId)
21217 
      oprot.writeFieldEnd()
21218 
    if self.quantity is not None:
21219 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21220 
      oprot.writeI64(self.quantity)
21221 
      oprot.writeFieldEnd()
21222 
    if self.estimate is not None:
21223 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21224 
      oprot.writeI64(self.estimate)
21225 
      oprot.writeFieldEnd()
4369 rajveer 21226 
    if self.isReminder is not None:
21227 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21228 
      oprot.writeBool(self.isReminder)
21229 
      oprot.writeFieldEnd()
4303 rajveer 21230 
    oprot.writeFieldStop()
21231 
    oprot.writeStructEnd()
21232 
 
21233 
  def validate(self):
21234 
    return
21235 
 
21236 
 
21237 
  def __repr__(self):
21238 
    L = ['%s=%r' % (key, value)
21239 
      for key, value in self.__dict__.iteritems()]
21240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21241 
 
21242 
  def __eq__(self, other):
21243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21244 
 
21245 
  def __ne__(self, other):
21246 
    return not (self == other)
21247 
 
21248 
class markOrdersAsReversalInitiated_result:
21249 
  """
21250 
  Attributes:
21251 
   - ex
21252 
  """
21253 
 
21254 
  thrift_spec = (
21255 
    None, # 0
21256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21257 
  )
21258 
 
21259 
  def __init__(self, ex=None,):
21260 
    self.ex = ex
21261 
 
21262 
  def read(self, iprot):
21263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21265 
      return
21266 
    iprot.readStructBegin()
21267 
    while True:
21268 
      (fname, ftype, fid) = iprot.readFieldBegin()
21269 
      if ftype == TType.STOP:
21270 
        break
21271 
      if fid == 1:
21272 
        if ftype == TType.STRUCT:
21273 
          self.ex = TransactionServiceException()
21274 
          self.ex.read(iprot)
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      else:
21278 
        iprot.skip(ftype)
21279 
      iprot.readFieldEnd()
21280 
    iprot.readStructEnd()
21281 
 
21282 
  def write(self, oprot):
21283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21285 
      return
21286 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21287 
    if self.ex is not None:
21288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21289 
      self.ex.write(oprot)
21290 
      oprot.writeFieldEnd()
21291 
    oprot.writeFieldStop()
21292 
    oprot.writeStructEnd()
21293 
 
21294 
  def validate(self):
21295 
    return
21296 
 
21297 
 
21298 
  def __repr__(self):
21299 
    L = ['%s=%r' % (key, value)
21300 
      for key, value in self.__dict__.iteritems()]
21301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21302 
 
21303 
  def __eq__(self, other):
21304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21305 
 
21306 
  def __ne__(self, other):
21307 
    return not (self == other)
21308 
 
21309 
class markOrdersAsNotAvailabke_args:
21310 
  """
21311 
  Attributes:
21312 
   - vendorId
21313 
   - itemId
21314 
   - quantity
21315 
   - estimate
4369 rajveer 21316 
   - isReminder
4303 rajveer 21317 
  """
21318 
 
21319 
  thrift_spec = (
21320 
    None, # 0
21321 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21322 
    (2, TType.I64, 'itemId', None, None, ), # 2
21323 
    (3, TType.I64, 'quantity', None, None, ), # 3
21324 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21325 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21326 
  )
21327 
 
4369 rajveer 21328 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21329 
    self.vendorId = vendorId
21330 
    self.itemId = itemId
21331 
    self.quantity = quantity
21332 
    self.estimate = estimate
4369 rajveer 21333 
    self.isReminder = isReminder
4303 rajveer 21334 
 
21335 
  def read(self, iprot):
21336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21338 
      return
21339 
    iprot.readStructBegin()
21340 
    while True:
21341 
      (fname, ftype, fid) = iprot.readFieldBegin()
21342 
      if ftype == TType.STOP:
21343 
        break
21344 
      if fid == 1:
21345 
        if ftype == TType.I64:
21346 
          self.vendorId = iprot.readI64();
21347 
        else:
21348 
          iprot.skip(ftype)
21349 
      elif fid == 2:
21350 
        if ftype == TType.I64:
21351 
          self.itemId = iprot.readI64();
21352 
        else:
21353 
          iprot.skip(ftype)
21354 
      elif fid == 3:
21355 
        if ftype == TType.I64:
21356 
          self.quantity = iprot.readI64();
21357 
        else:
21358 
          iprot.skip(ftype)
21359 
      elif fid == 4:
21360 
        if ftype == TType.I64:
21361 
          self.estimate = iprot.readI64();
21362 
        else:
21363 
          iprot.skip(ftype)
4369 rajveer 21364 
      elif fid == 5:
21365 
        if ftype == TType.BOOL:
21366 
          self.isReminder = iprot.readBool();
21367 
        else:
21368 
          iprot.skip(ftype)
4303 rajveer 21369 
      else:
21370 
        iprot.skip(ftype)
21371 
      iprot.readFieldEnd()
21372 
    iprot.readStructEnd()
21373 
 
21374 
  def write(self, oprot):
21375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21377 
      return
21378 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21379 
    if self.vendorId is not None:
21380 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21381 
      oprot.writeI64(self.vendorId)
21382 
      oprot.writeFieldEnd()
21383 
    if self.itemId is not None:
21384 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21385 
      oprot.writeI64(self.itemId)
21386 
      oprot.writeFieldEnd()
21387 
    if self.quantity is not None:
21388 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21389 
      oprot.writeI64(self.quantity)
21390 
      oprot.writeFieldEnd()
21391 
    if self.estimate is not None:
21392 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21393 
      oprot.writeI64(self.estimate)
21394 
      oprot.writeFieldEnd()
4369 rajveer 21395 
    if self.isReminder is not None:
21396 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21397 
      oprot.writeBool(self.isReminder)
21398 
      oprot.writeFieldEnd()
4303 rajveer 21399 
    oprot.writeFieldStop()
21400 
    oprot.writeStructEnd()
21401 
 
21402 
  def validate(self):
21403 
    return
21404 
 
21405 
 
21406 
  def __repr__(self):
21407 
    L = ['%s=%r' % (key, value)
21408 
      for key, value in self.__dict__.iteritems()]
21409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21410 
 
21411 
  def __eq__(self, other):
21412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21413 
 
21414 
  def __ne__(self, other):
21415 
    return not (self == other)
21416 
 
21417 
class markOrdersAsNotAvailabke_result:
21418 
  """
21419 
  Attributes:
21420 
   - ex
21421 
  """
21422 
 
21423 
  thrift_spec = (
21424 
    None, # 0
21425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21426 
  )
21427 
 
21428 
  def __init__(self, ex=None,):
21429 
    self.ex = ex
21430 
 
21431 
  def read(self, iprot):
21432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21434 
      return
21435 
    iprot.readStructBegin()
21436 
    while True:
21437 
      (fname, ftype, fid) = iprot.readFieldBegin()
21438 
      if ftype == TType.STOP:
21439 
        break
21440 
      if fid == 1:
21441 
        if ftype == TType.STRUCT:
21442 
          self.ex = TransactionServiceException()
21443 
          self.ex.read(iprot)
21444 
        else:
21445 
          iprot.skip(ftype)
21446 
      else:
21447 
        iprot.skip(ftype)
21448 
      iprot.readFieldEnd()
21449 
    iprot.readStructEnd()
21450 
 
21451 
  def write(self, oprot):
21452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21454 
      return
21455 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21456 
    if self.ex is not None:
21457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21458 
      self.ex.write(oprot)
21459 
      oprot.writeFieldEnd()
21460 
    oprot.writeFieldStop()
21461 
    oprot.writeStructEnd()
21462 
 
21463 
  def validate(self):
21464 
    return
21465 
 
21466 
 
21467 
  def __repr__(self):
21468 
    L = ['%s=%r' % (key, value)
21469 
      for key, value in self.__dict__.iteritems()]
21470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21471 
 
21472 
  def __eq__(self, other):
21473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21474 
 
21475 
  def __ne__(self, other):
21476 
    return not (self == other)
4369 rajveer 21477 
 
21478 
class markOrdersAsTimeout_args:
21479 
  """
21480 
  Attributes:
21481 
   - vendorId
21482 
  """
21483 
 
21484 
  thrift_spec = (
21485 
    None, # 0
21486 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21487 
  )
21488 
 
21489 
  def __init__(self, vendorId=None,):
21490 
    self.vendorId = vendorId
21491 
 
21492 
  def read(self, iprot):
21493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21495 
      return
21496 
    iprot.readStructBegin()
21497 
    while True:
21498 
      (fname, ftype, fid) = iprot.readFieldBegin()
21499 
      if ftype == TType.STOP:
21500 
        break
21501 
      if fid == 1:
21502 
        if ftype == TType.I64:
21503 
          self.vendorId = iprot.readI64();
21504 
        else:
21505 
          iprot.skip(ftype)
21506 
      else:
21507 
        iprot.skip(ftype)
21508 
      iprot.readFieldEnd()
21509 
    iprot.readStructEnd()
21510 
 
21511 
  def write(self, oprot):
21512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21514 
      return
21515 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21516 
    if self.vendorId is not None:
21517 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21518 
      oprot.writeI64(self.vendorId)
21519 
      oprot.writeFieldEnd()
21520 
    oprot.writeFieldStop()
21521 
    oprot.writeStructEnd()
21522 
 
21523 
  def validate(self):
21524 
    return
21525 
 
21526 
 
21527 
  def __repr__(self):
21528 
    L = ['%s=%r' % (key, value)
21529 
      for key, value in self.__dict__.iteritems()]
21530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21531 
 
21532 
  def __eq__(self, other):
21533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21534 
 
21535 
  def __ne__(self, other):
21536 
    return not (self == other)
21537 
 
21538 
class markOrdersAsTimeout_result:
21539 
  """
21540 
  Attributes:
21541 
   - success
21542 
   - ex
21543 
  """
21544 
 
21545 
  thrift_spec = (
21546 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21548 
  )
21549 
 
21550 
  def __init__(self, success=None, ex=None,):
21551 
    self.success = success
21552 
    self.ex = ex
21553 
 
21554 
  def read(self, iprot):
21555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21557 
      return
21558 
    iprot.readStructBegin()
21559 
    while True:
21560 
      (fname, ftype, fid) = iprot.readFieldBegin()
21561 
      if ftype == TType.STOP:
21562 
        break
21563 
      if fid == 0:
21564 
        if ftype == TType.MAP:
21565 
          self.success = {}
6188 rajveer 21566 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21567 
          for _i505 in xrange(_size501):
21568 
            _key506 = iprot.readI32();
21569 
            _val507 = TimeoutSummary()
21570 
            _val507.read(iprot)
21571 
            self.success[_key506] = _val507
4369 rajveer 21572 
          iprot.readMapEnd()
21573 
        else:
21574 
          iprot.skip(ftype)
21575 
      elif fid == 1:
21576 
        if ftype == TType.STRUCT:
21577 
          self.ex = TransactionServiceException()
21578 
          self.ex.read(iprot)
21579 
        else:
21580 
          iprot.skip(ftype)
21581 
      else:
21582 
        iprot.skip(ftype)
21583 
      iprot.readFieldEnd()
21584 
    iprot.readStructEnd()
21585 
 
21586 
  def write(self, oprot):
21587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21589 
      return
21590 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21591 
    if self.success is not None:
21592 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21593 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21594 
      for kiter508,viter509 in self.success.items():
21595 
        oprot.writeI32(kiter508)
21596 
        viter509.write(oprot)
4369 rajveer 21597 
      oprot.writeMapEnd()
21598 
      oprot.writeFieldEnd()
21599 
    if self.ex is not None:
21600 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21601 
      self.ex.write(oprot)
21602 
      oprot.writeFieldEnd()
21603 
    oprot.writeFieldStop()
21604 
    oprot.writeStructEnd()
21605 
 
21606 
  def validate(self):
21607 
    return
21608 
 
21609 
 
21610 
  def __repr__(self):
21611 
    L = ['%s=%r' % (key, value)
21612 
      for key, value in self.__dict__.iteritems()]
21613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21614 
 
21615 
  def __eq__(self, other):
21616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21617 
 
21618 
  def __ne__(self, other):
21619 
    return not (self == other)
4386 anupam.sin 21620 
 
4662 rajveer 21621 
class markOrderAsLostInTransit_args:
21622 
  """
21623 
  Attributes:
21624 
   - orderId
21625 
  """
21626 
 
21627 
  thrift_spec = (
21628 
    None, # 0
21629 
    (1, TType.I64, 'orderId', None, None, ), # 1
21630 
  )
21631 
 
21632 
  def __init__(self, orderId=None,):
21633 
    self.orderId = orderId
21634 
 
21635 
  def read(self, iprot):
21636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21638 
      return
21639 
    iprot.readStructBegin()
21640 
    while True:
21641 
      (fname, ftype, fid) = iprot.readFieldBegin()
21642 
      if ftype == TType.STOP:
21643 
        break
21644 
      if fid == 1:
21645 
        if ftype == TType.I64:
21646 
          self.orderId = iprot.readI64();
21647 
        else:
21648 
          iprot.skip(ftype)
21649 
      else:
21650 
        iprot.skip(ftype)
21651 
      iprot.readFieldEnd()
21652 
    iprot.readStructEnd()
21653 
 
21654 
  def write(self, oprot):
21655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21657 
      return
21658 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21659 
    if self.orderId is not None:
21660 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21661 
      oprot.writeI64(self.orderId)
21662 
      oprot.writeFieldEnd()
21663 
    oprot.writeFieldStop()
21664 
    oprot.writeStructEnd()
21665 
 
21666 
  def validate(self):
21667 
    return
21668 
 
21669 
 
21670 
  def __repr__(self):
21671 
    L = ['%s=%r' % (key, value)
21672 
      for key, value in self.__dict__.iteritems()]
21673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21674 
 
21675 
  def __eq__(self, other):
21676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21677 
 
21678 
  def __ne__(self, other):
21679 
    return not (self == other)
21680 
 
21681 
class markOrderAsLostInTransit_result:
21682 
  """
21683 
  Attributes:
21684 
   - success
21685 
   - ex
21686 
  """
21687 
 
21688 
  thrift_spec = (
21689 
    (0, TType.BOOL, 'success', None, None, ), # 0
21690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21691 
  )
21692 
 
21693 
  def __init__(self, success=None, ex=None,):
21694 
    self.success = success
21695 
    self.ex = ex
21696 
 
21697 
  def read(self, iprot):
21698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21700 
      return
21701 
    iprot.readStructBegin()
21702 
    while True:
21703 
      (fname, ftype, fid) = iprot.readFieldBegin()
21704 
      if ftype == TType.STOP:
21705 
        break
21706 
      if fid == 0:
21707 
        if ftype == TType.BOOL:
21708 
          self.success = iprot.readBool();
21709 
        else:
21710 
          iprot.skip(ftype)
21711 
      elif fid == 1:
21712 
        if ftype == TType.STRUCT:
21713 
          self.ex = TransactionServiceException()
21714 
          self.ex.read(iprot)
21715 
        else:
21716 
          iprot.skip(ftype)
21717 
      else:
21718 
        iprot.skip(ftype)
21719 
      iprot.readFieldEnd()
21720 
    iprot.readStructEnd()
21721 
 
21722 
  def write(self, oprot):
21723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21725 
      return
21726 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21727 
    if self.success is not None:
21728 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21729 
      oprot.writeBool(self.success)
21730 
      oprot.writeFieldEnd()
21731 
    if self.ex is not None:
21732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21733 
      self.ex.write(oprot)
21734 
      oprot.writeFieldEnd()
21735 
    oprot.writeFieldStop()
21736 
    oprot.writeStructEnd()
21737 
 
21738 
  def validate(self):
21739 
    return
21740 
 
21741 
 
21742 
  def __repr__(self):
21743 
    L = ['%s=%r' % (key, value)
21744 
      for key, value in self.__dict__.iteritems()]
21745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21746 
 
21747 
  def __eq__(self, other):
21748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21749 
 
21750 
  def __ne__(self, other):
21751 
    return not (self == other)
21752 
 
4386 anupam.sin 21753 
class getOrderForAwb_args:
21754 
  """
21755 
  Attributes:
21756 
   - awb
21757 
  """
21758 
 
21759 
  thrift_spec = (
21760 
    None, # 0
21761 
    (1, TType.STRING, 'awb', None, None, ), # 1
21762 
  )
21763 
 
21764 
  def __init__(self, awb=None,):
21765 
    self.awb = awb
21766 
 
21767 
  def read(self, iprot):
21768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21770 
      return
21771 
    iprot.readStructBegin()
21772 
    while True:
21773 
      (fname, ftype, fid) = iprot.readFieldBegin()
21774 
      if ftype == TType.STOP:
21775 
        break
21776 
      if fid == 1:
21777 
        if ftype == TType.STRING:
21778 
          self.awb = iprot.readString();
21779 
        else:
21780 
          iprot.skip(ftype)
21781 
      else:
21782 
        iprot.skip(ftype)
21783 
      iprot.readFieldEnd()
21784 
    iprot.readStructEnd()
21785 
 
21786 
  def write(self, oprot):
21787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21789 
      return
21790 
    oprot.writeStructBegin('getOrderForAwb_args')
21791 
    if self.awb is not None:
21792 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21793 
      oprot.writeString(self.awb)
21794 
      oprot.writeFieldEnd()
21795 
    oprot.writeFieldStop()
21796 
    oprot.writeStructEnd()
21797 
 
21798 
  def validate(self):
21799 
    return
21800 
 
21801 
 
21802 
  def __repr__(self):
21803 
    L = ['%s=%r' % (key, value)
21804 
      for key, value in self.__dict__.iteritems()]
21805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21806 
 
21807 
  def __eq__(self, other):
21808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21809 
 
21810 
  def __ne__(self, other):
21811 
    return not (self == other)
21812 
 
21813 
class getOrderForAwb_result:
21814 
  """
21815 
  Attributes:
21816 
   - success
21817 
   - ex
21818 
  """
21819 
 
21820 
  thrift_spec = (
21821 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21822 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21823 
  )
21824 
 
21825 
  def __init__(self, success=None, ex=None,):
21826 
    self.success = success
21827 
    self.ex = ex
21828 
 
21829 
  def read(self, iprot):
21830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21832 
      return
21833 
    iprot.readStructBegin()
21834 
    while True:
21835 
      (fname, ftype, fid) = iprot.readFieldBegin()
21836 
      if ftype == TType.STOP:
21837 
        break
21838 
      if fid == 0:
21839 
        if ftype == TType.STRUCT:
21840 
          self.success = Order()
21841 
          self.success.read(iprot)
21842 
        else:
21843 
          iprot.skip(ftype)
21844 
      elif fid == 1:
21845 
        if ftype == TType.STRUCT:
21846 
          self.ex = TransactionServiceException()
21847 
          self.ex.read(iprot)
21848 
        else:
21849 
          iprot.skip(ftype)
21850 
      else:
21851 
        iprot.skip(ftype)
21852 
      iprot.readFieldEnd()
21853 
    iprot.readStructEnd()
21854 
 
21855 
  def write(self, oprot):
21856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21858 
      return
21859 
    oprot.writeStructBegin('getOrderForAwb_result')
21860 
    if self.success is not None:
21861 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21862 
      self.success.write(oprot)
21863 
      oprot.writeFieldEnd()
21864 
    if self.ex is not None:
21865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21866 
      self.ex.write(oprot)
21867 
      oprot.writeFieldEnd()
21868 
    oprot.writeFieldStop()
21869 
    oprot.writeStructEnd()
21870 
 
21871 
  def validate(self):
21872 
    return
21873 
 
21874 
 
21875 
  def __repr__(self):
21876 
    L = ['%s=%r' % (key, value)
21877 
      for key, value in self.__dict__.iteritems()]
21878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21879 
 
21880 
  def __eq__(self, other):
21881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21882 
 
21883 
  def __ne__(self, other):
21884 
    return not (self == other)
4506 phani.kuma 21885 
 
21886 
class getOrdersForProviderForStatus_args:
21887 
  """
21888 
  Attributes:
21889 
   - logistics_provider_id
4910 phani.kuma 21890 
   - order_status_list
4506 phani.kuma 21891 
  """
21892 
 
21893 
  thrift_spec = (
21894 
    None, # 0
21895 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21896 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21897 
  )
21898 
 
4910 phani.kuma 21899 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21900 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21901 
    self.order_status_list = order_status_list
4506 phani.kuma 21902 
 
21903 
  def read(self, iprot):
21904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21906 
      return
21907 
    iprot.readStructBegin()
21908 
    while True:
21909 
      (fname, ftype, fid) = iprot.readFieldBegin()
21910 
      if ftype == TType.STOP:
21911 
        break
21912 
      if fid == 1:
21913 
        if ftype == TType.I64:
21914 
          self.logistics_provider_id = iprot.readI64();
21915 
        else:
21916 
          iprot.skip(ftype)
21917 
      elif fid == 2:
4910 phani.kuma 21918 
        if ftype == TType.LIST:
21919 
          self.order_status_list = []
6188 rajveer 21920 
          (_etype513, _size510) = iprot.readListBegin()
21921 
          for _i514 in xrange(_size510):
21922 
            _elem515 = iprot.readI32();
21923 
            self.order_status_list.append(_elem515)
4910 phani.kuma 21924 
          iprot.readListEnd()
4506 phani.kuma 21925 
        else:
21926 
          iprot.skip(ftype)
21927 
      else:
21928 
        iprot.skip(ftype)
21929 
      iprot.readFieldEnd()
21930 
    iprot.readStructEnd()
21931 
 
21932 
  def write(self, oprot):
21933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21935 
      return
21936 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21937 
    if self.logistics_provider_id is not None:
21938 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21939 
      oprot.writeI64(self.logistics_provider_id)
21940 
      oprot.writeFieldEnd()
4910 phani.kuma 21941 
    if self.order_status_list is not None:
21942 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21943 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 21944 
      for iter516 in self.order_status_list:
21945 
        oprot.writeI32(iter516)
4910 phani.kuma 21946 
      oprot.writeListEnd()
4506 phani.kuma 21947 
      oprot.writeFieldEnd()
21948 
    oprot.writeFieldStop()
21949 
    oprot.writeStructEnd()
21950 
 
21951 
  def validate(self):
21952 
    return
21953 
 
21954 
 
21955 
  def __repr__(self):
21956 
    L = ['%s=%r' % (key, value)
21957 
      for key, value in self.__dict__.iteritems()]
21958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21959 
 
21960 
  def __eq__(self, other):
21961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21962 
 
21963 
  def __ne__(self, other):
21964 
    return not (self == other)
21965 
 
21966 
class getOrdersForProviderForStatus_result:
21967 
  """
21968 
  Attributes:
21969 
   - success
21970 
   - ex
21971 
  """
21972 
 
21973 
  thrift_spec = (
21974 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21975 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21976 
  )
21977 
 
21978 
  def __init__(self, success=None, ex=None,):
21979 
    self.success = success
21980 
    self.ex = ex
21981 
 
21982 
  def read(self, iprot):
21983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21985 
      return
21986 
    iprot.readStructBegin()
21987 
    while True:
21988 
      (fname, ftype, fid) = iprot.readFieldBegin()
21989 
      if ftype == TType.STOP:
21990 
        break
21991 
      if fid == 0:
21992 
        if ftype == TType.LIST:
21993 
          self.success = []
6188 rajveer 21994 
          (_etype520, _size517) = iprot.readListBegin()
21995 
          for _i521 in xrange(_size517):
21996 
            _elem522 = Order()
21997 
            _elem522.read(iprot)
21998 
            self.success.append(_elem522)
4506 phani.kuma 21999 
          iprot.readListEnd()
22000 
        else:
22001 
          iprot.skip(ftype)
22002 
      elif fid == 1:
22003 
        if ftype == TType.STRUCT:
22004 
          self.ex = TransactionServiceException()
22005 
          self.ex.read(iprot)
22006 
        else:
22007 
          iprot.skip(ftype)
22008 
      else:
22009 
        iprot.skip(ftype)
22010 
      iprot.readFieldEnd()
22011 
    iprot.readStructEnd()
22012 
 
22013 
  def write(self, oprot):
22014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22016 
      return
22017 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22018 
    if self.success is not None:
22019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22021 
      for iter523 in self.success:
22022 
        iter523.write(oprot)
4506 phani.kuma 22023 
      oprot.writeListEnd()
22024 
      oprot.writeFieldEnd()
22025 
    if self.ex is not None:
22026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22027 
      self.ex.write(oprot)
22028 
      oprot.writeFieldEnd()
22029 
    oprot.writeFieldStop()
22030 
    oprot.writeStructEnd()
22031 
 
22032 
  def validate(self):
22033 
    return
22034 
 
22035 
 
22036 
  def __repr__(self):
22037 
    L = ['%s=%r' % (key, value)
22038 
      for key, value in self.__dict__.iteritems()]
22039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22040 
 
22041 
  def __eq__(self, other):
22042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22043 
 
22044 
  def __ne__(self, other):
22045 
    return not (self == other)
4600 varun.gupt 22046 
 
22047 
class getBilledOrdersForVendor_args:
22048 
  """
22049 
  Attributes:
22050 
   - vendorId
22051 
   - billingDateFrom
22052 
   - billingDateTo
22053 
  """
22054 
 
22055 
  thrift_spec = (
22056 
    None, # 0
22057 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22058 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22059 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22060 
  )
22061 
 
22062 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22063 
    self.vendorId = vendorId
22064 
    self.billingDateFrom = billingDateFrom
22065 
    self.billingDateTo = billingDateTo
22066 
 
22067 
  def read(self, iprot):
22068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22070 
      return
22071 
    iprot.readStructBegin()
22072 
    while True:
22073 
      (fname, ftype, fid) = iprot.readFieldBegin()
22074 
      if ftype == TType.STOP:
22075 
        break
22076 
      if fid == 1:
22077 
        if ftype == TType.I64:
22078 
          self.vendorId = iprot.readI64();
22079 
        else:
22080 
          iprot.skip(ftype)
22081 
      elif fid == 2:
22082 
        if ftype == TType.I64:
22083 
          self.billingDateFrom = iprot.readI64();
22084 
        else:
22085 
          iprot.skip(ftype)
22086 
      elif fid == 3:
22087 
        if ftype == TType.I64:
22088 
          self.billingDateTo = iprot.readI64();
22089 
        else:
22090 
          iprot.skip(ftype)
22091 
      else:
22092 
        iprot.skip(ftype)
22093 
      iprot.readFieldEnd()
22094 
    iprot.readStructEnd()
22095 
 
22096 
  def write(self, oprot):
22097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22099 
      return
22100 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22101 
    if self.vendorId is not None:
22102 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22103 
      oprot.writeI64(self.vendorId)
22104 
      oprot.writeFieldEnd()
22105 
    if self.billingDateFrom is not None:
22106 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22107 
      oprot.writeI64(self.billingDateFrom)
22108 
      oprot.writeFieldEnd()
22109 
    if self.billingDateTo is not None:
22110 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22111 
      oprot.writeI64(self.billingDateTo)
22112 
      oprot.writeFieldEnd()
22113 
    oprot.writeFieldStop()
22114 
    oprot.writeStructEnd()
22115 
 
22116 
  def validate(self):
22117 
    return
22118 
 
22119 
 
22120 
  def __repr__(self):
22121 
    L = ['%s=%r' % (key, value)
22122 
      for key, value in self.__dict__.iteritems()]
22123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22124 
 
22125 
  def __eq__(self, other):
22126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22127 
 
22128 
  def __ne__(self, other):
22129 
    return not (self == other)
22130 
 
22131 
class getBilledOrdersForVendor_result:
22132 
  """
22133 
  Attributes:
22134 
   - success
22135 
   - ex
22136 
  """
22137 
 
22138 
  thrift_spec = (
22139 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22141 
  )
22142 
 
22143 
  def __init__(self, success=None, ex=None,):
22144 
    self.success = success
22145 
    self.ex = ex
22146 
 
22147 
  def read(self, iprot):
22148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22150 
      return
22151 
    iprot.readStructBegin()
22152 
    while True:
22153 
      (fname, ftype, fid) = iprot.readFieldBegin()
22154 
      if ftype == TType.STOP:
22155 
        break
22156 
      if fid == 0:
22157 
        if ftype == TType.LIST:
22158 
          self.success = []
6188 rajveer 22159 
          (_etype527, _size524) = iprot.readListBegin()
22160 
          for _i528 in xrange(_size524):
22161 
            _elem529 = Order()
22162 
            _elem529.read(iprot)
22163 
            self.success.append(_elem529)
4600 varun.gupt 22164 
          iprot.readListEnd()
22165 
        else:
22166 
          iprot.skip(ftype)
22167 
      elif fid == 1:
22168 
        if ftype == TType.STRUCT:
22169 
          self.ex = TransactionServiceException()
22170 
          self.ex.read(iprot)
22171 
        else:
22172 
          iprot.skip(ftype)
22173 
      else:
22174 
        iprot.skip(ftype)
22175 
      iprot.readFieldEnd()
22176 
    iprot.readStructEnd()
22177 
 
22178 
  def write(self, oprot):
22179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22181 
      return
22182 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22183 
    if self.success is not None:
22184 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22185 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22186 
      for iter530 in self.success:
22187 
        iter530.write(oprot)
4600 varun.gupt 22188 
      oprot.writeListEnd()
22189 
      oprot.writeFieldEnd()
22190 
    if self.ex is not None:
22191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22192 
      self.ex.write(oprot)
22193 
      oprot.writeFieldEnd()
22194 
    oprot.writeFieldStop()
22195 
    oprot.writeStructEnd()
22196 
 
22197 
  def validate(self):
22198 
    return
22199 
 
22200 
 
22201 
  def __repr__(self):
22202 
    L = ['%s=%r' % (key, value)
22203 
      for key, value in self.__dict__.iteritems()]
22204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22205 
 
22206 
  def __eq__(self, other):
22207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22208 
 
22209 
  def __ne__(self, other):
22210 
    return not (self == other)
22211 
 
4607 rajveer 22212 
class getSlippedSippingDateOrders_args:
22213 
 
22214 
  thrift_spec = (
22215 
  )
22216 
 
22217 
  def read(self, iprot):
22218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22220 
      return
22221 
    iprot.readStructBegin()
22222 
    while True:
22223 
      (fname, ftype, fid) = iprot.readFieldBegin()
22224 
      if ftype == TType.STOP:
22225 
        break
22226 
      else:
22227 
        iprot.skip(ftype)
22228 
      iprot.readFieldEnd()
22229 
    iprot.readStructEnd()
22230 
 
22231 
  def write(self, oprot):
22232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22234 
      return
22235 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22236 
    oprot.writeFieldStop()
22237 
    oprot.writeStructEnd()
22238 
 
22239 
  def validate(self):
22240 
    return
22241 
 
22242 
 
22243 
  def __repr__(self):
22244 
    L = ['%s=%r' % (key, value)
22245 
      for key, value in self.__dict__.iteritems()]
22246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22247 
 
22248 
  def __eq__(self, other):
22249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22250 
 
22251 
  def __ne__(self, other):
22252 
    return not (self == other)
22253 
 
22254 
class getSlippedSippingDateOrders_result:
22255 
  """
22256 
  Attributes:
22257 
   - success
22258 
   - ex
22259 
  """
22260 
 
22261 
  thrift_spec = (
22262 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22264 
  )
22265 
 
22266 
  def __init__(self, success=None, ex=None,):
22267 
    self.success = success
22268 
    self.ex = ex
22269 
 
22270 
  def read(self, iprot):
22271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22273 
      return
22274 
    iprot.readStructBegin()
22275 
    while True:
22276 
      (fname, ftype, fid) = iprot.readFieldBegin()
22277 
      if ftype == TType.STOP:
22278 
        break
22279 
      if fid == 0:
22280 
        if ftype == TType.LIST:
22281 
          self.success = []
6188 rajveer 22282 
          (_etype534, _size531) = iprot.readListBegin()
22283 
          for _i535 in xrange(_size531):
22284 
            _elem536 = Order()
22285 
            _elem536.read(iprot)
22286 
            self.success.append(_elem536)
4607 rajveer 22287 
          iprot.readListEnd()
22288 
        else:
22289 
          iprot.skip(ftype)
22290 
      elif fid == 1:
22291 
        if ftype == TType.STRUCT:
22292 
          self.ex = TransactionServiceException()
22293 
          self.ex.read(iprot)
22294 
        else:
22295 
          iprot.skip(ftype)
22296 
      else:
22297 
        iprot.skip(ftype)
22298 
      iprot.readFieldEnd()
22299 
    iprot.readStructEnd()
22300 
 
22301 
  def write(self, oprot):
22302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22304 
      return
22305 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22306 
    if self.success is not None:
22307 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22308 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22309 
      for iter537 in self.success:
22310 
        iter537.write(oprot)
4607 rajveer 22311 
      oprot.writeListEnd()
22312 
      oprot.writeFieldEnd()
22313 
    if self.ex is not None:
22314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22315 
      self.ex.write(oprot)
22316 
      oprot.writeFieldEnd()
22317 
    oprot.writeFieldStop()
22318 
    oprot.writeStructEnd()
22319 
 
22320 
  def validate(self):
22321 
    return
22322 
 
22323 
 
22324 
  def __repr__(self):
22325 
    L = ['%s=%r' % (key, value)
22326 
      for key, value in self.__dict__.iteritems()]
22327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22328 
 
22329 
  def __eq__(self, other):
22330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22331 
 
22332 
  def __ne__(self, other):
22333 
    return not (self == other)
22334 
 
4709 rajveer 22335 
class getCancelledOrders_args:
22336 
  """
22337 
  Attributes:
22338 
   - cancelDateFrom
22339 
   - cancelDateTo
22340 
  """
22341 
 
22342 
  thrift_spec = (
22343 
    None, # 0
22344 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22345 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22346 
  )
22347 
 
22348 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22349 
    self.cancelDateFrom = cancelDateFrom
22350 
    self.cancelDateTo = cancelDateTo
22351 
 
22352 
  def read(self, iprot):
22353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22355 
      return
22356 
    iprot.readStructBegin()
22357 
    while True:
22358 
      (fname, ftype, fid) = iprot.readFieldBegin()
22359 
      if ftype == TType.STOP:
22360 
        break
22361 
      if fid == 1:
22362 
        if ftype == TType.I64:
22363 
          self.cancelDateFrom = iprot.readI64();
22364 
        else:
22365 
          iprot.skip(ftype)
22366 
      elif fid == 2:
22367 
        if ftype == TType.I64:
22368 
          self.cancelDateTo = iprot.readI64();
22369 
        else:
22370 
          iprot.skip(ftype)
22371 
      else:
22372 
        iprot.skip(ftype)
22373 
      iprot.readFieldEnd()
22374 
    iprot.readStructEnd()
22375 
 
22376 
  def write(self, oprot):
22377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22379 
      return
22380 
    oprot.writeStructBegin('getCancelledOrders_args')
22381 
    if self.cancelDateFrom is not None:
22382 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22383 
      oprot.writeI64(self.cancelDateFrom)
22384 
      oprot.writeFieldEnd()
22385 
    if self.cancelDateTo is not None:
22386 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22387 
      oprot.writeI64(self.cancelDateTo)
22388 
      oprot.writeFieldEnd()
22389 
    oprot.writeFieldStop()
22390 
    oprot.writeStructEnd()
22391 
 
22392 
  def validate(self):
22393 
    return
22394 
 
22395 
 
22396 
  def __repr__(self):
22397 
    L = ['%s=%r' % (key, value)
22398 
      for key, value in self.__dict__.iteritems()]
22399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22400 
 
22401 
  def __eq__(self, other):
22402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22403 
 
22404 
  def __ne__(self, other):
22405 
    return not (self == other)
22406 
 
22407 
class getCancelledOrders_result:
22408 
  """
22409 
  Attributes:
22410 
   - success
22411 
   - ex
22412 
  """
22413 
 
22414 
  thrift_spec = (
22415 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22417 
  )
22418 
 
22419 
  def __init__(self, success=None, ex=None,):
22420 
    self.success = success
22421 
    self.ex = ex
22422 
 
22423 
  def read(self, iprot):
22424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22426 
      return
22427 
    iprot.readStructBegin()
22428 
    while True:
22429 
      (fname, ftype, fid) = iprot.readFieldBegin()
22430 
      if ftype == TType.STOP:
22431 
        break
22432 
      if fid == 0:
22433 
        if ftype == TType.LIST:
22434 
          self.success = []
6188 rajveer 22435 
          (_etype541, _size538) = iprot.readListBegin()
22436 
          for _i542 in xrange(_size538):
22437 
            _elem543 = Order()
22438 
            _elem543.read(iprot)
22439 
            self.success.append(_elem543)
4709 rajveer 22440 
          iprot.readListEnd()
22441 
        else:
22442 
          iprot.skip(ftype)
22443 
      elif fid == 1:
22444 
        if ftype == TType.STRUCT:
22445 
          self.ex = TransactionServiceException()
22446 
          self.ex.read(iprot)
22447 
        else:
22448 
          iprot.skip(ftype)
22449 
      else:
22450 
        iprot.skip(ftype)
22451 
      iprot.readFieldEnd()
22452 
    iprot.readStructEnd()
22453 
 
22454 
  def write(self, oprot):
22455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22457 
      return
22458 
    oprot.writeStructBegin('getCancelledOrders_result')
22459 
    if self.success is not None:
22460 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22461 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22462 
      for iter544 in self.success:
22463 
        iter544.write(oprot)
4709 rajveer 22464 
      oprot.writeListEnd()
22465 
      oprot.writeFieldEnd()
22466 
    if self.ex is not None:
22467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22468 
      self.ex.write(oprot)
22469 
      oprot.writeFieldEnd()
22470 
    oprot.writeFieldStop()
22471 
    oprot.writeStructEnd()
22472 
 
22473 
  def validate(self):
22474 
    return
22475 
 
22476 
 
22477 
  def __repr__(self):
22478 
    L = ['%s=%r' % (key, value)
22479 
      for key, value in self.__dict__.iteritems()]
22480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22481 
 
22482 
  def __eq__(self, other):
22483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22484 
 
22485 
  def __ne__(self, other):
22486 
    return not (self == other)
22487 
 
4600 varun.gupt 22488 
class saveBluedartSettlements_args:
22489 
  """
22490 
  Attributes:
22491 
   - mapAWBAndAmount
22492 
  """
22493 
 
22494 
  thrift_spec = (
22495 
    None, # 0
22496 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22497 
  )
22498 
 
22499 
  def __init__(self, mapAWBAndAmount=None,):
22500 
    self.mapAWBAndAmount = mapAWBAndAmount
22501 
 
22502 
  def read(self, iprot):
22503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22505 
      return
22506 
    iprot.readStructBegin()
22507 
    while True:
22508 
      (fname, ftype, fid) = iprot.readFieldBegin()
22509 
      if ftype == TType.STOP:
22510 
        break
22511 
      if fid == 1:
22512 
        if ftype == TType.MAP:
22513 
          self.mapAWBAndAmount = {}
6188 rajveer 22514 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22515 
          for _i549 in xrange(_size545):
22516 
            _key550 = iprot.readI64();
22517 
            _val551 = iprot.readDouble();
22518 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22519 
          iprot.readMapEnd()
22520 
        else:
22521 
          iprot.skip(ftype)
22522 
      else:
22523 
        iprot.skip(ftype)
22524 
      iprot.readFieldEnd()
22525 
    iprot.readStructEnd()
22526 
 
22527 
  def write(self, oprot):
22528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22530 
      return
22531 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22532 
    if self.mapAWBAndAmount is not None:
22533 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22534 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22535 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22536 
        oprot.writeI64(kiter552)
22537 
        oprot.writeDouble(viter553)
4600 varun.gupt 22538 
      oprot.writeMapEnd()
22539 
      oprot.writeFieldEnd()
22540 
    oprot.writeFieldStop()
22541 
    oprot.writeStructEnd()
22542 
 
22543 
  def validate(self):
22544 
    return
22545 
 
22546 
 
22547 
  def __repr__(self):
22548 
    L = ['%s=%r' % (key, value)
22549 
      for key, value in self.__dict__.iteritems()]
22550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22551 
 
22552 
  def __eq__(self, other):
22553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22554 
 
22555 
  def __ne__(self, other):
22556 
    return not (self == other)
22557 
 
22558 
class saveBluedartSettlements_result:
22559 
  """
22560 
  Attributes:
22561 
   - ex
22562 
  """
22563 
 
22564 
  thrift_spec = (
22565 
    None, # 0
22566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22567 
  )
22568 
 
22569 
  def __init__(self, ex=None,):
22570 
    self.ex = ex
22571 
 
22572 
  def read(self, iprot):
22573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22575 
      return
22576 
    iprot.readStructBegin()
22577 
    while True:
22578 
      (fname, ftype, fid) = iprot.readFieldBegin()
22579 
      if ftype == TType.STOP:
22580 
        break
22581 
      if fid == 1:
22582 
        if ftype == TType.STRUCT:
22583 
          self.ex = TransactionServiceException()
22584 
          self.ex.read(iprot)
22585 
        else:
22586 
          iprot.skip(ftype)
22587 
      else:
22588 
        iprot.skip(ftype)
22589 
      iprot.readFieldEnd()
22590 
    iprot.readStructEnd()
22591 
 
22592 
  def write(self, oprot):
22593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22595 
      return
22596 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22597 
    if self.ex is not None:
22598 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22599 
      self.ex.write(oprot)
22600 
      oprot.writeFieldEnd()
22601 
    oprot.writeFieldStop()
22602 
    oprot.writeStructEnd()
22603 
 
22604 
  def validate(self):
22605 
    return
22606 
 
22607 
 
22608 
  def __repr__(self):
22609 
    L = ['%s=%r' % (key, value)
22610 
      for key, value in self.__dict__.iteritems()]
22611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22612 
 
22613 
  def __eq__(self, other):
22614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22615 
 
22616 
  def __ne__(self, other):
22617 
    return not (self == other)
22618 
 
22619 
class savePaymentSettlements_args:
22620 
  """
22621 
  Attributes:
22622 
   - settlementDate
22623 
   - paymentGatewayId
4905 varun.gupt 22624 
   - referenceId
4600 varun.gupt 22625 
   - serviceTax
22626 
   - otherCharges
22627 
   - netCollection
22628 
  """
22629 
 
22630 
  thrift_spec = (
22631 
    None, # 0
22632 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22633 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22634 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22635 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22636 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22637 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22638 
  )
22639 
 
4905 varun.gupt 22640 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22641 
    self.settlementDate = settlementDate
22642 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22643 
    self.referenceId = referenceId
4600 varun.gupt 22644 
    self.serviceTax = serviceTax
22645 
    self.otherCharges = otherCharges
22646 
    self.netCollection = netCollection
22647 
 
22648 
  def read(self, iprot):
22649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22651 
      return
22652 
    iprot.readStructBegin()
22653 
    while True:
22654 
      (fname, ftype, fid) = iprot.readFieldBegin()
22655 
      if ftype == TType.STOP:
22656 
        break
22657 
      if fid == 1:
22658 
        if ftype == TType.I64:
22659 
          self.settlementDate = iprot.readI64();
22660 
        else:
22661 
          iprot.skip(ftype)
22662 
      elif fid == 2:
22663 
        if ftype == TType.I64:
22664 
          self.paymentGatewayId = iprot.readI64();
22665 
        else:
22666 
          iprot.skip(ftype)
22667 
      elif fid == 3:
22668 
        if ftype == TType.I64:
4905 varun.gupt 22669 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22670 
        else:
22671 
          iprot.skip(ftype)
22672 
      elif fid == 4:
22673 
        if ftype == TType.DOUBLE:
22674 
          self.serviceTax = iprot.readDouble();
22675 
        else:
22676 
          iprot.skip(ftype)
22677 
      elif fid == 5:
22678 
        if ftype == TType.DOUBLE:
22679 
          self.otherCharges = iprot.readDouble();
22680 
        else:
22681 
          iprot.skip(ftype)
22682 
      elif fid == 6:
22683 
        if ftype == TType.DOUBLE:
22684 
          self.netCollection = iprot.readDouble();
22685 
        else:
22686 
          iprot.skip(ftype)
22687 
      else:
22688 
        iprot.skip(ftype)
22689 
      iprot.readFieldEnd()
22690 
    iprot.readStructEnd()
22691 
 
22692 
  def write(self, oprot):
22693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22695 
      return
22696 
    oprot.writeStructBegin('savePaymentSettlements_args')
22697 
    if self.settlementDate is not None:
22698 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22699 
      oprot.writeI64(self.settlementDate)
22700 
      oprot.writeFieldEnd()
22701 
    if self.paymentGatewayId is not None:
22702 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22703 
      oprot.writeI64(self.paymentGatewayId)
22704 
      oprot.writeFieldEnd()
4905 varun.gupt 22705 
    if self.referenceId is not None:
22706 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22707 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22708 
      oprot.writeFieldEnd()
22709 
    if self.serviceTax is not None:
22710 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22711 
      oprot.writeDouble(self.serviceTax)
22712 
      oprot.writeFieldEnd()
22713 
    if self.otherCharges is not None:
22714 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22715 
      oprot.writeDouble(self.otherCharges)
22716 
      oprot.writeFieldEnd()
22717 
    if self.netCollection is not None:
22718 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22719 
      oprot.writeDouble(self.netCollection)
22720 
      oprot.writeFieldEnd()
22721 
    oprot.writeFieldStop()
22722 
    oprot.writeStructEnd()
22723 
 
22724 
  def validate(self):
22725 
    return
22726 
 
22727 
 
22728 
  def __repr__(self):
22729 
    L = ['%s=%r' % (key, value)
22730 
      for key, value in self.__dict__.iteritems()]
22731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22732 
 
22733 
  def __eq__(self, other):
22734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22735 
 
22736 
  def __ne__(self, other):
22737 
    return not (self == other)
22738 
 
22739 
class savePaymentSettlements_result:
22740 
  """
22741 
  Attributes:
22742 
   - ex
22743 
  """
22744 
 
22745 
  thrift_spec = (
22746 
    None, # 0
22747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22748 
  )
22749 
 
22750 
  def __init__(self, ex=None,):
22751 
    self.ex = ex
22752 
 
22753 
  def read(self, iprot):
22754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22756 
      return
22757 
    iprot.readStructBegin()
22758 
    while True:
22759 
      (fname, ftype, fid) = iprot.readFieldBegin()
22760 
      if ftype == TType.STOP:
22761 
        break
22762 
      if fid == 1:
22763 
        if ftype == TType.STRUCT:
22764 
          self.ex = TransactionServiceException()
22765 
          self.ex.read(iprot)
22766 
        else:
22767 
          iprot.skip(ftype)
22768 
      else:
22769 
        iprot.skip(ftype)
22770 
      iprot.readFieldEnd()
22771 
    iprot.readStructEnd()
22772 
 
22773 
  def write(self, oprot):
22774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22776 
      return
22777 
    oprot.writeStructBegin('savePaymentSettlements_result')
22778 
    if self.ex is not None:
22779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22780 
      self.ex.write(oprot)
22781 
      oprot.writeFieldEnd()
22782 
    oprot.writeFieldStop()
22783 
    oprot.writeStructEnd()
22784 
 
22785 
  def validate(self):
22786 
    return
22787 
 
22788 
 
22789 
  def __repr__(self):
22790 
    L = ['%s=%r' % (key, value)
22791 
      for key, value in self.__dict__.iteritems()]
22792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22793 
 
22794 
  def __eq__(self, other):
22795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22796 
 
22797 
  def __ne__(self, other):
22798 
    return not (self == other)
22799 
 
22800 
class saveEBSSettlementSummary_args:
22801 
  """
22802 
  Attributes:
22803 
   - settlementId
22804 
   - settlementDate
22805 
   - transactionDateFrom
22806 
   - transactionDateTo
22807 
   - amount
22808 
  """
22809 
 
22810 
  thrift_spec = (
22811 
    None, # 0
22812 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22813 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22814 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22815 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22816 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22817 
  )
22818 
 
22819 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22820 
    self.settlementId = settlementId
22821 
    self.settlementDate = settlementDate
22822 
    self.transactionDateFrom = transactionDateFrom
22823 
    self.transactionDateTo = transactionDateTo
22824 
    self.amount = amount
22825 
 
22826 
  def read(self, iprot):
22827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22829 
      return
22830 
    iprot.readStructBegin()
22831 
    while True:
22832 
      (fname, ftype, fid) = iprot.readFieldBegin()
22833 
      if ftype == TType.STOP:
22834 
        break
22835 
      if fid == 1:
22836 
        if ftype == TType.I64:
22837 
          self.settlementId = iprot.readI64();
22838 
        else:
22839 
          iprot.skip(ftype)
22840 
      elif fid == 2:
22841 
        if ftype == TType.I64:
22842 
          self.settlementDate = iprot.readI64();
22843 
        else:
22844 
          iprot.skip(ftype)
22845 
      elif fid == 3:
22846 
        if ftype == TType.I64:
22847 
          self.transactionDateFrom = iprot.readI64();
22848 
        else:
22849 
          iprot.skip(ftype)
22850 
      elif fid == 4:
22851 
        if ftype == TType.I64:
22852 
          self.transactionDateTo = iprot.readI64();
22853 
        else:
22854 
          iprot.skip(ftype)
22855 
      elif fid == 5:
22856 
        if ftype == TType.DOUBLE:
22857 
          self.amount = iprot.readDouble();
22858 
        else:
22859 
          iprot.skip(ftype)
22860 
      else:
22861 
        iprot.skip(ftype)
22862 
      iprot.readFieldEnd()
22863 
    iprot.readStructEnd()
22864 
 
22865 
  def write(self, oprot):
22866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22868 
      return
22869 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22870 
    if self.settlementId is not None:
22871 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22872 
      oprot.writeI64(self.settlementId)
22873 
      oprot.writeFieldEnd()
22874 
    if self.settlementDate is not None:
22875 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22876 
      oprot.writeI64(self.settlementDate)
22877 
      oprot.writeFieldEnd()
22878 
    if self.transactionDateFrom is not None:
22879 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22880 
      oprot.writeI64(self.transactionDateFrom)
22881 
      oprot.writeFieldEnd()
22882 
    if self.transactionDateTo is not None:
22883 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22884 
      oprot.writeI64(self.transactionDateTo)
22885 
      oprot.writeFieldEnd()
22886 
    if self.amount is not None:
22887 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22888 
      oprot.writeDouble(self.amount)
22889 
      oprot.writeFieldEnd()
22890 
    oprot.writeFieldStop()
22891 
    oprot.writeStructEnd()
22892 
 
22893 
  def validate(self):
22894 
    return
22895 
 
22896 
 
22897 
  def __repr__(self):
22898 
    L = ['%s=%r' % (key, value)
22899 
      for key, value in self.__dict__.iteritems()]
22900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22901 
 
22902 
  def __eq__(self, other):
22903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22904 
 
22905 
  def __ne__(self, other):
22906 
    return not (self == other)
22907 
 
22908 
class saveEBSSettlementSummary_result:
22909 
  """
22910 
  Attributes:
22911 
   - ex
22912 
  """
22913 
 
22914 
  thrift_spec = (
22915 
    None, # 0
22916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22917 
  )
22918 
 
22919 
  def __init__(self, ex=None,):
22920 
    self.ex = ex
22921 
 
22922 
  def read(self, iprot):
22923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22925 
      return
22926 
    iprot.readStructBegin()
22927 
    while True:
22928 
      (fname, ftype, fid) = iprot.readFieldBegin()
22929 
      if ftype == TType.STOP:
22930 
        break
22931 
      if fid == 1:
22932 
        if ftype == TType.STRUCT:
22933 
          self.ex = TransactionServiceException()
22934 
          self.ex.read(iprot)
22935 
        else:
22936 
          iprot.skip(ftype)
22937 
      else:
22938 
        iprot.skip(ftype)
22939 
      iprot.readFieldEnd()
22940 
    iprot.readStructEnd()
22941 
 
22942 
  def write(self, oprot):
22943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22945 
      return
22946 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22947 
    if self.ex is not None:
22948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22949 
      self.ex.write(oprot)
22950 
      oprot.writeFieldEnd()
22951 
    oprot.writeFieldStop()
22952 
    oprot.writeStructEnd()
22953 
 
22954 
  def validate(self):
22955 
    return
22956 
 
22957 
 
22958 
  def __repr__(self):
22959 
    L = ['%s=%r' % (key, value)
22960 
      for key, value in self.__dict__.iteritems()]
22961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22962 
 
22963 
  def __eq__(self, other):
22964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22965 
 
22966 
  def __ne__(self, other):
22967 
    return not (self == other)
22968 
 
5386 phani.kuma 22969 
class getSettlementForPrepaid_args:
4600 varun.gupt 22970 
  """
22971 
  Attributes:
5189 varun.gupt 22972 
   - referenceId
22973 
   - isRefund
4600 varun.gupt 22974 
  """
22975 
 
22976 
  thrift_spec = (
22977 
    None, # 0
5189 varun.gupt 22978 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22979 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22980 
  )
22981 
 
5386 phani.kuma 22982 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22983 
    self.referenceId = referenceId
22984 
    self.isRefund = isRefund
4600 varun.gupt 22985 
 
22986 
  def read(self, iprot):
22987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22989 
      return
22990 
    iprot.readStructBegin()
22991 
    while True:
22992 
      (fname, ftype, fid) = iprot.readFieldBegin()
22993 
      if ftype == TType.STOP:
22994 
        break
22995 
      if fid == 1:
22996 
        if ftype == TType.I64:
5189 varun.gupt 22997 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22998 
        else:
22999 
          iprot.skip(ftype)
5189 varun.gupt 23000 
      elif fid == 2:
23001 
        if ftype == TType.BOOL:
23002 
          self.isRefund = iprot.readBool();
23003 
        else:
23004 
          iprot.skip(ftype)
4600 varun.gupt 23005 
      else:
23006 
        iprot.skip(ftype)
23007 
      iprot.readFieldEnd()
23008 
    iprot.readStructEnd()
23009 
 
23010 
  def write(self, oprot):
23011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23013 
      return
5386 phani.kuma 23014 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23015 
    if self.referenceId is not None:
23016 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23017 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23018 
      oprot.writeFieldEnd()
5386 phani.kuma 23019 
    if self.isRefund is not None:
23020 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23021 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23022 
      oprot.writeFieldEnd()
5386 phani.kuma 23023 
    oprot.writeFieldStop()
23024 
    oprot.writeStructEnd()
23025 
 
23026 
  def validate(self):
23027 
    return
23028 
 
23029 
 
23030 
  def __repr__(self):
23031 
    L = ['%s=%r' % (key, value)
23032 
      for key, value in self.__dict__.iteritems()]
23033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23034 
 
23035 
  def __eq__(self, other):
23036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23037 
 
23038 
  def __ne__(self, other):
23039 
    return not (self == other)
23040 
 
23041 
class getSettlementForPrepaid_result:
23042 
  """
23043 
  Attributes:
23044 
   - success
23045 
   - ex
23046 
  """
23047 
 
23048 
  thrift_spec = (
23049 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23051 
  )
23052 
 
23053 
  def __init__(self, success=None, ex=None,):
23054 
    self.success = success
23055 
    self.ex = ex
23056 
 
23057 
  def read(self, iprot):
23058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23060 
      return
23061 
    iprot.readStructBegin()
23062 
    while True:
23063 
      (fname, ftype, fid) = iprot.readFieldBegin()
23064 
      if ftype == TType.STOP:
23065 
        break
23066 
      if fid == 0:
23067 
        if ftype == TType.STRUCT:
23068 
          self.success = PaymentSettlement()
23069 
          self.success.read(iprot)
23070 
        else:
23071 
          iprot.skip(ftype)
23072 
      elif fid == 1:
23073 
        if ftype == TType.STRUCT:
23074 
          self.ex = TransactionServiceException()
23075 
          self.ex.read(iprot)
23076 
        else:
23077 
          iprot.skip(ftype)
23078 
      else:
23079 
        iprot.skip(ftype)
23080 
      iprot.readFieldEnd()
23081 
    iprot.readStructEnd()
23082 
 
23083 
  def write(self, oprot):
23084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23086 
      return
23087 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23088 
    if self.success is not None:
23089 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23090 
      self.success.write(oprot)
23091 
      oprot.writeFieldEnd()
23092 
    if self.ex is not None:
23093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23094 
      self.ex.write(oprot)
23095 
      oprot.writeFieldEnd()
23096 
    oprot.writeFieldStop()
23097 
    oprot.writeStructEnd()
23098 
 
23099 
  def validate(self):
23100 
    return
23101 
 
23102 
 
23103 
  def __repr__(self):
23104 
    L = ['%s=%r' % (key, value)
23105 
      for key, value in self.__dict__.iteritems()]
23106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23107 
 
23108 
  def __eq__(self, other):
23109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23110 
 
23111 
  def __ne__(self, other):
23112 
    return not (self == other)
23113 
 
23114 
class getSettlementForCod_args:
23115 
  """
23116 
  Attributes:
23117 
   - orderId
23118 
   - isRefund
23119 
  """
23120 
 
23121 
  thrift_spec = (
23122 
    None, # 0
23123 
    (1, TType.I64, 'orderId', None, None, ), # 1
23124 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23125 
  )
23126 
 
23127 
  def __init__(self, orderId=None, isRefund=None,):
23128 
    self.orderId = orderId
23129 
    self.isRefund = isRefund
23130 
 
23131 
  def read(self, iprot):
23132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23134 
      return
23135 
    iprot.readStructBegin()
23136 
    while True:
23137 
      (fname, ftype, fid) = iprot.readFieldBegin()
23138 
      if ftype == TType.STOP:
23139 
        break
23140 
      if fid == 1:
23141 
        if ftype == TType.I64:
23142 
          self.orderId = iprot.readI64();
23143 
        else:
23144 
          iprot.skip(ftype)
23145 
      elif fid == 2:
23146 
        if ftype == TType.BOOL:
23147 
          self.isRefund = iprot.readBool();
23148 
        else:
23149 
          iprot.skip(ftype)
23150 
      else:
23151 
        iprot.skip(ftype)
23152 
      iprot.readFieldEnd()
23153 
    iprot.readStructEnd()
23154 
 
23155 
  def write(self, oprot):
23156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23158 
      return
23159 
    oprot.writeStructBegin('getSettlementForCod_args')
23160 
    if self.orderId is not None:
23161 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23162 
      oprot.writeI64(self.orderId)
23163 
      oprot.writeFieldEnd()
5189 varun.gupt 23164 
    if self.isRefund is not None:
5386 phani.kuma 23165 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23166 
      oprot.writeBool(self.isRefund)
23167 
      oprot.writeFieldEnd()
4600 varun.gupt 23168 
    oprot.writeFieldStop()
23169 
    oprot.writeStructEnd()
23170 
 
23171 
  def validate(self):
23172 
    return
23173 
 
23174 
 
23175 
  def __repr__(self):
23176 
    L = ['%s=%r' % (key, value)
23177 
      for key, value in self.__dict__.iteritems()]
23178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23179 
 
23180 
  def __eq__(self, other):
23181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23182 
 
23183 
  def __ne__(self, other):
23184 
    return not (self == other)
23185 
 
5386 phani.kuma 23186 
class getSettlementForCod_result:
4600 varun.gupt 23187 
  """
23188 
  Attributes:
23189 
   - success
23190 
   - ex
23191 
  """
23192 
 
23193 
  thrift_spec = (
23194 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23196 
  )
23197 
 
23198 
  def __init__(self, success=None, ex=None,):
23199 
    self.success = success
23200 
    self.ex = ex
23201 
 
23202 
  def read(self, iprot):
23203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23205 
      return
23206 
    iprot.readStructBegin()
23207 
    while True:
23208 
      (fname, ftype, fid) = iprot.readFieldBegin()
23209 
      if ftype == TType.STOP:
23210 
        break
23211 
      if fid == 0:
23212 
        if ftype == TType.STRUCT:
23213 
          self.success = PaymentSettlement()
23214 
          self.success.read(iprot)
23215 
        else:
23216 
          iprot.skip(ftype)
23217 
      elif fid == 1:
23218 
        if ftype == TType.STRUCT:
23219 
          self.ex = TransactionServiceException()
23220 
          self.ex.read(iprot)
23221 
        else:
23222 
          iprot.skip(ftype)
23223 
      else:
23224 
        iprot.skip(ftype)
23225 
      iprot.readFieldEnd()
23226 
    iprot.readStructEnd()
23227 
 
23228 
  def write(self, oprot):
23229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23231 
      return
5386 phani.kuma 23232 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23233 
    if self.success is not None:
23234 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23235 
      self.success.write(oprot)
23236 
      oprot.writeFieldEnd()
23237 
    if self.ex is not None:
23238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23239 
      self.ex.write(oprot)
23240 
      oprot.writeFieldEnd()
23241 
    oprot.writeFieldStop()
23242 
    oprot.writeStructEnd()
23243 
 
23244 
  def validate(self):
23245 
    return
23246 
 
23247 
 
23248 
  def __repr__(self):
23249 
    L = ['%s=%r' % (key, value)
23250 
      for key, value in self.__dict__.iteritems()]
23251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23252 
 
23253 
  def __eq__(self, other):
23254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23255 
 
23256 
  def __ne__(self, other):
23257 
    return not (self == other)
23258 
 
23259 
class getEBSSettlementSummaries_args:
23260 
 
23261 
  thrift_spec = (
23262 
  )
23263 
 
23264 
  def read(self, iprot):
23265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23267 
      return
23268 
    iprot.readStructBegin()
23269 
    while True:
23270 
      (fname, ftype, fid) = iprot.readFieldBegin()
23271 
      if ftype == TType.STOP:
23272 
        break
23273 
      else:
23274 
        iprot.skip(ftype)
23275 
      iprot.readFieldEnd()
23276 
    iprot.readStructEnd()
23277 
 
23278 
  def write(self, oprot):
23279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23281 
      return
23282 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23283 
    oprot.writeFieldStop()
23284 
    oprot.writeStructEnd()
23285 
 
23286 
  def validate(self):
23287 
    return
23288 
 
23289 
 
23290 
  def __repr__(self):
23291 
    L = ['%s=%r' % (key, value)
23292 
      for key, value in self.__dict__.iteritems()]
23293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23294 
 
23295 
  def __eq__(self, other):
23296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23297 
 
23298 
  def __ne__(self, other):
23299 
    return not (self == other)
23300 
 
23301 
class getEBSSettlementSummaries_result:
23302 
  """
23303 
  Attributes:
23304 
   - success
23305 
   - ex
23306 
  """
23307 
 
23308 
  thrift_spec = (
23309 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23311 
  )
23312 
 
23313 
  def __init__(self, success=None, ex=None,):
23314 
    self.success = success
23315 
    self.ex = ex
23316 
 
23317 
  def read(self, iprot):
23318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23320 
      return
23321 
    iprot.readStructBegin()
23322 
    while True:
23323 
      (fname, ftype, fid) = iprot.readFieldBegin()
23324 
      if ftype == TType.STOP:
23325 
        break
23326 
      if fid == 0:
23327 
        if ftype == TType.MAP:
23328 
          self.success = {}
6188 rajveer 23329 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23330 
          for _i558 in xrange(_size554):
23331 
            _key559 = iprot.readI64();
23332 
            _val560 = iprot.readString();
23333 
            self.success[_key559] = _val560
4600 varun.gupt 23334 
          iprot.readMapEnd()
23335 
        else:
23336 
          iprot.skip(ftype)
23337 
      elif fid == 1:
23338 
        if ftype == TType.STRUCT:
23339 
          self.ex = TransactionServiceException()
23340 
          self.ex.read(iprot)
23341 
        else:
23342 
          iprot.skip(ftype)
23343 
      else:
23344 
        iprot.skip(ftype)
23345 
      iprot.readFieldEnd()
23346 
    iprot.readStructEnd()
23347 
 
23348 
  def write(self, oprot):
23349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23351 
      return
23352 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23353 
    if self.success is not None:
23354 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23355 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23356 
      for kiter561,viter562 in self.success.items():
23357 
        oprot.writeI64(kiter561)
23358 
        oprot.writeString(viter562)
4600 varun.gupt 23359 
      oprot.writeMapEnd()
23360 
      oprot.writeFieldEnd()
23361 
    if self.ex is not None:
23362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23363 
      self.ex.write(oprot)
23364 
      oprot.writeFieldEnd()
23365 
    oprot.writeFieldStop()
23366 
    oprot.writeStructEnd()
23367 
 
23368 
  def validate(self):
23369 
    return
23370 
 
23371 
 
23372 
  def __repr__(self):
23373 
    L = ['%s=%r' % (key, value)
23374 
      for key, value in self.__dict__.iteritems()]
23375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23376 
 
23377 
  def __eq__(self, other):
23378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23379 
 
23380 
  def __ne__(self, other):
23381 
    return not (self == other)
23382 
 
23383 
class markEBSSettlementUploaded_args:
23384 
  """
23385 
  Attributes:
23386 
   - settlementId
23387 
  """
23388 
 
23389 
  thrift_spec = (
23390 
    None, # 0
23391 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23392 
  )
23393 
 
23394 
  def __init__(self, settlementId=None,):
23395 
    self.settlementId = settlementId
23396 
 
23397 
  def read(self, iprot):
23398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23400 
      return
23401 
    iprot.readStructBegin()
23402 
    while True:
23403 
      (fname, ftype, fid) = iprot.readFieldBegin()
23404 
      if ftype == TType.STOP:
23405 
        break
23406 
      if fid == 1:
23407 
        if ftype == TType.I64:
23408 
          self.settlementId = iprot.readI64();
23409 
        else:
23410 
          iprot.skip(ftype)
23411 
      else:
23412 
        iprot.skip(ftype)
23413 
      iprot.readFieldEnd()
23414 
    iprot.readStructEnd()
23415 
 
23416 
  def write(self, oprot):
23417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23419 
      return
23420 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23421 
    if self.settlementId is not None:
23422 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23423 
      oprot.writeI64(self.settlementId)
23424 
      oprot.writeFieldEnd()
23425 
    oprot.writeFieldStop()
23426 
    oprot.writeStructEnd()
23427 
 
23428 
  def validate(self):
23429 
    return
23430 
 
23431 
 
23432 
  def __repr__(self):
23433 
    L = ['%s=%r' % (key, value)
23434 
      for key, value in self.__dict__.iteritems()]
23435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23436 
 
23437 
  def __eq__(self, other):
23438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23439 
 
23440 
  def __ne__(self, other):
23441 
    return not (self == other)
23442 
 
23443 
class markEBSSettlementUploaded_result:
23444 
  """
23445 
  Attributes:
23446 
   - ex
23447 
  """
23448 
 
23449 
  thrift_spec = (
23450 
    None, # 0
23451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23452 
  )
23453 
 
23454 
  def __init__(self, ex=None,):
23455 
    self.ex = ex
23456 
 
23457 
  def read(self, iprot):
23458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23460 
      return
23461 
    iprot.readStructBegin()
23462 
    while True:
23463 
      (fname, ftype, fid) = iprot.readFieldBegin()
23464 
      if ftype == TType.STOP:
23465 
        break
23466 
      if fid == 1:
23467 
        if ftype == TType.STRUCT:
23468 
          self.ex = TransactionServiceException()
23469 
          self.ex.read(iprot)
23470 
        else:
23471 
          iprot.skip(ftype)
23472 
      else:
23473 
        iprot.skip(ftype)
23474 
      iprot.readFieldEnd()
23475 
    iprot.readStructEnd()
23476 
 
23477 
  def write(self, oprot):
23478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23480 
      return
23481 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23482 
    if self.ex is not None:
23483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23484 
      self.ex.write(oprot)
23485 
      oprot.writeFieldEnd()
23486 
    oprot.writeFieldStop()
23487 
    oprot.writeStructEnd()
23488 
 
23489 
  def validate(self):
23490 
    return
23491 
 
23492 
 
23493 
  def __repr__(self):
23494 
    L = ['%s=%r' % (key, value)
23495 
      for key, value in self.__dict__.iteritems()]
23496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23497 
 
23498 
  def __eq__(self, other):
23499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23500 
 
23501 
  def __ne__(self, other):
23502 
    return not (self == other)
23503 
 
23504 
class getEBSSettlementDate_args:
23505 
  """
23506 
  Attributes:
23507 
   - settlementId
23508 
  """
23509 
 
23510 
  thrift_spec = (
23511 
    None, # 0
23512 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23513 
  )
23514 
 
23515 
  def __init__(self, settlementId=None,):
23516 
    self.settlementId = settlementId
23517 
 
23518 
  def read(self, iprot):
23519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23521 
      return
23522 
    iprot.readStructBegin()
23523 
    while True:
23524 
      (fname, ftype, fid) = iprot.readFieldBegin()
23525 
      if ftype == TType.STOP:
23526 
        break
23527 
      if fid == 1:
23528 
        if ftype == TType.I64:
23529 
          self.settlementId = iprot.readI64();
23530 
        else:
23531 
          iprot.skip(ftype)
23532 
      else:
23533 
        iprot.skip(ftype)
23534 
      iprot.readFieldEnd()
23535 
    iprot.readStructEnd()
23536 
 
23537 
  def write(self, oprot):
23538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23540 
      return
23541 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23542 
    if self.settlementId is not None:
23543 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23544 
      oprot.writeI64(self.settlementId)
23545 
      oprot.writeFieldEnd()
23546 
    oprot.writeFieldStop()
23547 
    oprot.writeStructEnd()
23548 
 
23549 
  def validate(self):
23550 
    return
23551 
 
23552 
 
23553 
  def __repr__(self):
23554 
    L = ['%s=%r' % (key, value)
23555 
      for key, value in self.__dict__.iteritems()]
23556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23557 
 
23558 
  def __eq__(self, other):
23559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23560 
 
23561 
  def __ne__(self, other):
23562 
    return not (self == other)
23563 
 
23564 
class getEBSSettlementDate_result:
23565 
  """
23566 
  Attributes:
23567 
   - success
23568 
   - ex
23569 
  """
23570 
 
23571 
  thrift_spec = (
23572 
    (0, TType.I64, 'success', None, None, ), # 0
23573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23574 
  )
23575 
 
23576 
  def __init__(self, success=None, ex=None,):
23577 
    self.success = success
23578 
    self.ex = ex
23579 
 
23580 
  def read(self, iprot):
23581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23583 
      return
23584 
    iprot.readStructBegin()
23585 
    while True:
23586 
      (fname, ftype, fid) = iprot.readFieldBegin()
23587 
      if ftype == TType.STOP:
23588 
        break
23589 
      if fid == 0:
23590 
        if ftype == TType.I64:
23591 
          self.success = iprot.readI64();
23592 
        else:
23593 
          iprot.skip(ftype)
23594 
      elif fid == 1:
23595 
        if ftype == TType.STRUCT:
23596 
          self.ex = TransactionServiceException()
23597 
          self.ex.read(iprot)
23598 
        else:
23599 
          iprot.skip(ftype)
23600 
      else:
23601 
        iprot.skip(ftype)
23602 
      iprot.readFieldEnd()
23603 
    iprot.readStructEnd()
23604 
 
23605 
  def write(self, oprot):
23606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23608 
      return
23609 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23610 
    if self.success is not None:
23611 
      oprot.writeFieldBegin('success', TType.I64, 0)
23612 
      oprot.writeI64(self.success)
23613 
      oprot.writeFieldEnd()
23614 
    if self.ex is not None:
23615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23616 
      self.ex.write(oprot)
23617 
      oprot.writeFieldEnd()
23618 
    oprot.writeFieldStop()
23619 
    oprot.writeStructEnd()
23620 
 
23621 
  def validate(self):
23622 
    return
23623 
 
23624 
 
23625 
  def __repr__(self):
23626 
    L = ['%s=%r' % (key, value)
23627 
      for key, value in self.__dict__.iteritems()]
23628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23629 
 
23630 
  def __eq__(self, other):
23631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23632 
 
23633 
  def __ne__(self, other):
23634 
    return not (self == other)
4715 varun.gupt 23635 
 
23636 
class getSettlementsByDate_args:
23637 
  """
23638 
  Attributes:
23639 
   - settlementDateFrom
23640 
   - settlementDateTo
23641 
   - isRefund
23642 
  """
23643 
 
23644 
  thrift_spec = (
23645 
    None, # 0
23646 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23647 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23648 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23649 
  )
23650 
 
23651 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23652 
    self.settlementDateFrom = settlementDateFrom
23653 
    self.settlementDateTo = settlementDateTo
23654 
    self.isRefund = isRefund
23655 
 
23656 
  def read(self, iprot):
23657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23659 
      return
23660 
    iprot.readStructBegin()
23661 
    while True:
23662 
      (fname, ftype, fid) = iprot.readFieldBegin()
23663 
      if ftype == TType.STOP:
23664 
        break
23665 
      if fid == 1:
23666 
        if ftype == TType.I64:
23667 
          self.settlementDateFrom = iprot.readI64();
23668 
        else:
23669 
          iprot.skip(ftype)
23670 
      elif fid == 2:
23671 
        if ftype == TType.I64:
23672 
          self.settlementDateTo = iprot.readI64();
23673 
        else:
23674 
          iprot.skip(ftype)
23675 
      elif fid == 3:
23676 
        if ftype == TType.BOOL:
23677 
          self.isRefund = iprot.readBool();
23678 
        else:
23679 
          iprot.skip(ftype)
23680 
      else:
23681 
        iprot.skip(ftype)
23682 
      iprot.readFieldEnd()
23683 
    iprot.readStructEnd()
23684 
 
23685 
  def write(self, oprot):
23686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23688 
      return
23689 
    oprot.writeStructBegin('getSettlementsByDate_args')
23690 
    if self.settlementDateFrom is not None:
23691 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23692 
      oprot.writeI64(self.settlementDateFrom)
23693 
      oprot.writeFieldEnd()
23694 
    if self.settlementDateTo is not None:
23695 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23696 
      oprot.writeI64(self.settlementDateTo)
23697 
      oprot.writeFieldEnd()
23698 
    if self.isRefund is not None:
23699 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23700 
      oprot.writeBool(self.isRefund)
23701 
      oprot.writeFieldEnd()
23702 
    oprot.writeFieldStop()
23703 
    oprot.writeStructEnd()
23704 
 
23705 
  def validate(self):
23706 
    return
23707 
 
23708 
 
23709 
  def __repr__(self):
23710 
    L = ['%s=%r' % (key, value)
23711 
      for key, value in self.__dict__.iteritems()]
23712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23713 
 
23714 
  def __eq__(self, other):
23715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23716 
 
23717 
  def __ne__(self, other):
23718 
    return not (self == other)
23719 
 
23720 
class getSettlementsByDate_result:
23721 
  """
23722 
  Attributes:
23723 
   - success
23724 
   - ex
23725 
  """
23726 
 
23727 
  thrift_spec = (
23728 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23730 
  )
23731 
 
23732 
  def __init__(self, success=None, ex=None,):
23733 
    self.success = success
23734 
    self.ex = ex
23735 
 
23736 
  def read(self, iprot):
23737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23739 
      return
23740 
    iprot.readStructBegin()
23741 
    while True:
23742 
      (fname, ftype, fid) = iprot.readFieldBegin()
23743 
      if ftype == TType.STOP:
23744 
        break
23745 
      if fid == 0:
23746 
        if ftype == TType.LIST:
23747 
          self.success = []
6188 rajveer 23748 
          (_etype566, _size563) = iprot.readListBegin()
23749 
          for _i567 in xrange(_size563):
23750 
            _elem568 = PaymentSettlement()
23751 
            _elem568.read(iprot)
23752 
            self.success.append(_elem568)
4715 varun.gupt 23753 
          iprot.readListEnd()
23754 
        else:
23755 
          iprot.skip(ftype)
23756 
      elif fid == 1:
23757 
        if ftype == TType.STRUCT:
23758 
          self.ex = TransactionServiceException()
23759 
          self.ex.read(iprot)
23760 
        else:
23761 
          iprot.skip(ftype)
23762 
      else:
23763 
        iprot.skip(ftype)
23764 
      iprot.readFieldEnd()
23765 
    iprot.readStructEnd()
23766 
 
23767 
  def write(self, oprot):
23768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23770 
      return
23771 
    oprot.writeStructBegin('getSettlementsByDate_result')
23772 
    if self.success is not None:
23773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23775 
      for iter569 in self.success:
23776 
        iter569.write(oprot)
4715 varun.gupt 23777 
      oprot.writeListEnd()
23778 
      oprot.writeFieldEnd()
23779 
    if self.ex is not None:
23780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23781 
      self.ex.write(oprot)
23782 
      oprot.writeFieldEnd()
23783 
    oprot.writeFieldStop()
23784 
    oprot.writeStructEnd()
23785 
 
23786 
  def validate(self):
23787 
    return
23788 
 
23789 
 
23790 
  def __repr__(self):
23791 
    L = ['%s=%r' % (key, value)
23792 
      for key, value in self.__dict__.iteritems()]
23793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23794 
 
23795 
  def __eq__(self, other):
23796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23797 
 
23798 
  def __ne__(self, other):
23799 
    return not (self == other)
23800 
 
23801 
class getReshippedOrderIds_args:
23802 
  """
23803 
  Attributes:
23804 
   - orderIds
23805 
  """
23806 
 
23807 
  thrift_spec = (
23808 
    None, # 0
23809 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23810 
  )
23811 
 
23812 
  def __init__(self, orderIds=None,):
23813 
    self.orderIds = orderIds
23814 
 
23815 
  def read(self, iprot):
23816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23818 
      return
23819 
    iprot.readStructBegin()
23820 
    while True:
23821 
      (fname, ftype, fid) = iprot.readFieldBegin()
23822 
      if ftype == TType.STOP:
23823 
        break
23824 
      if fid == 1:
23825 
        if ftype == TType.LIST:
23826 
          self.orderIds = []
6188 rajveer 23827 
          (_etype573, _size570) = iprot.readListBegin()
23828 
          for _i574 in xrange(_size570):
23829 
            _elem575 = iprot.readI64();
23830 
            self.orderIds.append(_elem575)
4715 varun.gupt 23831 
          iprot.readListEnd()
23832 
        else:
23833 
          iprot.skip(ftype)
23834 
      else:
23835 
        iprot.skip(ftype)
23836 
      iprot.readFieldEnd()
23837 
    iprot.readStructEnd()
23838 
 
23839 
  def write(self, oprot):
23840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23842 
      return
23843 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23844 
    if self.orderIds is not None:
23845 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23846 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23847 
      for iter576 in self.orderIds:
23848 
        oprot.writeI64(iter576)
4715 varun.gupt 23849 
      oprot.writeListEnd()
23850 
      oprot.writeFieldEnd()
23851 
    oprot.writeFieldStop()
23852 
    oprot.writeStructEnd()
23853 
 
23854 
  def validate(self):
23855 
    return
23856 
 
23857 
 
23858 
  def __repr__(self):
23859 
    L = ['%s=%r' % (key, value)
23860 
      for key, value in self.__dict__.iteritems()]
23861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23862 
 
23863 
  def __eq__(self, other):
23864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23865 
 
23866 
  def __ne__(self, other):
23867 
    return not (self == other)
23868 
 
23869 
class getReshippedOrderIds_result:
23870 
  """
23871 
  Attributes:
23872 
   - success
23873 
   - ex
23874 
  """
23875 
 
23876 
  thrift_spec = (
23877 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23879 
  )
23880 
 
23881 
  def __init__(self, success=None, ex=None,):
23882 
    self.success = success
23883 
    self.ex = ex
23884 
 
23885 
  def read(self, iprot):
23886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23888 
      return
23889 
    iprot.readStructBegin()
23890 
    while True:
23891 
      (fname, ftype, fid) = iprot.readFieldBegin()
23892 
      if ftype == TType.STOP:
23893 
        break
23894 
      if fid == 0:
23895 
        if ftype == TType.LIST:
23896 
          self.success = []
6188 rajveer 23897 
          (_etype580, _size577) = iprot.readListBegin()
23898 
          for _i581 in xrange(_size577):
23899 
            _elem582 = iprot.readI64();
23900 
            self.success.append(_elem582)
4715 varun.gupt 23901 
          iprot.readListEnd()
23902 
        else:
23903 
          iprot.skip(ftype)
23904 
      elif fid == 1:
23905 
        if ftype == TType.STRUCT:
23906 
          self.ex = TransactionServiceException()
23907 
          self.ex.read(iprot)
23908 
        else:
23909 
          iprot.skip(ftype)
23910 
      else:
23911 
        iprot.skip(ftype)
23912 
      iprot.readFieldEnd()
23913 
    iprot.readStructEnd()
23914 
 
23915 
  def write(self, oprot):
23916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23918 
      return
23919 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23920 
    if self.success is not None:
23921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23922 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 23923 
      for iter583 in self.success:
23924 
        oprot.writeI64(iter583)
4715 varun.gupt 23925 
      oprot.writeListEnd()
23926 
      oprot.writeFieldEnd()
23927 
    if self.ex is not None:
23928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23929 
      self.ex.write(oprot)
23930 
      oprot.writeFieldEnd()
23931 
    oprot.writeFieldStop()
23932 
    oprot.writeStructEnd()
23933 
 
23934 
  def validate(self):
23935 
    return
23936 
 
23937 
 
23938 
  def __repr__(self):
23939 
    L = ['%s=%r' % (key, value)
23940 
      for key, value in self.__dict__.iteritems()]
23941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23942 
 
23943 
  def __eq__(self, other):
23944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23945 
 
23946 
  def __ne__(self, other):
23947 
    return not (self == other)
4757 mandeep.dh 23948 
 
5481 phani.kuma 23949 
class getBilledOrders_args:
4875 varun.gupt 23950 
  """
23951 
  Attributes:
23952 
   - vendorId
5481 phani.kuma 23953 
   - onlyVendorNotPaid
23954 
   - billingDateFrom
23955 
   - billingDateTo
4875 varun.gupt 23956 
  """
23957 
 
23958 
  thrift_spec = (
23959 
    None, # 0
23960 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23961 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23962 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23963 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23964 
  )
23965 
 
5481 phani.kuma 23966 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23967 
    self.vendorId = vendorId
5481 phani.kuma 23968 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23969 
    self.billingDateFrom = billingDateFrom
23970 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23971 
 
23972 
  def read(self, iprot):
23973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23975 
      return
23976 
    iprot.readStructBegin()
23977 
    while True:
23978 
      (fname, ftype, fid) = iprot.readFieldBegin()
23979 
      if ftype == TType.STOP:
23980 
        break
23981 
      if fid == 1:
23982 
        if ftype == TType.I64:
23983 
          self.vendorId = iprot.readI64();
23984 
        else:
23985 
          iprot.skip(ftype)
5481 phani.kuma 23986 
      elif fid == 2:
23987 
        if ftype == TType.BOOL:
23988 
          self.onlyVendorNotPaid = iprot.readBool();
23989 
        else:
23990 
          iprot.skip(ftype)
23991 
      elif fid == 3:
23992 
        if ftype == TType.I64:
23993 
          self.billingDateFrom = iprot.readI64();
23994 
        else:
23995 
          iprot.skip(ftype)
23996 
      elif fid == 4:
23997 
        if ftype == TType.I64:
23998 
          self.billingDateTo = iprot.readI64();
23999 
        else:
24000 
          iprot.skip(ftype)
4875 varun.gupt 24001 
      else:
24002 
        iprot.skip(ftype)
24003 
      iprot.readFieldEnd()
24004 
    iprot.readStructEnd()
24005 
 
24006 
  def write(self, oprot):
24007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24009 
      return
5481 phani.kuma 24010 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24011 
    if self.vendorId is not None:
24012 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24013 
      oprot.writeI64(self.vendorId)
24014 
      oprot.writeFieldEnd()
5481 phani.kuma 24015 
    if self.onlyVendorNotPaid is not None:
24016 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24017 
      oprot.writeBool(self.onlyVendorNotPaid)
24018 
      oprot.writeFieldEnd()
24019 
    if self.billingDateFrom is not None:
24020 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24021 
      oprot.writeI64(self.billingDateFrom)
24022 
      oprot.writeFieldEnd()
24023 
    if self.billingDateTo is not None:
24024 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24025 
      oprot.writeI64(self.billingDateTo)
24026 
      oprot.writeFieldEnd()
4875 varun.gupt 24027 
    oprot.writeFieldStop()
24028 
    oprot.writeStructEnd()
24029 
 
24030 
  def validate(self):
24031 
    return
24032 
 
24033 
 
24034 
  def __repr__(self):
24035 
    L = ['%s=%r' % (key, value)
24036 
      for key, value in self.__dict__.iteritems()]
24037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24038 
 
24039 
  def __eq__(self, other):
24040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24041 
 
24042 
  def __ne__(self, other):
24043 
    return not (self == other)
24044 
 
5481 phani.kuma 24045 
class getBilledOrders_result:
4875 varun.gupt 24046 
  """
24047 
  Attributes:
24048 
   - success
24049 
   - ex
24050 
  """
24051 
 
24052 
  thrift_spec = (
24053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24055 
  )
24056 
 
24057 
  def __init__(self, success=None, ex=None,):
24058 
    self.success = success
24059 
    self.ex = ex
24060 
 
24061 
  def read(self, iprot):
24062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24064 
      return
24065 
    iprot.readStructBegin()
24066 
    while True:
24067 
      (fname, ftype, fid) = iprot.readFieldBegin()
24068 
      if ftype == TType.STOP:
24069 
        break
24070 
      if fid == 0:
24071 
        if ftype == TType.LIST:
24072 
          self.success = []
6188 rajveer 24073 
          (_etype587, _size584) = iprot.readListBegin()
24074 
          for _i588 in xrange(_size584):
24075 
            _elem589 = Order()
24076 
            _elem589.read(iprot)
24077 
            self.success.append(_elem589)
4875 varun.gupt 24078 
          iprot.readListEnd()
24079 
        else:
24080 
          iprot.skip(ftype)
24081 
      elif fid == 1:
24082 
        if ftype == TType.STRUCT:
24083 
          self.ex = TransactionServiceException()
24084 
          self.ex.read(iprot)
24085 
        else:
24086 
          iprot.skip(ftype)
24087 
      else:
24088 
        iprot.skip(ftype)
24089 
      iprot.readFieldEnd()
24090 
    iprot.readStructEnd()
24091 
 
24092 
  def write(self, oprot):
24093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24095 
      return
5481 phani.kuma 24096 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24097 
    if self.success is not None:
24098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24100 
      for iter590 in self.success:
24101 
        iter590.write(oprot)
4875 varun.gupt 24102 
      oprot.writeListEnd()
24103 
      oprot.writeFieldEnd()
24104 
    if self.ex is not None:
24105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24106 
      self.ex.write(oprot)
24107 
      oprot.writeFieldEnd()
24108 
    oprot.writeFieldStop()
24109 
    oprot.writeStructEnd()
24110 
 
24111 
  def validate(self):
24112 
    return
24113 
 
24114 
 
24115 
  def __repr__(self):
24116 
    L = ['%s=%r' % (key, value)
24117 
      for key, value in self.__dict__.iteritems()]
24118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24119 
 
24120 
  def __eq__(self, other):
24121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24122 
 
24123 
  def __ne__(self, other):
24124 
    return not (self == other)
5031 varun.gupt 24125 
 
24126 
class getStatusDistributionOfOrders_args:
24127 
  """
24128 
  Attributes:
24129 
   - startDate
24130 
   - endDate
24131 
  """
24132 
 
24133 
  thrift_spec = (
24134 
    None, # 0
24135 
    (1, TType.I64, 'startDate', None, None, ), # 1
24136 
    (2, TType.I64, 'endDate', None, None, ), # 2
24137 
  )
24138 
 
24139 
  def __init__(self, startDate=None, endDate=None,):
24140 
    self.startDate = startDate
24141 
    self.endDate = endDate
24142 
 
24143 
  def read(self, iprot):
24144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24146 
      return
24147 
    iprot.readStructBegin()
24148 
    while True:
24149 
      (fname, ftype, fid) = iprot.readFieldBegin()
24150 
      if ftype == TType.STOP:
24151 
        break
24152 
      if fid == 1:
24153 
        if ftype == TType.I64:
24154 
          self.startDate = iprot.readI64();
24155 
        else:
24156 
          iprot.skip(ftype)
24157 
      elif fid == 2:
24158 
        if ftype == TType.I64:
24159 
          self.endDate = iprot.readI64();
24160 
        else:
24161 
          iprot.skip(ftype)
24162 
      else:
24163 
        iprot.skip(ftype)
24164 
      iprot.readFieldEnd()
24165 
    iprot.readStructEnd()
24166 
 
24167 
  def write(self, oprot):
24168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24170 
      return
24171 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24172 
    if self.startDate is not None:
24173 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24174 
      oprot.writeI64(self.startDate)
24175 
      oprot.writeFieldEnd()
24176 
    if self.endDate is not None:
24177 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24178 
      oprot.writeI64(self.endDate)
24179 
      oprot.writeFieldEnd()
24180 
    oprot.writeFieldStop()
24181 
    oprot.writeStructEnd()
24182 
 
24183 
  def validate(self):
24184 
    return
24185 
 
24186 
 
24187 
  def __repr__(self):
24188 
    L = ['%s=%r' % (key, value)
24189 
      for key, value in self.__dict__.iteritems()]
24190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24191 
 
24192 
  def __eq__(self, other):
24193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24194 
 
24195 
  def __ne__(self, other):
24196 
    return not (self == other)
24197 
 
24198 
class getStatusDistributionOfOrders_result:
24199 
  """
24200 
  Attributes:
24201 
   - success
24202 
   - ex
24203 
  """
24204 
 
24205 
  thrift_spec = (
24206 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24207 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24208 
  )
24209 
 
24210 
  def __init__(self, success=None, ex=None,):
24211 
    self.success = success
24212 
    self.ex = ex
24213 
 
24214 
  def read(self, iprot):
24215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24217 
      return
24218 
    iprot.readStructBegin()
24219 
    while True:
24220 
      (fname, ftype, fid) = iprot.readFieldBegin()
24221 
      if ftype == TType.STOP:
24222 
        break
24223 
      if fid == 0:
24224 
        if ftype == TType.MAP:
24225 
          self.success = {}
6188 rajveer 24226 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24227 
          for _i595 in xrange(_size591):
24228 
            _key596 = iprot.readI64();
24229 
            _val597 = iprot.readI64();
24230 
            self.success[_key596] = _val597
5031 varun.gupt 24231 
          iprot.readMapEnd()
24232 
        else:
24233 
          iprot.skip(ftype)
24234 
      elif fid == 1:
24235 
        if ftype == TType.STRUCT:
24236 
          self.ex = TransactionServiceException()
24237 
          self.ex.read(iprot)
24238 
        else:
24239 
          iprot.skip(ftype)
24240 
      else:
24241 
        iprot.skip(ftype)
24242 
      iprot.readFieldEnd()
24243 
    iprot.readStructEnd()
24244 
 
24245 
  def write(self, oprot):
24246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24248 
      return
24249 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24250 
    if self.success is not None:
24251 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24252 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24253 
      for kiter598,viter599 in self.success.items():
24254 
        oprot.writeI64(kiter598)
24255 
        oprot.writeI64(viter599)
5031 varun.gupt 24256 
      oprot.writeMapEnd()
24257 
      oprot.writeFieldEnd()
24258 
    if self.ex is not None:
24259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24260 
      self.ex.write(oprot)
24261 
      oprot.writeFieldEnd()
24262 
    oprot.writeFieldStop()
24263 
    oprot.writeStructEnd()
24264 
 
24265 
  def validate(self):
24266 
    return
24267 
 
24268 
 
24269 
  def __repr__(self):
24270 
    L = ['%s=%r' % (key, value)
24271 
      for key, value in self.__dict__.iteritems()]
24272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24273 
 
24274 
  def __eq__(self, other):
24275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24276 
 
24277 
  def __ne__(self, other):
24278 
    return not (self == other)
5067 varun.gupt 24279 
 
24280 
class getOrderIdsForStatus_args:
24281 
  """
24282 
  Attributes:
24283 
   - status
24284 
   - startDatetime
24285 
   - endDatetime
24286 
  """
24287 
 
24288 
  thrift_spec = (
24289 
    None, # 0
24290 
    (1, TType.I64, 'status', None, None, ), # 1
24291 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24292 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24293 
  )
24294 
 
24295 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24296 
    self.status = status
24297 
    self.startDatetime = startDatetime
24298 
    self.endDatetime = endDatetime
24299 
 
24300 
  def read(self, iprot):
24301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24303 
      return
24304 
    iprot.readStructBegin()
24305 
    while True:
24306 
      (fname, ftype, fid) = iprot.readFieldBegin()
24307 
      if ftype == TType.STOP:
24308 
        break
24309 
      if fid == 1:
24310 
        if ftype == TType.I64:
24311 
          self.status = iprot.readI64();
24312 
        else:
24313 
          iprot.skip(ftype)
24314 
      elif fid == 2:
24315 
        if ftype == TType.I64:
24316 
          self.startDatetime = iprot.readI64();
24317 
        else:
24318 
          iprot.skip(ftype)
24319 
      elif fid == 3:
24320 
        if ftype == TType.I64:
24321 
          self.endDatetime = iprot.readI64();
24322 
        else:
24323 
          iprot.skip(ftype)
24324 
      else:
24325 
        iprot.skip(ftype)
24326 
      iprot.readFieldEnd()
24327 
    iprot.readStructEnd()
24328 
 
24329 
  def write(self, oprot):
24330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24332 
      return
24333 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24334 
    if self.status is not None:
24335 
      oprot.writeFieldBegin('status', TType.I64, 1)
24336 
      oprot.writeI64(self.status)
24337 
      oprot.writeFieldEnd()
24338 
    if self.startDatetime is not None:
24339 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24340 
      oprot.writeI64(self.startDatetime)
24341 
      oprot.writeFieldEnd()
24342 
    if self.endDatetime is not None:
24343 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24344 
      oprot.writeI64(self.endDatetime)
24345 
      oprot.writeFieldEnd()
24346 
    oprot.writeFieldStop()
24347 
    oprot.writeStructEnd()
24348 
 
24349 
  def validate(self):
24350 
    return
24351 
 
24352 
 
24353 
  def __repr__(self):
24354 
    L = ['%s=%r' % (key, value)
24355 
      for key, value in self.__dict__.iteritems()]
24356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24357 
 
24358 
  def __eq__(self, other):
24359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24360 
 
24361 
  def __ne__(self, other):
24362 
    return not (self == other)
24363 
 
24364 
class getOrderIdsForStatus_result:
24365 
  """
24366 
  Attributes:
24367 
   - success
24368 
   - ex
24369 
  """
24370 
 
24371 
  thrift_spec = (
24372 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24374 
  )
24375 
 
24376 
  def __init__(self, success=None, ex=None,):
24377 
    self.success = success
24378 
    self.ex = ex
24379 
 
24380 
  def read(self, iprot):
24381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24383 
      return
24384 
    iprot.readStructBegin()
24385 
    while True:
24386 
      (fname, ftype, fid) = iprot.readFieldBegin()
24387 
      if ftype == TType.STOP:
24388 
        break
24389 
      if fid == 0:
24390 
        if ftype == TType.LIST:
24391 
          self.success = []
6188 rajveer 24392 
          (_etype603, _size600) = iprot.readListBegin()
24393 
          for _i604 in xrange(_size600):
24394 
            _elem605 = iprot.readI64();
24395 
            self.success.append(_elem605)
5067 varun.gupt 24396 
          iprot.readListEnd()
24397 
        else:
24398 
          iprot.skip(ftype)
24399 
      elif fid == 1:
24400 
        if ftype == TType.STRUCT:
24401 
          self.ex = TransactionServiceException()
24402 
          self.ex.read(iprot)
24403 
        else:
24404 
          iprot.skip(ftype)
24405 
      else:
24406 
        iprot.skip(ftype)
24407 
      iprot.readFieldEnd()
24408 
    iprot.readStructEnd()
24409 
 
24410 
  def write(self, oprot):
24411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24413 
      return
24414 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24415 
    if self.success is not None:
24416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24417 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24418 
      for iter606 in self.success:
24419 
        oprot.writeI64(iter606)
5067 varun.gupt 24420 
      oprot.writeListEnd()
24421 
      oprot.writeFieldEnd()
24422 
    if self.ex is not None:
24423 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24424 
      self.ex.write(oprot)
24425 
      oprot.writeFieldEnd()
24426 
    oprot.writeFieldStop()
24427 
    oprot.writeStructEnd()
24428 
 
24429 
  def validate(self):
24430 
    return
24431 
 
24432 
 
24433 
  def __repr__(self):
24434 
    L = ['%s=%r' % (key, value)
24435 
      for key, value in self.__dict__.iteritems()]
24436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24437 
 
24438 
  def __eq__(self, other):
24439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24440 
 
24441 
  def __ne__(self, other):
24442 
    return not (self == other)
5099 varun.gupt 24443 
 
5348 anupam.sin 24444 
class updateCODAgent_args:
24445 
  """
24446 
  Attributes:
24447 
   - agent
24448 
   - orderId
24449 
  """
24450 
 
24451 
  thrift_spec = (
24452 
    None, # 0
24453 
    (1, TType.STRING, 'agent', None, None, ), # 1
24454 
    (2, TType.I64, 'orderId', None, None, ), # 2
24455 
  )
24456 
 
24457 
  def __init__(self, agent=None, orderId=None,):
24458 
    self.agent = agent
24459 
    self.orderId = orderId
24460 
 
24461 
  def read(self, iprot):
24462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24464 
      return
24465 
    iprot.readStructBegin()
24466 
    while True:
24467 
      (fname, ftype, fid) = iprot.readFieldBegin()
24468 
      if ftype == TType.STOP:
24469 
        break
24470 
      if fid == 1:
24471 
        if ftype == TType.STRING:
24472 
          self.agent = iprot.readString();
24473 
        else:
24474 
          iprot.skip(ftype)
24475 
      elif fid == 2:
24476 
        if ftype == TType.I64:
24477 
          self.orderId = iprot.readI64();
24478 
        else:
24479 
          iprot.skip(ftype)
24480 
      else:
24481 
        iprot.skip(ftype)
24482 
      iprot.readFieldEnd()
24483 
    iprot.readStructEnd()
24484 
 
24485 
  def write(self, oprot):
24486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24488 
      return
24489 
    oprot.writeStructBegin('updateCODAgent_args')
24490 
    if self.agent is not None:
24491 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24492 
      oprot.writeString(self.agent)
24493 
      oprot.writeFieldEnd()
24494 
    if self.orderId is not None:
24495 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24496 
      oprot.writeI64(self.orderId)
24497 
      oprot.writeFieldEnd()
24498 
    oprot.writeFieldStop()
24499 
    oprot.writeStructEnd()
24500 
 
24501 
  def validate(self):
24502 
    return
24503 
 
24504 
 
24505 
  def __repr__(self):
24506 
    L = ['%s=%r' % (key, value)
24507 
      for key, value in self.__dict__.iteritems()]
24508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24509 
 
24510 
  def __eq__(self, other):
24511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24512 
 
24513 
  def __ne__(self, other):
24514 
    return not (self == other)
24515 
 
24516 
class updateCODAgent_result:
24517 
  """
24518 
  Attributes:
24519 
   - ex
24520 
  """
24521 
 
24522 
  thrift_spec = (
24523 
    None, # 0
24524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24525 
  )
24526 
 
24527 
  def __init__(self, ex=None,):
24528 
    self.ex = ex
24529 
 
24530 
  def read(self, iprot):
24531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24533 
      return
24534 
    iprot.readStructBegin()
24535 
    while True:
24536 
      (fname, ftype, fid) = iprot.readFieldBegin()
24537 
      if ftype == TType.STOP:
24538 
        break
24539 
      if fid == 1:
24540 
        if ftype == TType.STRUCT:
24541 
          self.ex = TransactionServiceException()
24542 
          self.ex.read(iprot)
24543 
        else:
24544 
          iprot.skip(ftype)
24545 
      else:
24546 
        iprot.skip(ftype)
24547 
      iprot.readFieldEnd()
24548 
    iprot.readStructEnd()
24549 
 
24550 
  def write(self, oprot):
24551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24553 
      return
24554 
    oprot.writeStructBegin('updateCODAgent_result')
24555 
    if self.ex is not None:
24556 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24557 
      self.ex.write(oprot)
24558 
      oprot.writeFieldEnd()
24559 
    oprot.writeFieldStop()
24560 
    oprot.writeStructEnd()
24561 
 
24562 
  def validate(self):
24563 
    return
24564 
 
24565 
 
24566 
  def __repr__(self):
24567 
    L = ['%s=%r' % (key, value)
24568 
      for key, value in self.__dict__.iteritems()]
24569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24570 
 
24571 
  def __eq__(self, other):
24572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24573 
 
24574 
  def __ne__(self, other):
24575 
    return not (self == other)
24576 
 
5099 varun.gupt 24577 
class updateOrderAsPaidToVendor_args:
24578 
  """
24579 
  Attributes:
24580 
   - orderId
24581 
  """
24582 
 
24583 
  thrift_spec = (
24584 
    None, # 0
24585 
    (1, TType.I64, 'orderId', None, None, ), # 1
24586 
  )
24587 
 
24588 
  def __init__(self, orderId=None,):
24589 
    self.orderId = orderId
24590 
 
24591 
  def read(self, iprot):
24592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24594 
      return
24595 
    iprot.readStructBegin()
24596 
    while True:
24597 
      (fname, ftype, fid) = iprot.readFieldBegin()
24598 
      if ftype == TType.STOP:
24599 
        break
24600 
      if fid == 1:
24601 
        if ftype == TType.I64:
24602 
          self.orderId = iprot.readI64();
24603 
        else:
24604 
          iprot.skip(ftype)
24605 
      else:
24606 
        iprot.skip(ftype)
24607 
      iprot.readFieldEnd()
24608 
    iprot.readStructEnd()
24609 
 
24610 
  def write(self, oprot):
24611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24613 
      return
24614 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24615 
    if self.orderId is not None:
24616 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24617 
      oprot.writeI64(self.orderId)
24618 
      oprot.writeFieldEnd()
24619 
    oprot.writeFieldStop()
24620 
    oprot.writeStructEnd()
24621 
 
24622 
  def validate(self):
24623 
    return
24624 
 
24625 
 
24626 
  def __repr__(self):
24627 
    L = ['%s=%r' % (key, value)
24628 
      for key, value in self.__dict__.iteritems()]
24629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24630 
 
24631 
  def __eq__(self, other):
24632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24633 
 
24634 
  def __ne__(self, other):
24635 
    return not (self == other)
24636 
 
24637 
class updateOrderAsPaidToVendor_result:
24638 
  """
24639 
  Attributes:
24640 
   - ex
24641 
  """
24642 
 
24643 
  thrift_spec = (
24644 
    None, # 0
24645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24646 
  )
24647 
 
24648 
  def __init__(self, ex=None,):
24649 
    self.ex = ex
24650 
 
24651 
  def read(self, iprot):
24652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24654 
      return
24655 
    iprot.readStructBegin()
24656 
    while True:
24657 
      (fname, ftype, fid) = iprot.readFieldBegin()
24658 
      if ftype == TType.STOP:
24659 
        break
24660 
      if fid == 1:
24661 
        if ftype == TType.STRUCT:
24662 
          self.ex = TransactionServiceException()
24663 
          self.ex.read(iprot)
24664 
        else:
24665 
          iprot.skip(ftype)
24666 
      else:
24667 
        iprot.skip(ftype)
24668 
      iprot.readFieldEnd()
24669 
    iprot.readStructEnd()
24670 
 
24671 
  def write(self, oprot):
24672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24674 
      return
24675 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24676 
    if self.ex is not None:
24677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24678 
      self.ex.write(oprot)
24679 
      oprot.writeFieldEnd()
24680 
    oprot.writeFieldStop()
24681 
    oprot.writeStructEnd()
24682 
 
24683 
  def validate(self):
24684 
    return
24685 
 
24686 
 
24687 
  def __repr__(self):
24688 
    L = ['%s=%r' % (key, value)
24689 
      for key, value in self.__dict__.iteritems()]
24690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24691 
 
24692 
  def __eq__(self, other):
24693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24694 
 
24695 
  def __ne__(self, other):
24696 
    return not (self == other)
5208 varun.gupt 24697 
 
5386 phani.kuma 24698 
class updateOrderOnlyAsPaidToVendor_args:
24699 
  """
24700 
  Attributes:
24701 
   - orderId
24702 
  """
24703 
 
24704 
  thrift_spec = (
24705 
    None, # 0
24706 
    (1, TType.I64, 'orderId', None, None, ), # 1
24707 
  )
24708 
 
24709 
  def __init__(self, orderId=None,):
24710 
    self.orderId = orderId
24711 
 
24712 
  def read(self, iprot):
24713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24715 
      return
24716 
    iprot.readStructBegin()
24717 
    while True:
24718 
      (fname, ftype, fid) = iprot.readFieldBegin()
24719 
      if ftype == TType.STOP:
24720 
        break
24721 
      if fid == 1:
24722 
        if ftype == TType.I64:
24723 
          self.orderId = iprot.readI64();
24724 
        else:
24725 
          iprot.skip(ftype)
24726 
      else:
24727 
        iprot.skip(ftype)
24728 
      iprot.readFieldEnd()
24729 
    iprot.readStructEnd()
24730 
 
24731 
  def write(self, oprot):
24732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24734 
      return
24735 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24736 
    if self.orderId is not None:
24737 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24738 
      oprot.writeI64(self.orderId)
24739 
      oprot.writeFieldEnd()
24740 
    oprot.writeFieldStop()
24741 
    oprot.writeStructEnd()
24742 
 
24743 
  def validate(self):
24744 
    return
24745 
 
24746 
 
24747 
  def __repr__(self):
24748 
    L = ['%s=%r' % (key, value)
24749 
      for key, value in self.__dict__.iteritems()]
24750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24751 
 
24752 
  def __eq__(self, other):
24753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24754 
 
24755 
  def __ne__(self, other):
24756 
    return not (self == other)
24757 
 
24758 
class updateOrderOnlyAsPaidToVendor_result:
24759 
  """
24760 
  Attributes:
24761 
   - ex
24762 
  """
24763 
 
24764 
  thrift_spec = (
24765 
    None, # 0
24766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24767 
  )
24768 
 
24769 
  def __init__(self, ex=None,):
24770 
    self.ex = ex
24771 
 
24772 
  def read(self, iprot):
24773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24775 
      return
24776 
    iprot.readStructBegin()
24777 
    while True:
24778 
      (fname, ftype, fid) = iprot.readFieldBegin()
24779 
      if ftype == TType.STOP:
24780 
        break
24781 
      if fid == 1:
24782 
        if ftype == TType.STRUCT:
24783 
          self.ex = TransactionServiceException()
24784 
          self.ex.read(iprot)
24785 
        else:
24786 
          iprot.skip(ftype)
24787 
      else:
24788 
        iprot.skip(ftype)
24789 
      iprot.readFieldEnd()
24790 
    iprot.readStructEnd()
24791 
 
24792 
  def write(self, oprot):
24793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24795 
      return
24796 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24797 
    if self.ex is not None:
24798 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24799 
      self.ex.write(oprot)
24800 
      oprot.writeFieldEnd()
24801 
    oprot.writeFieldStop()
24802 
    oprot.writeStructEnd()
24803 
 
24804 
  def validate(self):
24805 
    return
24806 
 
24807 
 
24808 
  def __repr__(self):
24809 
    L = ['%s=%r' % (key, value)
24810 
      for key, value in self.__dict__.iteritems()]
24811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24812 
 
24813 
  def __eq__(self, other):
24814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24815 
 
24816 
  def __ne__(self, other):
24817 
    return not (self == other)
24818 
 
5208 varun.gupt 24819 
class getRefundedOrdersMarkedPaid_args:
24820 
 
24821 
  thrift_spec = (
24822 
  )
24823 
 
24824 
  def read(self, iprot):
24825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24827 
      return
24828 
    iprot.readStructBegin()
24829 
    while True:
24830 
      (fname, ftype, fid) = iprot.readFieldBegin()
24831 
      if ftype == TType.STOP:
24832 
        break
24833 
      else:
24834 
        iprot.skip(ftype)
24835 
      iprot.readFieldEnd()
24836 
    iprot.readStructEnd()
24837 
 
24838 
  def write(self, oprot):
24839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24841 
      return
24842 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24843 
    oprot.writeFieldStop()
24844 
    oprot.writeStructEnd()
24845 
 
24846 
  def validate(self):
24847 
    return
24848 
 
24849 
 
24850 
  def __repr__(self):
24851 
    L = ['%s=%r' % (key, value)
24852 
      for key, value in self.__dict__.iteritems()]
24853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24854 
 
24855 
  def __eq__(self, other):
24856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24857 
 
24858 
  def __ne__(self, other):
24859 
    return not (self == other)
24860 
 
24861 
class getRefundedOrdersMarkedPaid_result:
24862 
  """
24863 
  Attributes:
24864 
   - success
24865 
   - ex
24866 
  """
24867 
 
24868 
  thrift_spec = (
24869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24871 
  )
24872 
 
24873 
  def __init__(self, success=None, ex=None,):
24874 
    self.success = success
24875 
    self.ex = ex
24876 
 
24877 
  def read(self, iprot):
24878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24880 
      return
24881 
    iprot.readStructBegin()
24882 
    while True:
24883 
      (fname, ftype, fid) = iprot.readFieldBegin()
24884 
      if ftype == TType.STOP:
24885 
        break
24886 
      if fid == 0:
24887 
        if ftype == TType.LIST:
24888 
          self.success = []
6188 rajveer 24889 
          (_etype610, _size607) = iprot.readListBegin()
24890 
          for _i611 in xrange(_size607):
24891 
            _elem612 = Order()
24892 
            _elem612.read(iprot)
24893 
            self.success.append(_elem612)
5208 varun.gupt 24894 
          iprot.readListEnd()
24895 
        else:
24896 
          iprot.skip(ftype)
24897 
      elif fid == 1:
24898 
        if ftype == TType.STRUCT:
24899 
          self.ex = TransactionServiceException()
24900 
          self.ex.read(iprot)
24901 
        else:
24902 
          iprot.skip(ftype)
24903 
      else:
24904 
        iprot.skip(ftype)
24905 
      iprot.readFieldEnd()
24906 
    iprot.readStructEnd()
24907 
 
24908 
  def write(self, oprot):
24909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24911 
      return
24912 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24913 
    if self.success is not None:
24914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24916 
      for iter613 in self.success:
24917 
        iter613.write(oprot)
5208 varun.gupt 24918 
      oprot.writeListEnd()
24919 
      oprot.writeFieldEnd()
24920 
    if self.ex is not None:
24921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24922 
      self.ex.write(oprot)
24923 
      oprot.writeFieldEnd()
24924 
    oprot.writeFieldStop()
24925 
    oprot.writeStructEnd()
24926 
 
24927 
  def validate(self):
24928 
    return
24929 
 
24930 
 
24931 
  def __repr__(self):
24932 
    L = ['%s=%r' % (key, value)
24933 
      for key, value in self.__dict__.iteritems()]
24934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24935 
 
24936 
  def __eq__(self, other):
24937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24938 
 
24939 
  def __ne__(self, other):
24940 
    return not (self == other)
5447 anupam.sin 24941 
 
24942 
class getAllVerificationAgents_args:
24943 
  """
24944 
  Attributes:
24945 
   - minOrderId
24946 
   - maxOrderId
24947 
  """
24948 
 
24949 
  thrift_spec = (
24950 
    None, # 0
24951 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24952 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24953 
  )
24954 
 
24955 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24956 
    self.minOrderId = minOrderId
24957 
    self.maxOrderId = maxOrderId
24958 
 
24959 
  def read(self, iprot):
24960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24962 
      return
24963 
    iprot.readStructBegin()
24964 
    while True:
24965 
      (fname, ftype, fid) = iprot.readFieldBegin()
24966 
      if ftype == TType.STOP:
24967 
        break
24968 
      if fid == 1:
24969 
        if ftype == TType.I64:
24970 
          self.minOrderId = iprot.readI64();
24971 
        else:
24972 
          iprot.skip(ftype)
24973 
      elif fid == 2:
24974 
        if ftype == TType.I64:
24975 
          self.maxOrderId = iprot.readI64();
24976 
        else:
24977 
          iprot.skip(ftype)
24978 
      else:
24979 
        iprot.skip(ftype)
24980 
      iprot.readFieldEnd()
24981 
    iprot.readStructEnd()
24982 
 
24983 
  def write(self, oprot):
24984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24986 
      return
24987 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24988 
    if self.minOrderId is not None:
24989 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24990 
      oprot.writeI64(self.minOrderId)
24991 
      oprot.writeFieldEnd()
24992 
    if self.maxOrderId is not None:
24993 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24994 
      oprot.writeI64(self.maxOrderId)
24995 
      oprot.writeFieldEnd()
24996 
    oprot.writeFieldStop()
24997 
    oprot.writeStructEnd()
24998 
 
24999 
  def validate(self):
25000 
    return
25001 
 
25002 
 
25003 
  def __repr__(self):
25004 
    L = ['%s=%r' % (key, value)
25005 
      for key, value in self.__dict__.iteritems()]
25006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25007 
 
25008 
  def __eq__(self, other):
25009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25010 
 
25011 
  def __ne__(self, other):
25012 
    return not (self == other)
25013 
 
25014 
class getAllVerificationAgents_result:
25015 
  """
25016 
  Attributes:
25017 
   - success
25018 
  """
25019 
 
25020 
  thrift_spec = (
25021 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25022 
  )
25023 
 
25024 
  def __init__(self, success=None,):
25025 
    self.success = success
25026 
 
25027 
  def read(self, iprot):
25028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25030 
      return
25031 
    iprot.readStructBegin()
25032 
    while True:
25033 
      (fname, ftype, fid) = iprot.readFieldBegin()
25034 
      if ftype == TType.STOP:
25035 
        break
25036 
      if fid == 0:
25037 
        if ftype == TType.LIST:
25038 
          self.success = []
6188 rajveer 25039 
          (_etype617, _size614) = iprot.readListBegin()
25040 
          for _i618 in xrange(_size614):
25041 
            _elem619 = CODVerificationAgent()
25042 
            _elem619.read(iprot)
25043 
            self.success.append(_elem619)
5447 anupam.sin 25044 
          iprot.readListEnd()
25045 
        else:
25046 
          iprot.skip(ftype)
25047 
      else:
25048 
        iprot.skip(ftype)
25049 
      iprot.readFieldEnd()
25050 
    iprot.readStructEnd()
25051 
 
25052 
  def write(self, oprot):
25053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25055 
      return
25056 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25057 
    if self.success is not None:
25058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25060 
      for iter620 in self.success:
25061 
        iter620.write(oprot)
5447 anupam.sin 25062 
      oprot.writeListEnd()
25063 
      oprot.writeFieldEnd()
25064 
    oprot.writeFieldStop()
25065 
    oprot.writeStructEnd()
25066 
 
25067 
  def validate(self):
25068 
    return
25069 
 
25070 
 
25071 
  def __repr__(self):
25072 
    L = ['%s=%r' % (key, value)
25073 
      for key, value in self.__dict__.iteritems()]
25074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25075 
 
25076 
  def __eq__(self, other):
25077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25078 
 
25079 
  def __ne__(self, other):
25080 
    return not (self == other)
5527 anupam.sin 25081 
 
25082 
class getAllAttributesForOrderId_args:
25083 
  """
25084 
  Attributes:
25085 
   - orderId
25086 
  """
25087 
 
25088 
  thrift_spec = (
25089 
    None, # 0
25090 
    (1, TType.I64, 'orderId', None, None, ), # 1
25091 
  )
25092 
 
25093 
  def __init__(self, orderId=None,):
25094 
    self.orderId = orderId
25095 
 
25096 
  def read(self, iprot):
25097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25099 
      return
25100 
    iprot.readStructBegin()
25101 
    while True:
25102 
      (fname, ftype, fid) = iprot.readFieldBegin()
25103 
      if ftype == TType.STOP:
25104 
        break
25105 
      if fid == 1:
25106 
        if ftype == TType.I64:
25107 
          self.orderId = iprot.readI64();
25108 
        else:
25109 
          iprot.skip(ftype)
25110 
      else:
25111 
        iprot.skip(ftype)
25112 
      iprot.readFieldEnd()
25113 
    iprot.readStructEnd()
25114 
 
25115 
  def write(self, oprot):
25116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25118 
      return
25119 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25120 
    if self.orderId is not None:
25121 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25122 
      oprot.writeI64(self.orderId)
25123 
      oprot.writeFieldEnd()
25124 
    oprot.writeFieldStop()
25125 
    oprot.writeStructEnd()
25126 
 
25127 
  def validate(self):
25128 
    return
25129 
 
25130 
 
25131 
  def __repr__(self):
25132 
    L = ['%s=%r' % (key, value)
25133 
      for key, value in self.__dict__.iteritems()]
25134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25135 
 
25136 
  def __eq__(self, other):
25137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25138 
 
25139 
  def __ne__(self, other):
25140 
    return not (self == other)
25141 
 
25142 
class getAllAttributesForOrderId_result:
25143 
  """
25144 
  Attributes:
25145 
   - success
25146 
  """
25147 
 
25148 
  thrift_spec = (
25149 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25150 
  )
25151 
 
25152 
  def __init__(self, success=None,):
25153 
    self.success = success
25154 
 
25155 
  def read(self, iprot):
25156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25158 
      return
25159 
    iprot.readStructBegin()
25160 
    while True:
25161 
      (fname, ftype, fid) = iprot.readFieldBegin()
25162 
      if ftype == TType.STOP:
25163 
        break
25164 
      if fid == 0:
25165 
        if ftype == TType.LIST:
25166 
          self.success = []
6188 rajveer 25167 
          (_etype624, _size621) = iprot.readListBegin()
25168 
          for _i625 in xrange(_size621):
25169 
            _elem626 = Attribute()
25170 
            _elem626.read(iprot)
25171 
            self.success.append(_elem626)
5527 anupam.sin 25172 
          iprot.readListEnd()
25173 
        else:
25174 
          iprot.skip(ftype)
25175 
      else:
25176 
        iprot.skip(ftype)
25177 
      iprot.readFieldEnd()
25178 
    iprot.readStructEnd()
25179 
 
25180 
  def write(self, oprot):
25181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25183 
      return
25184 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25185 
    if self.success is not None:
25186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25188 
      for iter627 in self.success:
25189 
        iter627.write(oprot)
5527 anupam.sin 25190 
      oprot.writeListEnd()
25191 
      oprot.writeFieldEnd()
25192 
    oprot.writeFieldStop()
25193 
    oprot.writeStructEnd()
25194 
 
25195 
  def validate(self):
25196 
    return
25197 
 
25198 
 
25199 
  def __repr__(self):
25200 
    L = ['%s=%r' % (key, value)
25201 
      for key, value in self.__dict__.iteritems()]
25202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25203 
 
25204 
  def __eq__(self, other):
25205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25206 
 
25207 
  def __ne__(self, other):
25208 
    return not (self == other)
25209 
 
5676 rajveer 25210 
class setOrderAttributes_args:
25211 
  """
25212 
  Attributes:
25213 
   - orderId
25214 
   - attributes
25215 
  """
25216 
 
25217 
  thrift_spec = None
25218 
  def __init__(self, orderId=None, attributes=None,):
25219 
    self.orderId = orderId
25220 
    self.attributes = attributes
25221 
 
25222 
  def read(self, iprot):
25223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25225 
      return
25226 
    iprot.readStructBegin()
25227 
    while True:
25228 
      (fname, ftype, fid) = iprot.readFieldBegin()
25229 
      if ftype == TType.STOP:
25230 
        break
25231 
      if fid == 1:
25232 
        if ftype == TType.I64:
25233 
          self.orderId = iprot.readI64();
25234 
        else:
25235 
          iprot.skip(ftype)
25236 
      elif fid == -1:
25237 
        if ftype == TType.LIST:
25238 
          self.attributes = []
6188 rajveer 25239 
          (_etype631, _size628) = iprot.readListBegin()
25240 
          for _i632 in xrange(_size628):
25241 
            _elem633 = Attribute()
25242 
            _elem633.read(iprot)
25243 
            self.attributes.append(_elem633)
5676 rajveer 25244 
          iprot.readListEnd()
25245 
        else:
25246 
          iprot.skip(ftype)
25247 
      else:
25248 
        iprot.skip(ftype)
25249 
      iprot.readFieldEnd()
25250 
    iprot.readStructEnd()
25251 
 
25252 
  def write(self, oprot):
25253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25255 
      return
25256 
    oprot.writeStructBegin('setOrderAttributes_args')
25257 
    if self.attributes is not None:
25258 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25259 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25260 
      for iter634 in self.attributes:
25261 
        iter634.write(oprot)
5676 rajveer 25262 
      oprot.writeListEnd()
25263 
      oprot.writeFieldEnd()
25264 
    if self.orderId is not None:
25265 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25266 
      oprot.writeI64(self.orderId)
25267 
      oprot.writeFieldEnd()
25268 
    oprot.writeFieldStop()
25269 
    oprot.writeStructEnd()
25270 
 
25271 
  def validate(self):
25272 
    return
25273 
 
25274 
 
25275 
  def __repr__(self):
25276 
    L = ['%s=%r' % (key, value)
25277 
      for key, value in self.__dict__.iteritems()]
25278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25279 
 
25280 
  def __eq__(self, other):
25281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25282 
 
25283 
  def __ne__(self, other):
25284 
    return not (self == other)
25285 
 
25286 
class setOrderAttributes_result:
25287 
 
25288 
  thrift_spec = (
25289 
  )
25290 
 
25291 
  def read(self, iprot):
25292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25294 
      return
25295 
    iprot.readStructBegin()
25296 
    while True:
25297 
      (fname, ftype, fid) = iprot.readFieldBegin()
25298 
      if ftype == TType.STOP:
25299 
        break
25300 
      else:
25301 
        iprot.skip(ftype)
25302 
      iprot.readFieldEnd()
25303 
    iprot.readStructEnd()
25304 
 
25305 
  def write(self, oprot):
25306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25308 
      return
25309 
    oprot.writeStructBegin('setOrderAttributes_result')
25310 
    oprot.writeFieldStop()
25311 
    oprot.writeStructEnd()
25312 
 
25313 
  def validate(self):
25314 
    return
25315 
 
25316 
 
25317 
  def __repr__(self):
25318 
    L = ['%s=%r' % (key, value)
25319 
      for key, value in self.__dict__.iteritems()]
25320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25321 
 
25322 
  def __eq__(self, other):
25323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25324 
 
25325 
  def __ne__(self, other):
25326 
    return not (self == other)
25327 
 
5527 anupam.sin 25328 
class setOrderAttributeForTransaction_args:
25329 
  """
25330 
  Attributes:
25331 
   - transactionId
25332 
   - attribute
25333 
  """
25334 
 
25335 
  thrift_spec = None
25336 
  def __init__(self, transactionId=None, attribute=None,):
25337 
    self.transactionId = transactionId
25338 
    self.attribute = attribute
25339 
 
25340 
  def read(self, iprot):
25341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25343 
      return
25344 
    iprot.readStructBegin()
25345 
    while True:
25346 
      (fname, ftype, fid) = iprot.readFieldBegin()
25347 
      if ftype == TType.STOP:
25348 
        break
25349 
      if fid == 1:
25350 
        if ftype == TType.I64:
25351 
          self.transactionId = iprot.readI64();
25352 
        else:
25353 
          iprot.skip(ftype)
25354 
      elif fid == -1:
25355 
        if ftype == TType.STRUCT:
25356 
          self.attribute = Attribute()
25357 
          self.attribute.read(iprot)
25358 
        else:
25359 
          iprot.skip(ftype)
25360 
      else:
25361 
        iprot.skip(ftype)
25362 
      iprot.readFieldEnd()
25363 
    iprot.readStructEnd()
25364 
 
25365 
  def write(self, oprot):
25366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25368 
      return
25369 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25370 
    if self.attribute is not None:
25371 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25372 
      self.attribute.write(oprot)
25373 
      oprot.writeFieldEnd()
25374 
    if self.transactionId is not None:
25375 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25376 
      oprot.writeI64(self.transactionId)
25377 
      oprot.writeFieldEnd()
25378 
    oprot.writeFieldStop()
25379 
    oprot.writeStructEnd()
25380 
 
25381 
  def validate(self):
25382 
    return
25383 
 
25384 
 
25385 
  def __repr__(self):
25386 
    L = ['%s=%r' % (key, value)
25387 
      for key, value in self.__dict__.iteritems()]
25388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25389 
 
25390 
  def __eq__(self, other):
25391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25392 
 
25393 
  def __ne__(self, other):
25394 
    return not (self == other)
25395 
 
25396 
class setOrderAttributeForTransaction_result:
25397 
 
25398 
  thrift_spec = (
25399 
  )
25400 
 
25401 
  def read(self, iprot):
25402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25404 
      return
25405 
    iprot.readStructBegin()
25406 
    while True:
25407 
      (fname, ftype, fid) = iprot.readFieldBegin()
25408 
      if ftype == TType.STOP:
25409 
        break
25410 
      else:
25411 
        iprot.skip(ftype)
25412 
      iprot.readFieldEnd()
25413 
    iprot.readStructEnd()
25414 
 
25415 
  def write(self, oprot):
25416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25418 
      return
25419 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25420 
    oprot.writeFieldStop()
25421 
    oprot.writeStructEnd()
25422 
 
25423 
  def validate(self):
25424 
    return
25425 
 
25426 
 
25427 
  def __repr__(self):
25428 
    L = ['%s=%r' % (key, value)
25429 
      for key, value in self.__dict__.iteritems()]
25430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25431 
 
25432 
  def __eq__(self, other):
25433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25434 
 
25435 
  def __ne__(self, other):
25436 
    return not (self == other)
5553 rajveer 25437 
 
25438 
class getReceivePendingOrders_args:
25439 
  """
25440 
  Attributes:
25441 
   - storeId
25442 
  """
25443 
 
25444 
  thrift_spec = (
25445 
    None, # 0
25446 
    (1, TType.I64, 'storeId', None, None, ), # 1
25447 
  )
25448 
 
25449 
  def __init__(self, storeId=None,):
25450 
    self.storeId = storeId
25451 
 
25452 
  def read(self, iprot):
25453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25455 
      return
25456 
    iprot.readStructBegin()
25457 
    while True:
25458 
      (fname, ftype, fid) = iprot.readFieldBegin()
25459 
      if ftype == TType.STOP:
25460 
        break
25461 
      if fid == 1:
25462 
        if ftype == TType.I64:
25463 
          self.storeId = iprot.readI64();
25464 
        else:
25465 
          iprot.skip(ftype)
25466 
      else:
25467 
        iprot.skip(ftype)
25468 
      iprot.readFieldEnd()
25469 
    iprot.readStructEnd()
25470 
 
25471 
  def write(self, oprot):
25472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25474 
      return
25475 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25476 
    if self.storeId is not None:
25477 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25478 
      oprot.writeI64(self.storeId)
25479 
      oprot.writeFieldEnd()
25480 
    oprot.writeFieldStop()
25481 
    oprot.writeStructEnd()
25482 
 
25483 
  def validate(self):
25484 
    return
25485 
 
25486 
 
25487 
  def __repr__(self):
25488 
    L = ['%s=%r' % (key, value)
25489 
      for key, value in self.__dict__.iteritems()]
25490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25491 
 
25492 
  def __eq__(self, other):
25493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25494 
 
25495 
  def __ne__(self, other):
25496 
    return not (self == other)
25497 
 
25498 
class getReceivePendingOrders_result:
25499 
  """
25500 
  Attributes:
25501 
   - success
25502 
  """
25503 
 
25504 
  thrift_spec = (
25505 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25506 
  )
25507 
 
25508 
  def __init__(self, success=None,):
25509 
    self.success = success
25510 
 
25511 
  def read(self, iprot):
25512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25514 
      return
25515 
    iprot.readStructBegin()
25516 
    while True:
25517 
      (fname, ftype, fid) = iprot.readFieldBegin()
25518 
      if ftype == TType.STOP:
25519 
        break
25520 
      if fid == 0:
25521 
        if ftype == TType.LIST:
25522 
          self.success = []
6188 rajveer 25523 
          (_etype638, _size635) = iprot.readListBegin()
25524 
          for _i639 in xrange(_size635):
25525 
            _elem640 = Order()
25526 
            _elem640.read(iprot)
25527 
            self.success.append(_elem640)
5553 rajveer 25528 
          iprot.readListEnd()
25529 
        else:
25530 
          iprot.skip(ftype)
25531 
      else:
25532 
        iprot.skip(ftype)
25533 
      iprot.readFieldEnd()
25534 
    iprot.readStructEnd()
25535 
 
25536 
  def write(self, oprot):
25537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25539 
      return
25540 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25541 
    if self.success is not None:
25542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25544 
      for iter641 in self.success:
25545 
        iter641.write(oprot)
5553 rajveer 25546 
      oprot.writeListEnd()
25547 
      oprot.writeFieldEnd()
25548 
    oprot.writeFieldStop()
25549 
    oprot.writeStructEnd()
25550 
 
25551 
  def validate(self):
25552 
    return
25553 
 
25554 
 
25555 
  def __repr__(self):
25556 
    L = ['%s=%r' % (key, value)
25557 
      for key, value in self.__dict__.iteritems()]
25558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25559 
 
25560 
  def __eq__(self, other):
25561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25562 
 
25563 
  def __ne__(self, other):
25564 
    return not (self == other)
25565 
 
25566 
class getReceivedAtStoreOrders_args:
25567 
  """
25568 
  Attributes:
25569 
   - storeId
25570 
  """
25571 
 
25572 
  thrift_spec = (
25573 
    None, # 0
25574 
    (1, TType.I64, 'storeId', None, None, ), # 1
25575 
  )
25576 
 
25577 
  def __init__(self, storeId=None,):
25578 
    self.storeId = storeId
25579 
 
25580 
  def read(self, iprot):
25581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25583 
      return
25584 
    iprot.readStructBegin()
25585 
    while True:
25586 
      (fname, ftype, fid) = iprot.readFieldBegin()
25587 
      if ftype == TType.STOP:
25588 
        break
25589 
      if fid == 1:
25590 
        if ftype == TType.I64:
25591 
          self.storeId = iprot.readI64();
25592 
        else:
25593 
          iprot.skip(ftype)
25594 
      else:
25595 
        iprot.skip(ftype)
25596 
      iprot.readFieldEnd()
25597 
    iprot.readStructEnd()
25598 
 
25599 
  def write(self, oprot):
25600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25602 
      return
25603 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25604 
    if self.storeId is not None:
25605 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25606 
      oprot.writeI64(self.storeId)
25607 
      oprot.writeFieldEnd()
25608 
    oprot.writeFieldStop()
25609 
    oprot.writeStructEnd()
25610 
 
25611 
  def validate(self):
25612 
    return
25613 
 
25614 
 
25615 
  def __repr__(self):
25616 
    L = ['%s=%r' % (key, value)
25617 
      for key, value in self.__dict__.iteritems()]
25618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25619 
 
25620 
  def __eq__(self, other):
25621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25622 
 
25623 
  def __ne__(self, other):
25624 
    return not (self == other)
25625 
 
25626 
class getReceivedAtStoreOrders_result:
25627 
  """
25628 
  Attributes:
25629 
   - success
25630 
  """
25631 
 
25632 
  thrift_spec = (
25633 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25634 
  )
25635 
 
25636 
  def __init__(self, success=None,):
25637 
    self.success = success
25638 
 
25639 
  def read(self, iprot):
25640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25642 
      return
25643 
    iprot.readStructBegin()
25644 
    while True:
25645 
      (fname, ftype, fid) = iprot.readFieldBegin()
25646 
      if ftype == TType.STOP:
25647 
        break
25648 
      if fid == 0:
25649 
        if ftype == TType.LIST:
25650 
          self.success = []
6188 rajveer 25651 
          (_etype645, _size642) = iprot.readListBegin()
25652 
          for _i646 in xrange(_size642):
25653 
            _elem647 = Order()
25654 
            _elem647.read(iprot)
25655 
            self.success.append(_elem647)
5553 rajveer 25656 
          iprot.readListEnd()
25657 
        else:
25658 
          iprot.skip(ftype)
25659 
      else:
25660 
        iprot.skip(ftype)
25661 
      iprot.readFieldEnd()
25662 
    iprot.readStructEnd()
25663 
 
25664 
  def write(self, oprot):
25665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25667 
      return
25668 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25669 
    if self.success is not None:
25670 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25671 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25672 
      for iter648 in self.success:
25673 
        iter648.write(oprot)
5553 rajveer 25674 
      oprot.writeListEnd()
25675 
      oprot.writeFieldEnd()
25676 
    oprot.writeFieldStop()
25677 
    oprot.writeStructEnd()
25678 
 
25679 
  def validate(self):
25680 
    return
25681 
 
25682 
 
25683 
  def __repr__(self):
25684 
    L = ['%s=%r' % (key, value)
25685 
      for key, value in self.__dict__.iteritems()]
25686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25687 
 
25688 
  def __eq__(self, other):
25689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25690 
 
25691 
  def __ne__(self, other):
25692 
    return not (self == other)
5593 mandeep.dh 25693 
 
5713 rajveer 25694 
class getOrdersCollectionAtStore_args:
25695 
  """
25696 
  Attributes:
25697 
   - storeId
25698 
   - fromDate
25699 
   - toDate
25700 
   - onlyCod
25701 
  """
25702 
 
25703 
  thrift_spec = (
25704 
    None, # 0
25705 
    (1, TType.I64, 'storeId', None, None, ), # 1
25706 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25707 
    (3, TType.I64, 'toDate', None, None, ), # 3
25708 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25709 
  )
25710 
 
25711 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25712 
    self.storeId = storeId
25713 
    self.fromDate = fromDate
25714 
    self.toDate = toDate
25715 
    self.onlyCod = onlyCod
25716 
 
25717 
  def read(self, iprot):
25718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25720 
      return
25721 
    iprot.readStructBegin()
25722 
    while True:
25723 
      (fname, ftype, fid) = iprot.readFieldBegin()
25724 
      if ftype == TType.STOP:
25725 
        break
25726 
      if fid == 1:
25727 
        if ftype == TType.I64:
25728 
          self.storeId = iprot.readI64();
25729 
        else:
25730 
          iprot.skip(ftype)
25731 
      elif fid == 2:
25732 
        if ftype == TType.I64:
25733 
          self.fromDate = iprot.readI64();
25734 
        else:
25735 
          iprot.skip(ftype)
25736 
      elif fid == 3:
25737 
        if ftype == TType.I64:
25738 
          self.toDate = iprot.readI64();
25739 
        else:
25740 
          iprot.skip(ftype)
25741 
      elif fid == 4:
25742 
        if ftype == TType.BOOL:
25743 
          self.onlyCod = iprot.readBool();
25744 
        else:
25745 
          iprot.skip(ftype)
25746 
      else:
25747 
        iprot.skip(ftype)
25748 
      iprot.readFieldEnd()
25749 
    iprot.readStructEnd()
25750 
 
25751 
  def write(self, oprot):
25752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25754 
      return
25755 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25756 
    if self.storeId is not None:
25757 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25758 
      oprot.writeI64(self.storeId)
25759 
      oprot.writeFieldEnd()
25760 
    if self.fromDate is not None:
25761 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25762 
      oprot.writeI64(self.fromDate)
25763 
      oprot.writeFieldEnd()
25764 
    if self.toDate is not None:
25765 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25766 
      oprot.writeI64(self.toDate)
25767 
      oprot.writeFieldEnd()
25768 
    if self.onlyCod is not None:
25769 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25770 
      oprot.writeBool(self.onlyCod)
25771 
      oprot.writeFieldEnd()
25772 
    oprot.writeFieldStop()
25773 
    oprot.writeStructEnd()
25774 
 
25775 
  def validate(self):
25776 
    return
25777 
 
25778 
 
25779 
  def __repr__(self):
25780 
    L = ['%s=%r' % (key, value)
25781 
      for key, value in self.__dict__.iteritems()]
25782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25783 
 
25784 
  def __eq__(self, other):
25785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25786 
 
25787 
  def __ne__(self, other):
25788 
    return not (self == other)
25789 
 
25790 
class getOrdersCollectionAtStore_result:
25791 
  """
25792 
  Attributes:
25793 
   - success
25794 
  """
25795 
 
25796 
  thrift_spec = (
25797 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25798 
  )
25799 
 
25800 
  def __init__(self, success=None,):
25801 
    self.success = success
25802 
 
25803 
  def read(self, iprot):
25804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25806 
      return
25807 
    iprot.readStructBegin()
25808 
    while True:
25809 
      (fname, ftype, fid) = iprot.readFieldBegin()
25810 
      if ftype == TType.STOP:
25811 
        break
25812 
      if fid == 0:
25813 
        if ftype == TType.LIST:
25814 
          self.success = []
6188 rajveer 25815 
          (_etype652, _size649) = iprot.readListBegin()
25816 
          for _i653 in xrange(_size649):
25817 
            _elem654 = Order()
25818 
            _elem654.read(iprot)
25819 
            self.success.append(_elem654)
5713 rajveer 25820 
          iprot.readListEnd()
25821 
        else:
25822 
          iprot.skip(ftype)
25823 
      else:
25824 
        iprot.skip(ftype)
25825 
      iprot.readFieldEnd()
25826 
    iprot.readStructEnd()
25827 
 
25828 
  def write(self, oprot):
25829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25831 
      return
25832 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25833 
    if self.success is not None:
25834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25836 
      for iter655 in self.success:
25837 
        iter655.write(oprot)
5713 rajveer 25838 
      oprot.writeListEnd()
25839 
      oprot.writeFieldEnd()
25840 
    oprot.writeFieldStop()
25841 
    oprot.writeStructEnd()
25842 
 
25843 
  def validate(self):
25844 
    return
25845 
 
25846 
 
25847 
  def __repr__(self):
25848 
    L = ['%s=%r' % (key, value)
25849 
      for key, value in self.__dict__.iteritems()]
25850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25851 
 
25852 
  def __eq__(self, other):
25853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25854 
 
25855 
  def __ne__(self, other):
25856 
    return not (self == other)
25857 
 
5833 rajveer 25858 
class getOrderAttributeValue_args:
25859 
  """
25860 
  Attributes:
25861 
   - orderId
25862 
   - attributeName
25863 
  """
25864 
 
25865 
  thrift_spec = None
25866 
  def __init__(self, orderId=None, attributeName=None,):
25867 
    self.orderId = orderId
25868 
    self.attributeName = attributeName
25869 
 
25870 
  def read(self, iprot):
25871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25873 
      return
25874 
    iprot.readStructBegin()
25875 
    while True:
25876 
      (fname, ftype, fid) = iprot.readFieldBegin()
25877 
      if ftype == TType.STOP:
25878 
        break
25879 
      if fid == 1:
25880 
        if ftype == TType.I64:
25881 
          self.orderId = iprot.readI64();
25882 
        else:
25883 
          iprot.skip(ftype)
25884 
      elif fid == -1:
25885 
        if ftype == TType.STRING:
25886 
          self.attributeName = iprot.readString();
25887 
        else:
25888 
          iprot.skip(ftype)
25889 
      else:
25890 
        iprot.skip(ftype)
25891 
      iprot.readFieldEnd()
25892 
    iprot.readStructEnd()
25893 
 
25894 
  def write(self, oprot):
25895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25897 
      return
25898 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25899 
    if self.attributeName is not None:
25900 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25901 
      oprot.writeString(self.attributeName)
25902 
      oprot.writeFieldEnd()
25903 
    if self.orderId is not None:
25904 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25905 
      oprot.writeI64(self.orderId)
25906 
      oprot.writeFieldEnd()
25907 
    oprot.writeFieldStop()
25908 
    oprot.writeStructEnd()
25909 
 
25910 
  def validate(self):
25911 
    return
25912 
 
25913 
 
25914 
  def __repr__(self):
25915 
    L = ['%s=%r' % (key, value)
25916 
      for key, value in self.__dict__.iteritems()]
25917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25918 
 
25919 
  def __eq__(self, other):
25920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25921 
 
25922 
  def __ne__(self, other):
25923 
    return not (self == other)
25924 
 
25925 
class getOrderAttributeValue_result:
25926 
  """
25927 
  Attributes:
25928 
   - success
25929 
  """
25930 
 
25931 
  thrift_spec = (
25932 
    (0, TType.STRING, 'success', None, None, ), # 0
25933 
  )
25934 
 
25935 
  def __init__(self, success=None,):
25936 
    self.success = success
25937 
 
25938 
  def read(self, iprot):
25939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25941 
      return
25942 
    iprot.readStructBegin()
25943 
    while True:
25944 
      (fname, ftype, fid) = iprot.readFieldBegin()
25945 
      if ftype == TType.STOP:
25946 
        break
25947 
      if fid == 0:
25948 
        if ftype == TType.STRING:
25949 
          self.success = iprot.readString();
25950 
        else:
25951 
          iprot.skip(ftype)
25952 
      else:
25953 
        iprot.skip(ftype)
25954 
      iprot.readFieldEnd()
25955 
    iprot.readStructEnd()
25956 
 
25957 
  def write(self, oprot):
25958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25960 
      return
25961 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25962 
    if self.success is not None:
25963 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25964 
      oprot.writeString(self.success)
25965 
      oprot.writeFieldEnd()
25966 
    oprot.writeFieldStop()
25967 
    oprot.writeStructEnd()
25968 
 
25969 
  def validate(self):
25970 
    return
25971 
 
25972 
 
25973 
  def __repr__(self):
25974 
    L = ['%s=%r' % (key, value)
25975 
      for key, value in self.__dict__.iteritems()]
25976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25977 
 
25978 
  def __eq__(self, other):
25979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25980 
 
25981 
  def __ne__(self, other):
25982 
    return not (self == other)
25983 
 
6019 rajveer 25984 
class changeJacketNumber_args:
25985 
  """
25986 
  Attributes:
25987 
   - orderId
25988 
   - jacketNumber
25989 
  """
25990 
 
25991 
  thrift_spec = (
25992 
    None, # 0
25993 
    (1, TType.I64, 'orderId', None, None, ), # 1
25994 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25995 
  )
25996 
 
25997 
  def __init__(self, orderId=None, jacketNumber=None,):
25998 
    self.orderId = orderId
25999 
    self.jacketNumber = jacketNumber
26000 
 
26001 
  def read(self, iprot):
26002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26004 
      return
26005 
    iprot.readStructBegin()
26006 
    while True:
26007 
      (fname, ftype, fid) = iprot.readFieldBegin()
26008 
      if ftype == TType.STOP:
26009 
        break
26010 
      if fid == 1:
26011 
        if ftype == TType.I64:
26012 
          self.orderId = iprot.readI64();
26013 
        else:
26014 
          iprot.skip(ftype)
26015 
      elif fid == 2:
26016 
        if ftype == TType.I64:
26017 
          self.jacketNumber = iprot.readI64();
26018 
        else:
26019 
          iprot.skip(ftype)
26020 
      else:
26021 
        iprot.skip(ftype)
26022 
      iprot.readFieldEnd()
26023 
    iprot.readStructEnd()
26024 
 
26025 
  def write(self, oprot):
26026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26028 
      return
26029 
    oprot.writeStructBegin('changeJacketNumber_args')
26030 
    if self.orderId is not None:
26031 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26032 
      oprot.writeI64(self.orderId)
26033 
      oprot.writeFieldEnd()
26034 
    if self.jacketNumber is not None:
26035 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26036 
      oprot.writeI64(self.jacketNumber)
26037 
      oprot.writeFieldEnd()
26038 
    oprot.writeFieldStop()
26039 
    oprot.writeStructEnd()
26040 
 
26041 
  def validate(self):
26042 
    return
26043 
 
26044 
 
26045 
  def __repr__(self):
26046 
    L = ['%s=%r' % (key, value)
26047 
      for key, value in self.__dict__.iteritems()]
26048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26049 
 
26050 
  def __eq__(self, other):
26051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26052 
 
26053 
  def __ne__(self, other):
26054 
    return not (self == other)
26055 
 
26056 
class changeJacketNumber_result:
26057 
  """
26058 
  Attributes:
26059 
   - success
26060 
  """
26061 
 
26062 
  thrift_spec = (
26063 
    (0, TType.BOOL, 'success', None, None, ), # 0
26064 
  )
26065 
 
26066 
  def __init__(self, success=None,):
26067 
    self.success = success
26068 
 
26069 
  def read(self, iprot):
26070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26072 
      return
26073 
    iprot.readStructBegin()
26074 
    while True:
26075 
      (fname, ftype, fid) = iprot.readFieldBegin()
26076 
      if ftype == TType.STOP:
26077 
        break
26078 
      if fid == 0:
26079 
        if ftype == TType.BOOL:
26080 
          self.success = iprot.readBool();
26081 
        else:
26082 
          iprot.skip(ftype)
26083 
      else:
26084 
        iprot.skip(ftype)
26085 
      iprot.readFieldEnd()
26086 
    iprot.readStructEnd()
26087 
 
26088 
  def write(self, oprot):
26089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26091 
      return
26092 
    oprot.writeStructBegin('changeJacketNumber_result')
26093 
    if self.success is not None:
26094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26095 
      oprot.writeBool(self.success)
26096 
      oprot.writeFieldEnd()
26097 
    oprot.writeFieldStop()
26098 
    oprot.writeStructEnd()
26099 
 
26100 
  def validate(self):
26101 
    return
26102 
 
26103 
 
26104 
  def __repr__(self):
26105 
    L = ['%s=%r' % (key, value)
26106 
      for key, value in self.__dict__.iteritems()]
26107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26108 
 
26109 
  def __eq__(self, other):
26110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26111 
 
26112 
  def __ne__(self, other):
26113 
    return not (self == other)
26114 
 
26115 
class markOrderAsRtoInTransit_args:
26116 
  """
26117 
  Attributes:
26118 
   - orderId
26119 
  """
26120 
 
26121 
  thrift_spec = (
26122 
    None, # 0
26123 
    (1, TType.I64, 'orderId', None, None, ), # 1
26124 
  )
26125 
 
26126 
  def __init__(self, orderId=None,):
26127 
    self.orderId = orderId
26128 
 
26129 
  def read(self, iprot):
26130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26132 
      return
26133 
    iprot.readStructBegin()
26134 
    while True:
26135 
      (fname, ftype, fid) = iprot.readFieldBegin()
26136 
      if ftype == TType.STOP:
26137 
        break
26138 
      if fid == 1:
26139 
        if ftype == TType.I64:
26140 
          self.orderId = iprot.readI64();
26141 
        else:
26142 
          iprot.skip(ftype)
26143 
      else:
26144 
        iprot.skip(ftype)
26145 
      iprot.readFieldEnd()
26146 
    iprot.readStructEnd()
26147 
 
26148 
  def write(self, oprot):
26149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26151 
      return
26152 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26153 
    if self.orderId is not None:
26154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26155 
      oprot.writeI64(self.orderId)
26156 
      oprot.writeFieldEnd()
26157 
    oprot.writeFieldStop()
26158 
    oprot.writeStructEnd()
26159 
 
26160 
  def validate(self):
26161 
    return
26162 
 
26163 
 
26164 
  def __repr__(self):
26165 
    L = ['%s=%r' % (key, value)
26166 
      for key, value in self.__dict__.iteritems()]
26167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26168 
 
26169 
  def __eq__(self, other):
26170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26171 
 
26172 
  def __ne__(self, other):
26173 
    return not (self == other)
26174 
 
26175 
class markOrderAsRtoInTransit_result:
26176 
  """
26177 
  Attributes:
26178 
   - success
26179 
  """
26180 
 
26181 
  thrift_spec = (
26182 
    (0, TType.BOOL, 'success', None, None, ), # 0
26183 
  )
26184 
 
26185 
  def __init__(self, success=None,):
26186 
    self.success = success
26187 
 
26188 
  def read(self, iprot):
26189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26191 
      return
26192 
    iprot.readStructBegin()
26193 
    while True:
26194 
      (fname, ftype, fid) = iprot.readFieldBegin()
26195 
      if ftype == TType.STOP:
26196 
        break
26197 
      if fid == 0:
26198 
        if ftype == TType.BOOL:
26199 
          self.success = iprot.readBool();
26200 
        else:
26201 
          iprot.skip(ftype)
26202 
      else:
26203 
        iprot.skip(ftype)
26204 
      iprot.readFieldEnd()
26205 
    iprot.readStructEnd()
26206 
 
26207 
  def write(self, oprot):
26208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26210 
      return
26211 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26212 
    if self.success is not None:
26213 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26214 
      oprot.writeBool(self.success)
26215 
      oprot.writeFieldEnd()
26216 
    oprot.writeFieldStop()
26217 
    oprot.writeStructEnd()
26218 
 
26219 
  def validate(self):
26220 
    return
26221 
 
26222 
 
26223 
  def __repr__(self):
26224 
    L = ['%s=%r' % (key, value)
26225 
      for key, value in self.__dict__.iteritems()]
26226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26227 
 
26228 
  def __eq__(self, other):
26229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26230 
 
26231 
  def __ne__(self, other):
26232 
    return not (self == other)
26233 
 
5593 mandeep.dh 26234 
class acceptOrderForItem_args:
26235 
  """
26236 
  Attributes:
26237 
   - itemId
26238 
   - quantity
26239 
   - fulfilmentWarehouseId
26240 
   - billingWarehouseId
26241 
  """
26242 
 
26243 
  thrift_spec = (
26244 
    None, # 0
26245 
    (1, TType.I64, 'itemId', None, None, ), # 1
26246 
    (2, TType.I64, 'quantity', None, None, ), # 2
26247 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26248 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26249 
  )
26250 
 
26251 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26252 
    self.itemId = itemId
26253 
    self.quantity = quantity
26254 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26255 
    self.billingWarehouseId = billingWarehouseId
26256 
 
26257 
  def read(self, iprot):
26258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26260 
      return
26261 
    iprot.readStructBegin()
26262 
    while True:
26263 
      (fname, ftype, fid) = iprot.readFieldBegin()
26264 
      if ftype == TType.STOP:
26265 
        break
26266 
      if fid == 1:
26267 
        if ftype == TType.I64:
26268 
          self.itemId = iprot.readI64();
26269 
        else:
26270 
          iprot.skip(ftype)
26271 
      elif fid == 2:
26272 
        if ftype == TType.I64:
26273 
          self.quantity = iprot.readI64();
26274 
        else:
26275 
          iprot.skip(ftype)
26276 
      elif fid == 3:
26277 
        if ftype == TType.I64:
26278 
          self.fulfilmentWarehouseId = iprot.readI64();
26279 
        else:
26280 
          iprot.skip(ftype)
26281 
      elif fid == 4:
26282 
        if ftype == TType.I64:
26283 
          self.billingWarehouseId = iprot.readI64();
26284 
        else:
26285 
          iprot.skip(ftype)
26286 
      else:
26287 
        iprot.skip(ftype)
26288 
      iprot.readFieldEnd()
26289 
    iprot.readStructEnd()
26290 
 
26291 
  def write(self, oprot):
26292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26294 
      return
26295 
    oprot.writeStructBegin('acceptOrderForItem_args')
26296 
    if self.itemId is not None:
26297 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26298 
      oprot.writeI64(self.itemId)
26299 
      oprot.writeFieldEnd()
26300 
    if self.quantity is not None:
26301 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26302 
      oprot.writeI64(self.quantity)
26303 
      oprot.writeFieldEnd()
26304 
    if self.fulfilmentWarehouseId is not None:
26305 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26306 
      oprot.writeI64(self.fulfilmentWarehouseId)
26307 
      oprot.writeFieldEnd()
26308 
    if self.billingWarehouseId is not None:
26309 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26310 
      oprot.writeI64(self.billingWarehouseId)
26311 
      oprot.writeFieldEnd()
26312 
    oprot.writeFieldStop()
26313 
    oprot.writeStructEnd()
26314 
 
26315 
  def validate(self):
26316 
    return
26317 
 
26318 
 
26319 
  def __repr__(self):
26320 
    L = ['%s=%r' % (key, value)
26321 
      for key, value in self.__dict__.iteritems()]
26322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26323 
 
26324 
  def __eq__(self, other):
26325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26326 
 
26327 
  def __ne__(self, other):
26328 
    return not (self == other)
26329 
 
26330 
class acceptOrderForItem_result:
26331 
 
26332 
  thrift_spec = (
26333 
  )
26334 
 
26335 
  def read(self, iprot):
26336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26338 
      return
26339 
    iprot.readStructBegin()
26340 
    while True:
26341 
      (fname, ftype, fid) = iprot.readFieldBegin()
26342 
      if ftype == TType.STOP:
26343 
        break
26344 
      else:
26345 
        iprot.skip(ftype)
26346 
      iprot.readFieldEnd()
26347 
    iprot.readStructEnd()
26348 
 
26349 
  def write(self, oprot):
26350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26352 
      return
26353 
    oprot.writeStructBegin('acceptOrderForItem_result')
26354 
    oprot.writeFieldStop()
26355 
    oprot.writeStructEnd()
26356 
 
26357 
  def validate(self):
26358 
    return
26359 
 
26360 
 
26361 
  def __repr__(self):
26362 
    L = ['%s=%r' % (key, value)
26363 
      for key, value in self.__dict__.iteritems()]
26364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26365 
 
26366 
  def __eq__(self, other):
26367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26368 
 
26369 
  def __ne__(self, other):
26370 
    return not (self == other)
6000 mandeep.dh 26371 
 
26372 
class createRechargeOrder_args:
26373 
  """
26374 
  Attributes:
26375 
   - rechargeOrder
26376 
  """
26377 
 
26378 
  thrift_spec = (
26379 
    None, # 0
26380 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26381 
  )
26382 
 
26383 
  def __init__(self, rechargeOrder=None,):
26384 
    self.rechargeOrder = rechargeOrder
26385 
 
26386 
  def read(self, iprot):
26387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26389 
      return
26390 
    iprot.readStructBegin()
26391 
    while True:
26392 
      (fname, ftype, fid) = iprot.readFieldBegin()
26393 
      if ftype == TType.STOP:
26394 
        break
26395 
      if fid == 1:
26396 
        if ftype == TType.STRUCT:
26397 
          self.rechargeOrder = RechargeOrder()
26398 
          self.rechargeOrder.read(iprot)
26399 
        else:
26400 
          iprot.skip(ftype)
26401 
      else:
26402 
        iprot.skip(ftype)
26403 
      iprot.readFieldEnd()
26404 
    iprot.readStructEnd()
26405 
 
26406 
  def write(self, oprot):
26407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26409 
      return
26410 
    oprot.writeStructBegin('createRechargeOrder_args')
26411 
    if self.rechargeOrder is not None:
26412 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26413 
      self.rechargeOrder.write(oprot)
26414 
      oprot.writeFieldEnd()
26415 
    oprot.writeFieldStop()
26416 
    oprot.writeStructEnd()
26417 
 
26418 
  def validate(self):
26419 
    return
26420 
 
26421 
 
26422 
  def __repr__(self):
26423 
    L = ['%s=%r' % (key, value)
26424 
      for key, value in self.__dict__.iteritems()]
26425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26426 
 
26427 
  def __eq__(self, other):
26428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26429 
 
26430 
  def __ne__(self, other):
26431 
    return not (self == other)
26432 
 
26433 
class createRechargeOrder_result:
26434 
  """
26435 
  Attributes:
26436 
   - success
26437 
   - ex
26438 
  """
26439 
 
26440 
  thrift_spec = (
26441 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26443 
  )
26444 
 
26445 
  def __init__(self, success=None, ex=None,):
26446 
    self.success = success
26447 
    self.ex = ex
26448 
 
26449 
  def read(self, iprot):
26450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26452 
      return
26453 
    iprot.readStructBegin()
26454 
    while True:
26455 
      (fname, ftype, fid) = iprot.readFieldBegin()
26456 
      if ftype == TType.STOP:
26457 
        break
26458 
      if fid == 0:
26459 
        if ftype == TType.STRUCT:
26460 
          self.success = RechargeOrder()
26461 
          self.success.read(iprot)
26462 
        else:
26463 
          iprot.skip(ftype)
26464 
      elif fid == 1:
26465 
        if ftype == TType.STRUCT:
26466 
          self.ex = TransactionServiceException()
26467 
          self.ex.read(iprot)
26468 
        else:
26469 
          iprot.skip(ftype)
26470 
      else:
26471 
        iprot.skip(ftype)
26472 
      iprot.readFieldEnd()
26473 
    iprot.readStructEnd()
26474 
 
26475 
  def write(self, oprot):
26476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26478 
      return
26479 
    oprot.writeStructBegin('createRechargeOrder_result')
26480 
    if self.success is not None:
26481 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26482 
      self.success.write(oprot)
26483 
      oprot.writeFieldEnd()
26484 
    if self.ex is not None:
26485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26486 
      self.ex.write(oprot)
26487 
      oprot.writeFieldEnd()
26488 
    oprot.writeFieldStop()
26489 
    oprot.writeStructEnd()
26490 
 
26491 
  def validate(self):
26492 
    return
26493 
 
26494 
 
26495 
  def __repr__(self):
26496 
    L = ['%s=%r' % (key, value)
26497 
      for key, value in self.__dict__.iteritems()]
26498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26499 
 
26500 
  def __eq__(self, other):
26501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26502 
 
26503 
  def __ne__(self, other):
26504 
    return not (self == other)
26505 
 
6031 rajveer 26506 
class getRechargeOrder_args:
26507 
  """
26508 
  Attributes:
26509 
   - rechargeRrderId
26510 
  """
26511 
 
26512 
  thrift_spec = (
26513 
    None, # 0
26514 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26515 
  )
26516 
 
26517 
  def __init__(self, rechargeRrderId=None,):
26518 
    self.rechargeRrderId = rechargeRrderId
26519 
 
26520 
  def read(self, iprot):
26521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26523 
      return
26524 
    iprot.readStructBegin()
26525 
    while True:
26526 
      (fname, ftype, fid) = iprot.readFieldBegin()
26527 
      if ftype == TType.STOP:
26528 
        break
26529 
      if fid == 1:
26530 
        if ftype == TType.I64:
26531 
          self.rechargeRrderId = iprot.readI64();
26532 
        else:
26533 
          iprot.skip(ftype)
26534 
      else:
26535 
        iprot.skip(ftype)
26536 
      iprot.readFieldEnd()
26537 
    iprot.readStructEnd()
26538 
 
26539 
  def write(self, oprot):
26540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26542 
      return
26543 
    oprot.writeStructBegin('getRechargeOrder_args')
26544 
    if self.rechargeRrderId is not None:
26545 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26546 
      oprot.writeI64(self.rechargeRrderId)
26547 
      oprot.writeFieldEnd()
26548 
    oprot.writeFieldStop()
26549 
    oprot.writeStructEnd()
26550 
 
26551 
  def validate(self):
26552 
    return
26553 
 
26554 
 
26555 
  def __repr__(self):
26556 
    L = ['%s=%r' % (key, value)
26557 
      for key, value in self.__dict__.iteritems()]
26558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26559 
 
26560 
  def __eq__(self, other):
26561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26562 
 
26563 
  def __ne__(self, other):
26564 
    return not (self == other)
26565 
 
26566 
class getRechargeOrder_result:
26567 
  """
26568 
  Attributes:
26569 
   - success
26570 
   - ex
26571 
  """
26572 
 
26573 
  thrift_spec = (
26574 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26575 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26576 
  )
26577 
 
26578 
  def __init__(self, success=None, ex=None,):
26579 
    self.success = success
26580 
    self.ex = ex
26581 
 
26582 
  def read(self, iprot):
26583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26585 
      return
26586 
    iprot.readStructBegin()
26587 
    while True:
26588 
      (fname, ftype, fid) = iprot.readFieldBegin()
26589 
      if ftype == TType.STOP:
26590 
        break
26591 
      if fid == 0:
26592 
        if ftype == TType.STRUCT:
26593 
          self.success = RechargeOrder()
26594 
          self.success.read(iprot)
26595 
        else:
26596 
          iprot.skip(ftype)
26597 
      elif fid == 1:
26598 
        if ftype == TType.STRUCT:
26599 
          self.ex = TransactionServiceException()
26600 
          self.ex.read(iprot)
26601 
        else:
26602 
          iprot.skip(ftype)
26603 
      else:
26604 
        iprot.skip(ftype)
26605 
      iprot.readFieldEnd()
26606 
    iprot.readStructEnd()
26607 
 
26608 
  def write(self, oprot):
26609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26611 
      return
26612 
    oprot.writeStructBegin('getRechargeOrder_result')
26613 
    if self.success is not None:
26614 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26615 
      self.success.write(oprot)
26616 
      oprot.writeFieldEnd()
26617 
    if self.ex is not None:
26618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26619 
      self.ex.write(oprot)
26620 
      oprot.writeFieldEnd()
26621 
    oprot.writeFieldStop()
26622 
    oprot.writeStructEnd()
26623 
 
26624 
  def validate(self):
26625 
    return
26626 
 
26627 
 
26628 
  def __repr__(self):
26629 
    L = ['%s=%r' % (key, value)
26630 
      for key, value in self.__dict__.iteritems()]
26631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26632 
 
26633 
  def __eq__(self, other):
26634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26635 
 
26636 
  def __ne__(self, other):
26637 
    return not (self == other)
26638 
 
26639 
class getRechargeOrders_args:
26640 
  """
26641 
  Attributes:
26642 
   - userId
26643 
  """
26644 
 
26645 
  thrift_spec = (
26646 
    None, # 0
26647 
    (1, TType.I64, 'userId', None, None, ), # 1
26648 
  )
26649 
 
26650 
  def __init__(self, userId=None,):
26651 
    self.userId = userId
26652 
 
26653 
  def read(self, iprot):
26654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26656 
      return
26657 
    iprot.readStructBegin()
26658 
    while True:
26659 
      (fname, ftype, fid) = iprot.readFieldBegin()
26660 
      if ftype == TType.STOP:
26661 
        break
26662 
      if fid == 1:
26663 
        if ftype == TType.I64:
26664 
          self.userId = iprot.readI64();
26665 
        else:
26666 
          iprot.skip(ftype)
26667 
      else:
26668 
        iprot.skip(ftype)
26669 
      iprot.readFieldEnd()
26670 
    iprot.readStructEnd()
26671 
 
26672 
  def write(self, oprot):
26673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26675 
      return
26676 
    oprot.writeStructBegin('getRechargeOrders_args')
26677 
    if self.userId is not None:
26678 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26679 
      oprot.writeI64(self.userId)
26680 
      oprot.writeFieldEnd()
26681 
    oprot.writeFieldStop()
26682 
    oprot.writeStructEnd()
26683 
 
26684 
  def validate(self):
26685 
    return
26686 
 
26687 
 
26688 
  def __repr__(self):
26689 
    L = ['%s=%r' % (key, value)
26690 
      for key, value in self.__dict__.iteritems()]
26691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26692 
 
26693 
  def __eq__(self, other):
26694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26695 
 
26696 
  def __ne__(self, other):
26697 
    return not (self == other)
26698 
 
26699 
class getRechargeOrders_result:
26700 
  """
26701 
  Attributes:
26702 
   - success
26703 
  """
26704 
 
26705 
  thrift_spec = (
26706 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26707 
  )
26708 
 
26709 
  def __init__(self, success=None,):
26710 
    self.success = success
26711 
 
26712 
  def read(self, iprot):
26713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26715 
      return
26716 
    iprot.readStructBegin()
26717 
    while True:
26718 
      (fname, ftype, fid) = iprot.readFieldBegin()
26719 
      if ftype == TType.STOP:
26720 
        break
26721 
      if fid == 0:
26722 
        if ftype == TType.LIST:
26723 
          self.success = []
6188 rajveer 26724 
          (_etype659, _size656) = iprot.readListBegin()
26725 
          for _i660 in xrange(_size656):
26726 
            _elem661 = RechargeOrder()
26727 
            _elem661.read(iprot)
26728 
            self.success.append(_elem661)
6031 rajveer 26729 
          iprot.readListEnd()
26730 
        else:
26731 
          iprot.skip(ftype)
26732 
      else:
26733 
        iprot.skip(ftype)
26734 
      iprot.readFieldEnd()
26735 
    iprot.readStructEnd()
26736 
 
26737 
  def write(self, oprot):
26738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26740 
      return
26741 
    oprot.writeStructBegin('getRechargeOrders_result')
26742 
    if self.success is not None:
26743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26745 
      for iter662 in self.success:
26746 
        iter662.write(oprot)
6031 rajveer 26747 
      oprot.writeListEnd()
26748 
      oprot.writeFieldEnd()
26749 
    oprot.writeFieldStop()
26750 
    oprot.writeStructEnd()
26751 
 
26752 
  def validate(self):
26753 
    return
26754 
 
26755 
 
26756 
  def __repr__(self):
26757 
    L = ['%s=%r' % (key, value)
26758 
      for key, value in self.__dict__.iteritems()]
26759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26760 
 
26761 
  def __eq__(self, other):
26762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26763 
 
26764 
  def __ne__(self, other):
26765 
    return not (self == other)
26766 
 
6000 mandeep.dh 26767 
class updateRechargeOrderStatus_args:
26768 
  """
26769 
  Attributes:
26770 
   - rechargeOrderId
26771 
   - rechargeOrderStatus
26772 
  """
26773 
 
26774 
  thrift_spec = (
26775 
    None, # 0
26776 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26777 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26778 
  )
26779 
 
26780 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26781 
    self.rechargeOrderId = rechargeOrderId
26782 
    self.rechargeOrderStatus = rechargeOrderStatus
26783 
 
26784 
  def read(self, iprot):
26785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26787 
      return
26788 
    iprot.readStructBegin()
26789 
    while True:
26790 
      (fname, ftype, fid) = iprot.readFieldBegin()
26791 
      if ftype == TType.STOP:
26792 
        break
26793 
      if fid == 1:
26794 
        if ftype == TType.I64:
26795 
          self.rechargeOrderId = iprot.readI64();
26796 
        else:
26797 
          iprot.skip(ftype)
26798 
      elif fid == 2:
26799 
        if ftype == TType.I32:
26800 
          self.rechargeOrderStatus = iprot.readI32();
26801 
        else:
26802 
          iprot.skip(ftype)
26803 
      else:
26804 
        iprot.skip(ftype)
26805 
      iprot.readFieldEnd()
26806 
    iprot.readStructEnd()
26807 
 
26808 
  def write(self, oprot):
26809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26811 
      return
26812 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26813 
    if self.rechargeOrderId is not None:
26814 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26815 
      oprot.writeI64(self.rechargeOrderId)
26816 
      oprot.writeFieldEnd()
26817 
    if self.rechargeOrderStatus is not None:
26818 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26819 
      oprot.writeI32(self.rechargeOrderStatus)
26820 
      oprot.writeFieldEnd()
26821 
    oprot.writeFieldStop()
26822 
    oprot.writeStructEnd()
26823 
 
26824 
  def validate(self):
26825 
    return
26826 
 
26827 
 
26828 
  def __repr__(self):
26829 
    L = ['%s=%r' % (key, value)
26830 
      for key, value in self.__dict__.iteritems()]
26831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26832 
 
26833 
  def __eq__(self, other):
26834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26835 
 
26836 
  def __ne__(self, other):
26837 
    return not (self == other)
26838 
 
26839 
class updateRechargeOrderStatus_result:
26840 
  """
26841 
  Attributes:
6031 rajveer 26842 
   - success
6000 mandeep.dh 26843 
   - ex
26844 
  """
26845 
 
26846 
  thrift_spec = (
6031 rajveer 26847 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26848 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26849 
  )
26850 
 
6031 rajveer 26851 
  def __init__(self, success=None, ex=None,):
26852 
    self.success = success
6000 mandeep.dh 26853 
    self.ex = ex
26854 
 
26855 
  def read(self, iprot):
26856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26858 
      return
26859 
    iprot.readStructBegin()
26860 
    while True:
26861 
      (fname, ftype, fid) = iprot.readFieldBegin()
26862 
      if ftype == TType.STOP:
26863 
        break
6031 rajveer 26864 
      if fid == 0:
26865 
        if ftype == TType.BOOL:
26866 
          self.success = iprot.readBool();
26867 
        else:
26868 
          iprot.skip(ftype)
26869 
      elif fid == 1:
6000 mandeep.dh 26870 
        if ftype == TType.STRUCT:
26871 
          self.ex = TransactionServiceException()
26872 
          self.ex.read(iprot)
26873 
        else:
26874 
          iprot.skip(ftype)
26875 
      else:
26876 
        iprot.skip(ftype)
26877 
      iprot.readFieldEnd()
26878 
    iprot.readStructEnd()
26879 
 
26880 
  def write(self, oprot):
26881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26883 
      return
26884 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26885 
    if self.success is not None:
26886 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26887 
      oprot.writeBool(self.success)
26888 
      oprot.writeFieldEnd()
6000 mandeep.dh 26889 
    if self.ex is not None:
26890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26891 
      self.ex.write(oprot)
26892 
      oprot.writeFieldEnd()
26893 
    oprot.writeFieldStop()
26894 
    oprot.writeStructEnd()
26895 
 
26896 
  def validate(self):
26897 
    return
26898 
 
26899 
 
26900 
  def __repr__(self):
26901 
    L = ['%s=%r' % (key, value)
26902 
      for key, value in self.__dict__.iteritems()]
26903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26904 
 
26905 
  def __eq__(self, other):
26906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26907 
 
26908 
  def __ne__(self, other):
26909 
    return not (self == other)
26910 
 
26911 
class activateRechargeTxn_args:
26912 
  """
26913 
  Attributes:
6031 rajveer 26914 
   - rechargeOrderId
6000 mandeep.dh 26915 
  """
26916 
 
26917 
  thrift_spec = (
26918 
    None, # 0
6031 rajveer 26919 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26920 
  )
26921 
 
6031 rajveer 26922 
  def __init__(self, rechargeOrderId=None,):
26923 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26924 
 
26925 
  def read(self, iprot):
26926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26928 
      return
26929 
    iprot.readStructBegin()
26930 
    while True:
26931 
      (fname, ftype, fid) = iprot.readFieldBegin()
26932 
      if ftype == TType.STOP:
26933 
        break
26934 
      if fid == 1:
6031 rajveer 26935 
        if ftype == TType.I64:
26936 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26937 
        else:
26938 
          iprot.skip(ftype)
26939 
      else:
26940 
        iprot.skip(ftype)
26941 
      iprot.readFieldEnd()
26942 
    iprot.readStructEnd()
26943 
 
26944 
  def write(self, oprot):
26945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26947 
      return
26948 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26949 
    if self.rechargeOrderId is not None:
26950 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26951 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26952 
      oprot.writeFieldEnd()
26953 
    oprot.writeFieldStop()
26954 
    oprot.writeStructEnd()
26955 
 
26956 
  def validate(self):
26957 
    return
26958 
 
26959 
 
26960 
  def __repr__(self):
26961 
    L = ['%s=%r' % (key, value)
26962 
      for key, value in self.__dict__.iteritems()]
26963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26964 
 
26965 
  def __eq__(self, other):
26966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26967 
 
26968 
  def __ne__(self, other):
26969 
    return not (self == other)
26970 
 
26971 
class activateRechargeTxn_result:
26972 
  """
26973 
  Attributes:
26974 
   - success
26975 
   - ex
26976 
  """
26977 
 
26978 
  thrift_spec = (
6031 rajveer 26979 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26980 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26981 
  )
26982 
 
26983 
  def __init__(self, success=None, ex=None,):
26984 
    self.success = success
26985 
    self.ex = ex
26986 
 
26987 
  def read(self, iprot):
26988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26990 
      return
26991 
    iprot.readStructBegin()
26992 
    while True:
26993 
      (fname, ftype, fid) = iprot.readFieldBegin()
26994 
      if ftype == TType.STOP:
26995 
        break
26996 
      if fid == 0:
6031 rajveer 26997 
        if ftype == TType.BOOL:
26998 
          self.success = iprot.readBool();
6000 mandeep.dh 26999 
        else:
27000 
          iprot.skip(ftype)
27001 
      elif fid == 1:
27002 
        if ftype == TType.STRUCT:
27003 
          self.ex = TransactionServiceException()
27004 
          self.ex.read(iprot)
27005 
        else:
27006 
          iprot.skip(ftype)
27007 
      else:
27008 
        iprot.skip(ftype)
27009 
      iprot.readFieldEnd()
27010 
    iprot.readStructEnd()
27011 
 
27012 
  def write(self, oprot):
27013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27015 
      return
27016 
    oprot.writeStructBegin('activateRechargeTxn_result')
27017 
    if self.success is not None:
6031 rajveer 27018 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27019 
      oprot.writeBool(self.success)
6000 mandeep.dh 27020 
      oprot.writeFieldEnd()
27021 
    if self.ex is not None:
27022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27023 
      self.ex.write(oprot)
27024 
      oprot.writeFieldEnd()
27025 
    oprot.writeFieldStop()
27026 
    oprot.writeStructEnd()
27027 
 
27028 
  def validate(self):
27029 
    return
27030 
 
27031 
 
27032 
  def __repr__(self):
27033 
    L = ['%s=%r' % (key, value)
27034 
      for key, value in self.__dict__.iteritems()]
27035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27036 
 
27037 
  def __eq__(self, other):
27038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27039 
 
27040 
  def __ne__(self, other):
27041 
    return not (self == other)
27042 
 
6031 rajveer 27043 
class getUserWallet_args:
6000 mandeep.dh 27044 
  """
27045 
  Attributes:
6031 rajveer 27046 
   - userId
6000 mandeep.dh 27047 
  """
27048 
 
27049 
  thrift_spec = (
27050 
    None, # 0
6031 rajveer 27051 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27052 
  )
27053 
 
6031 rajveer 27054 
  def __init__(self, userId=None,):
27055 
    self.userId = userId
6000 mandeep.dh 27056 
 
27057 
  def read(self, iprot):
27058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27060 
      return
27061 
    iprot.readStructBegin()
27062 
    while True:
27063 
      (fname, ftype, fid) = iprot.readFieldBegin()
27064 
      if ftype == TType.STOP:
27065 
        break
27066 
      if fid == 1:
27067 
        if ftype == TType.I64:
6031 rajveer 27068 
          self.userId = iprot.readI64();
6000 mandeep.dh 27069 
        else:
27070 
          iprot.skip(ftype)
27071 
      else:
27072 
        iprot.skip(ftype)
27073 
      iprot.readFieldEnd()
27074 
    iprot.readStructEnd()
27075 
 
27076 
  def write(self, oprot):
27077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27079 
      return
6031 rajveer 27080 
    oprot.writeStructBegin('getUserWallet_args')
27081 
    if self.userId is not None:
27082 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27083 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27084 
      oprot.writeFieldEnd()
27085 
    oprot.writeFieldStop()
27086 
    oprot.writeStructEnd()
27087 
 
27088 
  def validate(self):
27089 
    return
27090 
 
27091 
 
27092 
  def __repr__(self):
27093 
    L = ['%s=%r' % (key, value)
27094 
      for key, value in self.__dict__.iteritems()]
27095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27096 
 
27097 
  def __eq__(self, other):
27098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27099 
 
27100 
  def __ne__(self, other):
27101 
    return not (self == other)
27102 
 
6031 rajveer 27103 
class getUserWallet_result:
6000 mandeep.dh 27104 
  """
27105 
  Attributes:
27106 
   - success
27107 
  """
27108 
 
27109 
  thrift_spec = (
6031 rajveer 27110 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27111 
  )
27112 
 
27113 
  def __init__(self, success=None,):
27114 
    self.success = success
27115 
 
27116 
  def read(self, iprot):
27117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27119 
      return
27120 
    iprot.readStructBegin()
27121 
    while True:
27122 
      (fname, ftype, fid) = iprot.readFieldBegin()
27123 
      if ftype == TType.STOP:
27124 
        break
27125 
      if fid == 0:
6031 rajveer 27126 
        if ftype == TType.STRUCT:
27127 
          self.success = UserWallet()
27128 
          self.success.read(iprot)
6000 mandeep.dh 27129 
        else:
27130 
          iprot.skip(ftype)
27131 
      else:
27132 
        iprot.skip(ftype)
27133 
      iprot.readFieldEnd()
27134 
    iprot.readStructEnd()
27135 
 
27136 
  def write(self, oprot):
27137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27139 
      return
6031 rajveer 27140 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27141 
    if self.success is not None:
6031 rajveer 27142 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27143 
      self.success.write(oprot)
6000 mandeep.dh 27144 
      oprot.writeFieldEnd()
27145 
    oprot.writeFieldStop()
27146 
    oprot.writeStructEnd()
27147 
 
27148 
  def validate(self):
27149 
    return
27150 
 
27151 
 
27152 
  def __repr__(self):
27153 
    L = ['%s=%r' % (key, value)
27154 
      for key, value in self.__dict__.iteritems()]
27155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27156 
 
27157 
  def __eq__(self, other):
27158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27159 
 
27160 
  def __ne__(self, other):
27161 
    return not (self == other)
27162 
 
6031 rajveer 27163 
class getUserWalletHistory_args:
6000 mandeep.dh 27164 
  """
27165 
  Attributes:
6031 rajveer 27166 
   - userId
6000 mandeep.dh 27167 
  """
27168 
 
27169 
  thrift_spec = (
27170 
    None, # 0
6031 rajveer 27171 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27172 
  )
27173 
 
6031 rajveer 27174 
  def __init__(self, userId=None,):
27175 
    self.userId = userId
6000 mandeep.dh 27176 
 
27177 
  def read(self, iprot):
27178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27180 
      return
27181 
    iprot.readStructBegin()
27182 
    while True:
27183 
      (fname, ftype, fid) = iprot.readFieldBegin()
27184 
      if ftype == TType.STOP:
27185 
        break
27186 
      if fid == 1:
27187 
        if ftype == TType.I64:
6031 rajveer 27188 
          self.userId = iprot.readI64();
6000 mandeep.dh 27189 
        else:
27190 
          iprot.skip(ftype)
27191 
      else:
27192 
        iprot.skip(ftype)
27193 
      iprot.readFieldEnd()
27194 
    iprot.readStructEnd()
27195 
 
27196 
  def write(self, oprot):
27197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27199 
      return
6031 rajveer 27200 
    oprot.writeStructBegin('getUserWalletHistory_args')
27201 
    if self.userId is not None:
27202 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27203 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27204 
      oprot.writeFieldEnd()
27205 
    oprot.writeFieldStop()
27206 
    oprot.writeStructEnd()
27207 
 
27208 
  def validate(self):
27209 
    return
27210 
 
27211 
 
27212 
  def __repr__(self):
27213 
    L = ['%s=%r' % (key, value)
27214 
      for key, value in self.__dict__.iteritems()]
27215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27216 
 
27217 
  def __eq__(self, other):
27218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27219 
 
27220 
  def __ne__(self, other):
27221 
    return not (self == other)
27222 
 
6031 rajveer 27223 
class getUserWalletHistory_result:
6000 mandeep.dh 27224 
  """
27225 
  Attributes:
27226 
   - success
27227 
  """
27228 
 
27229 
  thrift_spec = (
6031 rajveer 27230 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27231 
  )
27232 
 
27233 
  def __init__(self, success=None,):
27234 
    self.success = success
27235 
 
27236 
  def read(self, iprot):
27237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27239 
      return
27240 
    iprot.readStructBegin()
27241 
    while True:
27242 
      (fname, ftype, fid) = iprot.readFieldBegin()
27243 
      if ftype == TType.STOP:
27244 
        break
27245 
      if fid == 0:
27246 
        if ftype == TType.LIST:
27247 
          self.success = []
6188 rajveer 27248 
          (_etype666, _size663) = iprot.readListBegin()
27249 
          for _i667 in xrange(_size663):
27250 
            _elem668 = UserWalletHistory()
27251 
            _elem668.read(iprot)
27252 
            self.success.append(_elem668)
6000 mandeep.dh 27253 
          iprot.readListEnd()
27254 
        else:
27255 
          iprot.skip(ftype)
27256 
      else:
27257 
        iprot.skip(ftype)
27258 
      iprot.readFieldEnd()
27259 
    iprot.readStructEnd()
27260 
 
27261 
  def write(self, oprot):
27262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27264 
      return
6031 rajveer 27265 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27266 
    if self.success is not None:
27267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27268 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27269 
      for iter669 in self.success:
27270 
        iter669.write(oprot)
6000 mandeep.dh 27271 
      oprot.writeListEnd()
27272 
      oprot.writeFieldEnd()
27273 
    oprot.writeFieldStop()
27274 
    oprot.writeStructEnd()
27275 
 
27276 
  def validate(self):
27277 
    return
27278 
 
27279 
 
27280 
  def __repr__(self):
27281 
    L = ['%s=%r' % (key, value)
27282 
      for key, value in self.__dict__.iteritems()]
27283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27284 
 
27285 
  def __eq__(self, other):
27286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27287 
 
27288 
  def __ne__(self, other):
27289 
    return not (self == other)
6048 rajveer 27290 
 
6050 anupam.sin 27291 
class getRechargeOrdersForTransaction_args:
27292 
  """
27293 
  Attributes:
27294 
   - txnId
27295 
  """
27296 
 
27297 
  thrift_spec = (
27298 
    None, # 0
27299 
    (1, TType.I64, 'txnId', None, None, ), # 1
27300 
  )
27301 
 
27302 
  def __init__(self, txnId=None,):
27303 
    self.txnId = txnId
27304 
 
27305 
  def read(self, iprot):
27306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27308 
      return
27309 
    iprot.readStructBegin()
27310 
    while True:
27311 
      (fname, ftype, fid) = iprot.readFieldBegin()
27312 
      if ftype == TType.STOP:
27313 
        break
27314 
      if fid == 1:
27315 
        if ftype == TType.I64:
27316 
          self.txnId = iprot.readI64();
27317 
        else:
27318 
          iprot.skip(ftype)
27319 
      else:
27320 
        iprot.skip(ftype)
27321 
      iprot.readFieldEnd()
27322 
    iprot.readStructEnd()
27323 
 
27324 
  def write(self, oprot):
27325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27327 
      return
27328 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27329 
    if self.txnId is not None:
27330 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27331 
      oprot.writeI64(self.txnId)
27332 
      oprot.writeFieldEnd()
27333 
    oprot.writeFieldStop()
27334 
    oprot.writeStructEnd()
27335 
 
27336 
  def validate(self):
27337 
    return
27338 
 
27339 
 
27340 
  def __repr__(self):
27341 
    L = ['%s=%r' % (key, value)
27342 
      for key, value in self.__dict__.iteritems()]
27343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27344 
 
27345 
  def __eq__(self, other):
27346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27347 
 
27348 
  def __ne__(self, other):
27349 
    return not (self == other)
27350 
 
27351 
class getRechargeOrdersForTransaction_result:
27352 
  """
27353 
  Attributes:
27354 
   - success
27355 
   - ex
27356 
  """
27357 
 
27358 
  thrift_spec = (
27359 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27360 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27361 
  )
27362 
 
27363 
  def __init__(self, success=None, ex=None,):
27364 
    self.success = success
27365 
    self.ex = ex
27366 
 
27367 
  def read(self, iprot):
27368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27370 
      return
27371 
    iprot.readStructBegin()
27372 
    while True:
27373 
      (fname, ftype, fid) = iprot.readFieldBegin()
27374 
      if ftype == TType.STOP:
27375 
        break
27376 
      if fid == 0:
27377 
        if ftype == TType.STRUCT:
27378 
          self.success = RechargeOrder()
27379 
          self.success.read(iprot)
27380 
        else:
27381 
          iprot.skip(ftype)
27382 
      elif fid == 1:
27383 
        if ftype == TType.STRUCT:
27384 
          self.ex = TransactionServiceException()
27385 
          self.ex.read(iprot)
27386 
        else:
27387 
          iprot.skip(ftype)
27388 
      else:
27389 
        iprot.skip(ftype)
27390 
      iprot.readFieldEnd()
27391 
    iprot.readStructEnd()
27392 
 
27393 
  def write(self, oprot):
27394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27396 
      return
27397 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27398 
    if self.success is not None:
27399 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27400 
      self.success.write(oprot)
27401 
      oprot.writeFieldEnd()
27402 
    if self.ex is not None:
27403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27404 
      self.ex.write(oprot)
27405 
      oprot.writeFieldEnd()
27406 
    oprot.writeFieldStop()
27407 
    oprot.writeStructEnd()
27408 
 
27409 
  def validate(self):
27410 
    return
27411 
 
27412 
 
27413 
  def __repr__(self):
27414 
    L = ['%s=%r' % (key, value)
27415 
      for key, value in self.__dict__.iteritems()]
27416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27417 
 
27418 
  def __eq__(self, other):
27419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27420 
 
27421 
  def __ne__(self, other):
27422 
    return not (self == other)
27423 
 
6048 rajveer 27424 
class getServiceProviders_args:
27425 
  """
27426 
  Attributes:
27427 
   - rechargeType
6206 rajveer 27428 
   - onlyActive
6048 rajveer 27429 
  """
27430 
 
27431 
  thrift_spec = (
27432 
    None, # 0
27433 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27434 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27435 
  )
27436 
 
6206 rajveer 27437 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27438 
    self.rechargeType = rechargeType
6206 rajveer 27439 
    self.onlyActive = onlyActive
6048 rajveer 27440 
 
27441 
  def read(self, iprot):
27442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27444 
      return
27445 
    iprot.readStructBegin()
27446 
    while True:
27447 
      (fname, ftype, fid) = iprot.readFieldBegin()
27448 
      if ftype == TType.STOP:
27449 
        break
27450 
      if fid == 1:
27451 
        if ftype == TType.I32:
27452 
          self.rechargeType = iprot.readI32();
27453 
        else:
27454 
          iprot.skip(ftype)
6206 rajveer 27455 
      elif fid == 2:
27456 
        if ftype == TType.BOOL:
27457 
          self.onlyActive = iprot.readBool();
27458 
        else:
27459 
          iprot.skip(ftype)
6048 rajveer 27460 
      else:
27461 
        iprot.skip(ftype)
27462 
      iprot.readFieldEnd()
27463 
    iprot.readStructEnd()
27464 
 
27465 
  def write(self, oprot):
27466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27468 
      return
27469 
    oprot.writeStructBegin('getServiceProviders_args')
27470 
    if self.rechargeType is not None:
27471 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27472 
      oprot.writeI32(self.rechargeType)
27473 
      oprot.writeFieldEnd()
6206 rajveer 27474 
    if self.onlyActive is not None:
27475 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27476 
      oprot.writeBool(self.onlyActive)
27477 
      oprot.writeFieldEnd()
6048 rajveer 27478 
    oprot.writeFieldStop()
27479 
    oprot.writeStructEnd()
27480 
 
27481 
  def validate(self):
27482 
    return
27483 
 
27484 
 
27485 
  def __repr__(self):
27486 
    L = ['%s=%r' % (key, value)
27487 
      for key, value in self.__dict__.iteritems()]
27488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27489 
 
27490 
  def __eq__(self, other):
27491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27492 
 
27493 
  def __ne__(self, other):
27494 
    return not (self == other)
27495 
 
27496 
class getServiceProviders_result:
27497 
  """
27498 
  Attributes:
27499 
   - success
27500 
  """
27501 
 
27502 
  thrift_spec = (
27503 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27504 
  )
27505 
 
27506 
  def __init__(self, success=None,):
27507 
    self.success = success
27508 
 
27509 
  def read(self, iprot):
27510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27512 
      return
27513 
    iprot.readStructBegin()
27514 
    while True:
27515 
      (fname, ftype, fid) = iprot.readFieldBegin()
27516 
      if ftype == TType.STOP:
27517 
        break
27518 
      if fid == 0:
27519 
        if ftype == TType.MAP:
27520 
          self.success = {}
6188 rajveer 27521 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27522 
          for _i674 in xrange(_size670):
27523 
            _key675 = iprot.readI64();
27524 
            _val676 = iprot.readString();
27525 
            self.success[_key675] = _val676
6048 rajveer 27526 
          iprot.readMapEnd()
27527 
        else:
27528 
          iprot.skip(ftype)
27529 
      else:
27530 
        iprot.skip(ftype)
27531 
      iprot.readFieldEnd()
27532 
    iprot.readStructEnd()
27533 
 
27534 
  def write(self, oprot):
27535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27537 
      return
27538 
    oprot.writeStructBegin('getServiceProviders_result')
27539 
    if self.success is not None:
27540 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27541 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27542 
      for kiter677,viter678 in self.success.items():
27543 
        oprot.writeI64(kiter677)
27544 
        oprot.writeString(viter678)
6048 rajveer 27545 
      oprot.writeMapEnd()
27546 
      oprot.writeFieldEnd()
27547 
    oprot.writeFieldStop()
27548 
    oprot.writeStructEnd()
27549 
 
27550 
  def validate(self):
27551 
    return
27552 
 
27553 
 
27554 
  def __repr__(self):
27555 
    L = ['%s=%r' % (key, value)
27556 
      for key, value in self.__dict__.iteritems()]
27557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27558 
 
27559 
  def __eq__(self, other):
27560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27561 
 
27562 
  def __ne__(self, other):
27563 
    return not (self == other)
27564 
 
27565 
class getServiceProviderForDevice_args:
27566 
  """
27567 
  Attributes:
6049 rajveer 27568 
   - rechargeType
6048 rajveer 27569 
   - deviceNumber
27570 
  """
27571 
 
27572 
  thrift_spec = (
27573 
    None, # 0
6049 rajveer 27574 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27575 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27576 
  )
27577 
 
6049 rajveer 27578 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27579 
    self.rechargeType = rechargeType
6048 rajveer 27580 
    self.deviceNumber = deviceNumber
27581 
 
27582 
  def read(self, iprot):
27583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27585 
      return
27586 
    iprot.readStructBegin()
27587 
    while True:
27588 
      (fname, ftype, fid) = iprot.readFieldBegin()
27589 
      if ftype == TType.STOP:
27590 
        break
27591 
      if fid == 1:
6049 rajveer 27592 
        if ftype == TType.I32:
27593 
          self.rechargeType = iprot.readI32();
27594 
        else:
27595 
          iprot.skip(ftype)
27596 
      elif fid == 2:
6048 rajveer 27597 
        if ftype == TType.STRING:
27598 
          self.deviceNumber = iprot.readString();
27599 
        else:
27600 
          iprot.skip(ftype)
27601 
      else:
27602 
        iprot.skip(ftype)
27603 
      iprot.readFieldEnd()
27604 
    iprot.readStructEnd()
27605 
 
27606 
  def write(self, oprot):
27607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27609 
      return
27610 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27611 
    if self.rechargeType is not None:
27612 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27613 
      oprot.writeI32(self.rechargeType)
27614 
      oprot.writeFieldEnd()
6048 rajveer 27615 
    if self.deviceNumber is not None:
6049 rajveer 27616 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27617 
      oprot.writeString(self.deviceNumber)
27618 
      oprot.writeFieldEnd()
27619 
    oprot.writeFieldStop()
27620 
    oprot.writeStructEnd()
27621 
 
27622 
  def validate(self):
27623 
    return
27624 
 
27625 
 
27626 
  def __repr__(self):
27627 
    L = ['%s=%r' % (key, value)
27628 
      for key, value in self.__dict__.iteritems()]
27629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27630 
 
27631 
  def __eq__(self, other):
27632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27633 
 
27634 
  def __ne__(self, other):
27635 
    return not (self == other)
27636 
 
27637 
class getServiceProviderForDevice_result:
27638 
  """
27639 
  Attributes:
27640 
   - success
27641 
  """
27642 
 
27643 
  thrift_spec = (
27644 
    (0, TType.I64, 'success', None, None, ), # 0
27645 
  )
27646 
 
27647 
  def __init__(self, success=None,):
27648 
    self.success = success
27649 
 
27650 
  def read(self, iprot):
27651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27653 
      return
27654 
    iprot.readStructBegin()
27655 
    while True:
27656 
      (fname, ftype, fid) = iprot.readFieldBegin()
27657 
      if ftype == TType.STOP:
27658 
        break
27659 
      if fid == 0:
27660 
        if ftype == TType.I64:
27661 
          self.success = iprot.readI64();
27662 
        else:
27663 
          iprot.skip(ftype)
27664 
      else:
27665 
        iprot.skip(ftype)
27666 
      iprot.readFieldEnd()
27667 
    iprot.readStructEnd()
27668 
 
27669 
  def write(self, oprot):
27670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27672 
      return
27673 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27674 
    if self.success is not None:
27675 
      oprot.writeFieldBegin('success', TType.I64, 0)
27676 
      oprot.writeI64(self.success)
27677 
      oprot.writeFieldEnd()
27678 
    oprot.writeFieldStop()
27679 
    oprot.writeStructEnd()
27680 
 
27681 
  def validate(self):
27682 
    return
27683 
 
27684 
 
27685 
  def __repr__(self):
27686 
    L = ['%s=%r' % (key, value)
27687 
      for key, value in self.__dict__.iteritems()]
27688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27689 
 
27690 
  def __eq__(self, other):
27691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27692 
 
27693 
  def __ne__(self, other):
27694 
    return not (self == other)
6094 rajveer 27695 
 
27696 
class getRechargeOrdersForDevice_args:
27697 
  """
27698 
  Attributes:
27699 
   - deviceNumber
27700 
  """
27701 
 
27702 
  thrift_spec = (
27703 
    None, # 0
27704 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27705 
  )
27706 
 
27707 
  def __init__(self, deviceNumber=None,):
27708 
    self.deviceNumber = deviceNumber
27709 
 
27710 
  def read(self, iprot):
27711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27713 
      return
27714 
    iprot.readStructBegin()
27715 
    while True:
27716 
      (fname, ftype, fid) = iprot.readFieldBegin()
27717 
      if ftype == TType.STOP:
27718 
        break
27719 
      if fid == 1:
27720 
        if ftype == TType.STRING:
27721 
          self.deviceNumber = iprot.readString();
27722 
        else:
27723 
          iprot.skip(ftype)
27724 
      else:
27725 
        iprot.skip(ftype)
27726 
      iprot.readFieldEnd()
27727 
    iprot.readStructEnd()
27728 
 
27729 
  def write(self, oprot):
27730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27732 
      return
27733 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27734 
    if self.deviceNumber is not None:
27735 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27736 
      oprot.writeString(self.deviceNumber)
27737 
      oprot.writeFieldEnd()
27738 
    oprot.writeFieldStop()
27739 
    oprot.writeStructEnd()
27740 
 
27741 
  def validate(self):
27742 
    return
27743 
 
27744 
 
27745 
  def __repr__(self):
27746 
    L = ['%s=%r' % (key, value)
27747 
      for key, value in self.__dict__.iteritems()]
27748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27749 
 
27750 
  def __eq__(self, other):
27751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27752 
 
27753 
  def __ne__(self, other):
27754 
    return not (self == other)
27755 
 
27756 
class getRechargeOrdersForDevice_result:
27757 
  """
27758 
  Attributes:
27759 
   - success
27760 
  """
27761 
 
27762 
  thrift_spec = (
27763 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27764 
  )
27765 
 
27766 
  def __init__(self, success=None,):
27767 
    self.success = success
27768 
 
27769 
  def read(self, iprot):
27770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27772 
      return
27773 
    iprot.readStructBegin()
27774 
    while True:
27775 
      (fname, ftype, fid) = iprot.readFieldBegin()
27776 
      if ftype == TType.STOP:
27777 
        break
27778 
      if fid == 0:
27779 
        if ftype == TType.LIST:
27780 
          self.success = []
6188 rajveer 27781 
          (_etype682, _size679) = iprot.readListBegin()
27782 
          for _i683 in xrange(_size679):
27783 
            _elem684 = RechargeOrder()
27784 
            _elem684.read(iprot)
27785 
            self.success.append(_elem684)
6094 rajveer 27786 
          iprot.readListEnd()
27787 
        else:
27788 
          iprot.skip(ftype)
27789 
      else:
27790 
        iprot.skip(ftype)
27791 
      iprot.readFieldEnd()
27792 
    iprot.readStructEnd()
27793 
 
27794 
  def write(self, oprot):
27795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27797 
      return
27798 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27799 
    if self.success is not None:
27800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27802 
      for iter685 in self.success:
27803 
        iter685.write(oprot)
6094 rajveer 27804 
      oprot.writeListEnd()
27805 
      oprot.writeFieldEnd()
27806 
    oprot.writeFieldStop()
27807 
    oprot.writeStructEnd()
27808 
 
27809 
  def validate(self):
27810 
    return
27811 
 
27812 
 
27813 
  def __repr__(self):
27814 
    L = ['%s=%r' % (key, value)
27815 
      for key, value in self.__dict__.iteritems()]
27816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27817 
 
27818 
  def __eq__(self, other):
27819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27820 
 
27821 
  def __ne__(self, other):
27822 
    return not (self == other)
27823 
 
27824 
class addAmountToWallet_args:
27825 
  """
27826 
  Attributes:
27827 
   - userId
27828 
   - orderId
27829 
   - amount
27830 
  """
27831 
 
27832 
  thrift_spec = (
27833 
    None, # 0
27834 
    (1, TType.I64, 'userId', None, None, ), # 1
27835 
    (2, TType.I64, 'orderId', None, None, ), # 2
27836 
    (3, TType.I64, 'amount', None, None, ), # 3
27837 
  )
27838 
 
27839 
  def __init__(self, userId=None, orderId=None, amount=None,):
27840 
    self.userId = userId
27841 
    self.orderId = orderId
27842 
    self.amount = amount
27843 
 
27844 
  def read(self, iprot):
27845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27847 
      return
27848 
    iprot.readStructBegin()
27849 
    while True:
27850 
      (fname, ftype, fid) = iprot.readFieldBegin()
27851 
      if ftype == TType.STOP:
27852 
        break
27853 
      if fid == 1:
27854 
        if ftype == TType.I64:
27855 
          self.userId = iprot.readI64();
27856 
        else:
27857 
          iprot.skip(ftype)
27858 
      elif fid == 2:
27859 
        if ftype == TType.I64:
27860 
          self.orderId = iprot.readI64();
27861 
        else:
27862 
          iprot.skip(ftype)
27863 
      elif fid == 3:
27864 
        if ftype == TType.I64:
27865 
          self.amount = iprot.readI64();
27866 
        else:
27867 
          iprot.skip(ftype)
27868 
      else:
27869 
        iprot.skip(ftype)
27870 
      iprot.readFieldEnd()
27871 
    iprot.readStructEnd()
27872 
 
27873 
  def write(self, oprot):
27874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27876 
      return
27877 
    oprot.writeStructBegin('addAmountToWallet_args')
27878 
    if self.userId is not None:
27879 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27880 
      oprot.writeI64(self.userId)
27881 
      oprot.writeFieldEnd()
27882 
    if self.orderId is not None:
27883 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
27884 
      oprot.writeI64(self.orderId)
27885 
      oprot.writeFieldEnd()
27886 
    if self.amount is not None:
27887 
      oprot.writeFieldBegin('amount', TType.I64, 3)
27888 
      oprot.writeI64(self.amount)
27889 
      oprot.writeFieldEnd()
27890 
    oprot.writeFieldStop()
27891 
    oprot.writeStructEnd()
27892 
 
27893 
  def validate(self):
27894 
    return
27895 
 
27896 
 
27897 
  def __repr__(self):
27898 
    L = ['%s=%r' % (key, value)
27899 
      for key, value in self.__dict__.iteritems()]
27900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27901 
 
27902 
  def __eq__(self, other):
27903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27904 
 
27905 
  def __ne__(self, other):
27906 
    return not (self == other)
27907 
 
27908 
class addAmountToWallet_result:
27909 
 
27910 
  thrift_spec = (
27911 
  )
27912 
 
27913 
  def read(self, iprot):
27914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27916 
      return
27917 
    iprot.readStructBegin()
27918 
    while True:
27919 
      (fname, ftype, fid) = iprot.readFieldBegin()
27920 
      if ftype == TType.STOP:
27921 
        break
27922 
      else:
27923 
        iprot.skip(ftype)
27924 
      iprot.readFieldEnd()
27925 
    iprot.readStructEnd()
27926 
 
27927 
  def write(self, oprot):
27928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27930 
      return
27931 
    oprot.writeStructBegin('addAmountToWallet_result')
27932 
    oprot.writeFieldStop()
27933 
    oprot.writeStructEnd()
27934 
 
27935 
  def validate(self):
27936 
    return
27937 
 
27938 
 
27939 
  def __repr__(self):
27940 
    L = ['%s=%r' % (key, value)
27941 
      for key, value in self.__dict__.iteritems()]
27942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27943 
 
27944 
  def __eq__(self, other):
27945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27946 
 
27947 
  def __ne__(self, other):
27948 
    return not (self == other)
6154 rajveer 27949 
 
6188 rajveer 27950 
class getRechargeStatistics_args:
27951 
 
27952 
  thrift_spec = (
27953 
  )
27954 
 
27955 
  def read(self, iprot):
27956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27958 
      return
27959 
    iprot.readStructBegin()
27960 
    while True:
27961 
      (fname, ftype, fid) = iprot.readFieldBegin()
27962 
      if ftype == TType.STOP:
27963 
        break
27964 
      else:
27965 
        iprot.skip(ftype)
27966 
      iprot.readFieldEnd()
27967 
    iprot.readStructEnd()
27968 
 
27969 
  def write(self, oprot):
27970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27972 
      return
27973 
    oprot.writeStructBegin('getRechargeStatistics_args')
27974 
    oprot.writeFieldStop()
27975 
    oprot.writeStructEnd()
27976 
 
27977 
  def validate(self):
27978 
    return
27979 
 
27980 
 
27981 
  def __repr__(self):
27982 
    L = ['%s=%r' % (key, value)
27983 
      for key, value in self.__dict__.iteritems()]
27984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27985 
 
27986 
  def __eq__(self, other):
27987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27988 
 
27989 
  def __ne__(self, other):
27990 
    return not (self == other)
27991 
 
27992 
class getRechargeStatistics_result:
27993 
  """
27994 
  Attributes:
27995 
   - success
27996 
  """
27997 
 
27998 
  thrift_spec = (
27999 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28000 
  )
28001 
 
28002 
  def __init__(self, success=None,):
28003 
    self.success = success
28004 
 
28005 
  def read(self, iprot):
28006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28008 
      return
28009 
    iprot.readStructBegin()
28010 
    while True:
28011 
      (fname, ftype, fid) = iprot.readFieldBegin()
28012 
      if ftype == TType.STOP:
28013 
        break
28014 
      if fid == 0:
28015 
        if ftype == TType.STRUCT:
28016 
          self.success = RechargeStatistics()
28017 
          self.success.read(iprot)
28018 
        else:
28019 
          iprot.skip(ftype)
28020 
      else:
28021 
        iprot.skip(ftype)
28022 
      iprot.readFieldEnd()
28023 
    iprot.readStructEnd()
28024 
 
28025 
  def write(self, oprot):
28026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28028 
      return
28029 
    oprot.writeStructBegin('getRechargeStatistics_result')
28030 
    if self.success is not None:
28031 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28032 
      self.success.write(oprot)
28033 
      oprot.writeFieldEnd()
28034 
    oprot.writeFieldStop()
28035 
    oprot.writeStructEnd()
28036 
 
28037 
  def validate(self):
28038 
    return
28039 
 
28040 
 
28041 
  def __repr__(self):
28042 
    L = ['%s=%r' % (key, value)
28043 
      for key, value in self.__dict__.iteritems()]
28044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28045 
 
28046 
  def __eq__(self, other):
28047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28048 
 
28049 
  def __ne__(self, other):
28050 
    return not (self == other)
28051 
 
6154 rajveer 28052 
class getRechargeOrdersForStatus_args:
28053 
  """
28054 
  Attributes:
28055 
   - status
28056 
  """
28057 
 
28058 
  thrift_spec = (
28059 
    None, # 0
28060 
    (1, TType.I64, 'status', None, None, ), # 1
28061 
  )
28062 
 
28063 
  def __init__(self, status=None,):
28064 
    self.status = status
28065 
 
28066 
  def read(self, iprot):
28067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28069 
      return
28070 
    iprot.readStructBegin()
28071 
    while True:
28072 
      (fname, ftype, fid) = iprot.readFieldBegin()
28073 
      if ftype == TType.STOP:
28074 
        break
28075 
      if fid == 1:
28076 
        if ftype == TType.I64:
28077 
          self.status = iprot.readI64();
28078 
        else:
28079 
          iprot.skip(ftype)
28080 
      else:
28081 
        iprot.skip(ftype)
28082 
      iprot.readFieldEnd()
28083 
    iprot.readStructEnd()
28084 
 
28085 
  def write(self, oprot):
28086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28088 
      return
28089 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28090 
    if self.status is not None:
28091 
      oprot.writeFieldBegin('status', TType.I64, 1)
28092 
      oprot.writeI64(self.status)
28093 
      oprot.writeFieldEnd()
28094 
    oprot.writeFieldStop()
28095 
    oprot.writeStructEnd()
28096 
 
28097 
  def validate(self):
28098 
    return
28099 
 
28100 
 
28101 
  def __repr__(self):
28102 
    L = ['%s=%r' % (key, value)
28103 
      for key, value in self.__dict__.iteritems()]
28104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28105 
 
28106 
  def __eq__(self, other):
28107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28108 
 
28109 
  def __ne__(self, other):
28110 
    return not (self == other)
28111 
 
28112 
class getRechargeOrdersForStatus_result:
28113 
  """
28114 
  Attributes:
28115 
   - success
28116 
  """
28117 
 
28118 
  thrift_spec = (
28119 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28120 
  )
28121 
 
28122 
  def __init__(self, success=None,):
28123 
    self.success = success
28124 
 
28125 
  def read(self, iprot):
28126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28128 
      return
28129 
    iprot.readStructBegin()
28130 
    while True:
28131 
      (fname, ftype, fid) = iprot.readFieldBegin()
28132 
      if ftype == TType.STOP:
28133 
        break
28134 
      if fid == 0:
28135 
        if ftype == TType.LIST:
28136 
          self.success = []
6188 rajveer 28137 
          (_etype689, _size686) = iprot.readListBegin()
28138 
          for _i690 in xrange(_size686):
28139 
            _elem691 = RechargeOrder()
28140 
            _elem691.read(iprot)
28141 
            self.success.append(_elem691)
6154 rajveer 28142 
          iprot.readListEnd()
28143 
        else:
28144 
          iprot.skip(ftype)
28145 
      else:
28146 
        iprot.skip(ftype)
28147 
      iprot.readFieldEnd()
28148 
    iprot.readStructEnd()
28149 
 
28150 
  def write(self, oprot):
28151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28153 
      return
28154 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28155 
    if self.success is not None:
28156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28158 
      for iter692 in self.success:
28159 
        iter692.write(oprot)
6154 rajveer 28160 
      oprot.writeListEnd()
28161 
      oprot.writeFieldEnd()
28162 
    oprot.writeFieldStop()
28163 
    oprot.writeStructEnd()
28164 
 
28165 
  def validate(self):
28166 
    return
28167 
 
28168 
 
28169 
  def __repr__(self):
28170 
    L = ['%s=%r' % (key, value)
28171 
      for key, value in self.__dict__.iteritems()]
28172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28173 
 
28174 
  def __eq__(self, other):
28175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28176 
 
28177 
  def __ne__(self, other):
28178 
    return not (self == other)
6159 rajveer 28179 
 
28180 
class getPlansForOperator_args:
28181 
  """
28182 
  Attributes:
28183 
   - operatorId
28184 
  """
28185 
 
28186 
  thrift_spec = (
28187 
    None, # 0
28188 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28189 
  )
28190 
 
28191 
  def __init__(self, operatorId=None,):
28192 
    self.operatorId = operatorId
28193 
 
28194 
  def read(self, iprot):
28195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28197 
      return
28198 
    iprot.readStructBegin()
28199 
    while True:
28200 
      (fname, ftype, fid) = iprot.readFieldBegin()
28201 
      if ftype == TType.STOP:
28202 
        break
28203 
      if fid == 1:
28204 
        if ftype == TType.I64:
28205 
          self.operatorId = iprot.readI64();
28206 
        else:
28207 
          iprot.skip(ftype)
28208 
      else:
28209 
        iprot.skip(ftype)
28210 
      iprot.readFieldEnd()
28211 
    iprot.readStructEnd()
28212 
 
28213 
  def write(self, oprot):
28214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28216 
      return
28217 
    oprot.writeStructBegin('getPlansForOperator_args')
28218 
    if self.operatorId is not None:
28219 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28220 
      oprot.writeI64(self.operatorId)
28221 
      oprot.writeFieldEnd()
28222 
    oprot.writeFieldStop()
28223 
    oprot.writeStructEnd()
28224 
 
28225 
  def validate(self):
28226 
    return
28227 
 
28228 
 
28229 
  def __repr__(self):
28230 
    L = ['%s=%r' % (key, value)
28231 
      for key, value in self.__dict__.iteritems()]
28232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28233 
 
28234 
  def __eq__(self, other):
28235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28236 
 
28237 
  def __ne__(self, other):
28238 
    return not (self == other)
28239 
 
28240 
class getPlansForOperator_result:
28241 
  """
28242 
  Attributes:
28243 
   - success
28244 
  """
28245 
 
28246 
  thrift_spec = (
28247 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28248 
  )
28249 
 
28250 
  def __init__(self, success=None,):
28251 
    self.success = success
28252 
 
28253 
  def read(self, iprot):
28254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28256 
      return
28257 
    iprot.readStructBegin()
28258 
    while True:
28259 
      (fname, ftype, fid) = iprot.readFieldBegin()
28260 
      if ftype == TType.STOP:
28261 
        break
28262 
      if fid == 0:
28263 
        if ftype == TType.LIST:
28264 
          self.success = []
6188 rajveer 28265 
          (_etype696, _size693) = iprot.readListBegin()
28266 
          for _i697 in xrange(_size693):
28267 
            _elem698 = RechargePlan()
28268 
            _elem698.read(iprot)
28269 
            self.success.append(_elem698)
6159 rajveer 28270 
          iprot.readListEnd()
28271 
        else:
28272 
          iprot.skip(ftype)
28273 
      else:
28274 
        iprot.skip(ftype)
28275 
      iprot.readFieldEnd()
28276 
    iprot.readStructEnd()
28277 
 
28278 
  def write(self, oprot):
28279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28281 
      return
28282 
    oprot.writeStructBegin('getPlansForOperator_result')
28283 
    if self.success is not None:
28284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28286 
      for iter699 in self.success:
28287 
        iter699.write(oprot)
6159 rajveer 28288 
      oprot.writeListEnd()
28289 
      oprot.writeFieldEnd()
28290 
    oprot.writeFieldStop()
28291 
    oprot.writeStructEnd()
28292 
 
28293 
  def validate(self):
28294 
    return
28295 
 
28296 
 
28297 
  def __repr__(self):
28298 
    L = ['%s=%r' % (key, value)
28299 
      for key, value in self.__dict__.iteritems()]
28300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28301 
 
28302 
  def __eq__(self, other):
28303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28304 
 
28305 
  def __ne__(self, other):
28306 
    return not (self == other)