Subversion Repositories SmartDukaan

Rev

Rev 6206 | Rev 6289 | 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 
 
6269 rajveer 1365 
  def validateRecharge(self, rechargeType, deviceNumber):
1366 
    """
1367 
    Parameters:
1368 
     - rechargeType
1369 
     - deviceNumber
1370 
    """
1371 
    pass
1372 
 
6094 rajveer 1373 
  def getRechargeOrdersForDevice(self, deviceNumber):
1374 
    """
1375 
    Parameters:
1376 
     - deviceNumber
1377 
    """
1378 
    pass
6048 rajveer 1379 
 
6094 rajveer 1380 
  def addAmountToWallet(self, userId, orderId, amount):
1381 
    """
1382 
    Parameters:
1383 
     - userId
1384 
     - orderId
1385 
     - amount
1386 
    """
1387 
    pass
1388 
 
6188 rajveer 1389 
  def getRechargeStatistics(self, ):
1390 
    pass
1391 
 
6154 rajveer 1392 
  def getRechargeOrdersForStatus(self, status):
1393 
    """
1394 
    Parameters:
1395 
     - status
1396 
    """
1397 
    pass
6094 rajveer 1398 
 
6159 rajveer 1399 
  def getPlansForOperator(self, operatorId):
1400 
    """
1401 
    Parameters:
1402 
     - operatorId
1403 
    """
1404 
    pass
6154 rajveer 1405 
 
6159 rajveer 1406 
 
3376 rajveer 1407 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1408 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1409 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1410 
 
1411 
  def createTransaction(self, transaction):
1412 
    """
1413 
    Parameters:
1414 
     - transaction
1415 
    """
1416 
    self.send_createTransaction(transaction)
132 ashish 1417 
    return self.recv_createTransaction()
94 ashish 1418 
 
1419 
  def send_createTransaction(self, transaction):
1420 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1421 
    args = createTransaction_args()
1422 
    args.transaction = transaction
1423 
    args.write(self._oprot)
1424 
    self._oprot.writeMessageEnd()
1425 
    self._oprot.trans.flush()
1426 
 
1427 
  def recv_createTransaction(self, ):
1428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1429 
    if mtype == TMessageType.EXCEPTION:
1430 
      x = TApplicationException()
1431 
      x.read(self._iprot)
1432 
      self._iprot.readMessageEnd()
1433 
      raise x
1434 
    result = createTransaction_result()
1435 
    result.read(self._iprot)
1436 
    self._iprot.readMessageEnd()
3431 rajveer 1437 
    if result.success is not None:
132 ashish 1438 
      return result.success
3431 rajveer 1439 
    if result.ex is not None:
94 ashish 1440 
      raise result.ex
132 ashish 1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1442 
 
1443 
  def getTransaction(self, id):
1444 
    """
1445 
    Parameters:
1446 
     - id
1447 
    """
1448 
    self.send_getTransaction(id)
1449 
    return self.recv_getTransaction()
1450 
 
1451 
  def send_getTransaction(self, id):
1452 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1453 
    args = getTransaction_args()
1454 
    args.id = id
1455 
    args.write(self._oprot)
1456 
    self._oprot.writeMessageEnd()
1457 
    self._oprot.trans.flush()
1458 
 
1459 
  def recv_getTransaction(self, ):
1460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1461 
    if mtype == TMessageType.EXCEPTION:
1462 
      x = TApplicationException()
1463 
      x.read(self._iprot)
1464 
      self._iprot.readMessageEnd()
1465 
      raise x
1466 
    result = getTransaction_result()
1467 
    result.read(self._iprot)
1468 
    self._iprot.readMessageEnd()
3431 rajveer 1469 
    if result.success is not None:
94 ashish 1470 
      return result.success
3431 rajveer 1471 
    if result.ex is not None:
94 ashish 1472 
      raise result.ex
1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1474 
 
1475 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1476 
    """
1477 
    Parameters:
1478 
     - customerId
1479 
     - from_date
1480 
     - to_date
1481 
     - status
1482 
    """
1483 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1484 
    return self.recv_getTransactionsForCustomer()
1485 
 
1486 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1487 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1488 
    args = getTransactionsForCustomer_args()
1489 
    args.customerId = customerId
1490 
    args.from_date = from_date
1491 
    args.to_date = to_date
1492 
    args.status = status
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getTransactionsForCustomer(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getTransactionsForCustomer_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
94 ashish 1508 
      return result.success
3431 rajveer 1509 
    if result.ex is not None:
94 ashish 1510 
      raise result.ex
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1512 
 
132 ashish 1513 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1514 
    """
1515 
    Parameters:
1516 
     - shoppingCartId
1517 
    """
1518 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1519 
    return self.recv_getTransactionsForShoppingCartId()
1520 
 
1521 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1522 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1523 
    args = getTransactionsForShoppingCartId_args()
1524 
    args.shoppingCartId = shoppingCartId
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getTransactionsForShoppingCartId(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getTransactionsForShoppingCartId_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
3431 rajveer 1539 
    if result.success is not None:
132 ashish 1540 
      return result.success
3431 rajveer 1541 
    if result.ex is not None:
132 ashish 1542 
      raise result.ex
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1544 
 
94 ashish 1545 
  def getTransactionStatus(self, transactionId):
1546 
    """
1547 
    Parameters:
1548 
     - transactionId
1549 
    """
1550 
    self.send_getTransactionStatus(transactionId)
1551 
    return self.recv_getTransactionStatus()
1552 
 
1553 
  def send_getTransactionStatus(self, transactionId):
1554 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1555 
    args = getTransactionStatus_args()
1556 
    args.transactionId = transactionId
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_getTransactionStatus(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = getTransactionStatus_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
3431 rajveer 1571 
    if result.success is not None:
94 ashish 1572 
      return result.success
3431 rajveer 1573 
    if result.ex is not None:
94 ashish 1574 
      raise result.ex
1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1576 
 
5527 anupam.sin 1577 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1578 
    """
1579 
    Parameters:
1580 
     - transactionId
1581 
     - status
1582 
     - description
5527 anupam.sin 1583 
     - pickUp
1584 
     - orderType
94 ashish 1585 
    """
5527 anupam.sin 1586 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1587 
    return self.recv_changeTransactionStatus()
1588 
 
5527 anupam.sin 1589 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1590 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1591 
    args = changeTransactionStatus_args()
1592 
    args.transactionId = transactionId
1593 
    args.status = status
1594 
    args.description = description
5527 anupam.sin 1595 
    args.pickUp = pickUp
1596 
    args.orderType = orderType
94 ashish 1597 
    args.write(self._oprot)
1598 
    self._oprot.writeMessageEnd()
1599 
    self._oprot.trans.flush()
1600 
 
1601 
  def recv_changeTransactionStatus(self, ):
1602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1603 
    if mtype == TMessageType.EXCEPTION:
1604 
      x = TApplicationException()
1605 
      x.read(self._iprot)
1606 
      self._iprot.readMessageEnd()
1607 
      raise x
1608 
    result = changeTransactionStatus_result()
1609 
    result.read(self._iprot)
1610 
    self._iprot.readMessageEnd()
3431 rajveer 1611 
    if result.success is not None:
94 ashish 1612 
      return result.success
3431 rajveer 1613 
    if result.ex is not None:
94 ashish 1614 
      raise result.ex
1615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1616 
 
1398 varun.gupt 1617 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1618 
    """
1619 
    Parameters:
1620 
     - transactionId
1621 
    """
1398 varun.gupt 1622 
    self.send_enqueueTransactionInfoEmail(transactionId)
1623 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1624 
 
1398 varun.gupt 1625 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1626 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1627 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1628 
    args.transactionId = transactionId
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1398 varun.gupt 1633 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1398 varun.gupt 1640 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
1382 varun.gupt 1644 
      return result.success
3431 rajveer 1645 
    if result.ex is not None:
1382 varun.gupt 1646 
      raise result.ex
1398 varun.gupt 1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1648 
 
4801 anupam.sin 1649 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1650 
    """
1651 
    Parameters:
4801 anupam.sin 1652 
     - statuses
483 rajveer 1653 
     - from_date
1654 
     - to_date
1655 
     - warehouse_id
94 ashish 1656 
    """
4801 anupam.sin 1657 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1658 
    return self.recv_getAllOrders()
94 ashish 1659 
 
4801 anupam.sin 1660 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1661 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1662 
    args = getAllOrders_args()
4801 anupam.sin 1663 
    args.statuses = statuses
483 rajveer 1664 
    args.from_date = from_date
1665 
    args.to_date = to_date
1666 
    args.warehouse_id = warehouse_id
94 ashish 1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
483 rajveer 1671 
  def recv_getAllOrders(self, ):
94 ashish 1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
483 rajveer 1678 
    result = getAllOrders_result()
94 ashish 1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
3431 rajveer 1681 
    if result.success is not None:
94 ashish 1682 
      return result.success
3431 rajveer 1683 
    if result.ex is not None:
94 ashish 1684 
      raise result.ex
483 rajveer 1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1686 
 
4133 chandransh 1687 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1688 
    """
1689 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1690 
    Pass the status as null and the limit as 0 to ignore them.
1691 
 
1692 
    Parameters:
1693 
     - statuses
1694 
     - offset
1695 
     - limit
1696 
     - warehouse_id
1697 
    """
1698 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1699 
    return self.recv_getOrdersInBatch()
1700 
 
1701 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1702 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1703 
    args = getOrdersInBatch_args()
1704 
    args.statuses = statuses
1705 
    args.offset = offset
1706 
    args.limit = limit
1707 
    args.warehouse_id = warehouse_id
1708 
    args.write(self._oprot)
1709 
    self._oprot.writeMessageEnd()
1710 
    self._oprot.trans.flush()
1711 
 
1712 
  def recv_getOrdersInBatch(self, ):
1713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1714 
    if mtype == TMessageType.EXCEPTION:
1715 
      x = TApplicationException()
1716 
      x.read(self._iprot)
1717 
      self._iprot.readMessageEnd()
1718 
      raise x
1719 
    result = getOrdersInBatch_result()
1720 
    result.read(self._iprot)
1721 
    self._iprot.readMessageEnd()
1722 
    if result.success is not None:
1723 
      return result.success
1724 
    if result.ex is not None:
1725 
      raise result.ex
1726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1727 
 
1728 
  def getOrderCount(self, statuses, warehouseId):
1729 
    """
1730 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1731 
 
1732 
    Parameters:
1733 
     - statuses
1734 
     - warehouseId
1735 
    """
1736 
    self.send_getOrderCount(statuses, warehouseId)
1737 
    return self.recv_getOrderCount()
1738 
 
1739 
  def send_getOrderCount(self, statuses, warehouseId):
1740 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1741 
    args = getOrderCount_args()
1742 
    args.statuses = statuses
1743 
    args.warehouseId = warehouseId
1744 
    args.write(self._oprot)
1745 
    self._oprot.writeMessageEnd()
1746 
    self._oprot.trans.flush()
1747 
 
1748 
  def recv_getOrderCount(self, ):
1749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1750 
    if mtype == TMessageType.EXCEPTION:
1751 
      x = TApplicationException()
1752 
      x.read(self._iprot)
1753 
      self._iprot.readMessageEnd()
1754 
      raise x
1755 
    result = getOrderCount_result()
1756 
    result.read(self._iprot)
1757 
    self._iprot.readMessageEnd()
1758 
    if result.success is not None:
1759 
      return result.success
1760 
    if result.ex is not None:
1761 
      raise result.ex
1762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1763 
 
999 varun.gupt 1764 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1765 
    """
1132 chandransh 1766 
    Returns orders within a range of their billing dates
3431 rajveer 1767 
 
999 varun.gupt 1768 
    Parameters:
1769 
     - status
1770 
     - start_billing_date
1771 
     - end_billing_date
1772 
     - warehouse_id
1773 
    """
1774 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1775 
    return self.recv_getOrdersByBillingDate()
1776 
 
1777 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1778 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1779 
    args = getOrdersByBillingDate_args()
1780 
    args.status = status
1781 
    args.start_billing_date = start_billing_date
1782 
    args.end_billing_date = end_billing_date
1783 
    args.warehouse_id = warehouse_id
1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1788 
  def recv_getOrdersByBillingDate(self, ):
1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1795 
    result = getOrdersByBillingDate_result()
1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
3431 rajveer 1798 
    if result.success is not None:
999 varun.gupt 1799 
      return result.success
3431 rajveer 1800 
    if result.ex is not None:
999 varun.gupt 1801 
      raise result.ex
1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1803 
 
3451 chandransh 1804 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1805 
    """
1806 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1807 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1808 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1809 
 
3427 chandransh 1810 
    Parameters:
1811 
     - fromShippingDate
1812 
     - toShippingDate
1813 
     - providerId
1814 
     - warehouseId
3451 chandransh 1815 
     - cod
3427 chandransh 1816 
    """
3451 chandransh 1817 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1818 
    return self.recv_getOrdersByShippingDate()
1819 
 
3451 chandransh 1820 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1821 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1822 
    args = getOrdersByShippingDate_args()
1823 
    args.fromShippingDate = fromShippingDate
1824 
    args.toShippingDate = toShippingDate
1825 
    args.providerId = providerId
1826 
    args.warehouseId = warehouseId
3451 chandransh 1827 
    args.cod = cod
3427 chandransh 1828 
    args.write(self._oprot)
1829 
    self._oprot.writeMessageEnd()
1830 
    self._oprot.trans.flush()
1831 
 
1832 
  def recv_getOrdersByShippingDate(self, ):
1833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1834 
    if mtype == TMessageType.EXCEPTION:
1835 
      x = TApplicationException()
1836 
      x.read(self._iprot)
1837 
      self._iprot.readMessageEnd()
1838 
      raise x
1839 
    result = getOrdersByShippingDate_result()
1840 
    result.read(self._iprot)
1841 
    self._iprot.readMessageEnd()
3431 rajveer 1842 
    if result.success is not None:
3427 chandransh 1843 
      return result.success
3431 rajveer 1844 
    if result.ex is not None:
3427 chandransh 1845 
      raise result.ex
1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1847 
 
1382 varun.gupt 1848 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1849 
    """
1850 
    Returns order ids for orders which can be returned
3431 rajveer 1851 
 
1382 varun.gupt 1852 
    Parameters:
1853 
     - customer_id
1854 
     - limit
1855 
    """
1856 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1857 
    return self.recv_getReturnableOrdersForCustomer()
1858 
 
1859 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1860 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1861 
    args = getReturnableOrdersForCustomer_args()
1862 
    args.customer_id = customer_id
1863 
    args.limit = limit
1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
1868 
  def recv_getReturnableOrdersForCustomer(self, ):
1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
1875 
    result = getReturnableOrdersForCustomer_result()
1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
3431 rajveer 1878 
    if result.success is not None:
1382 varun.gupt 1879 
      return result.success
3431 rajveer 1880 
    if result.ex is not None:
1382 varun.gupt 1881 
      raise result.ex
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1883 
 
1884 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1885 
    """
1886 
    Returns order ids for orders which can be cancelled
3431 rajveer 1887 
 
1382 varun.gupt 1888 
    Parameters:
1889 
     - customer_id
1890 
     - limit
1891 
    """
1892 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1893 
    return self.recv_getCancellableOrdersForCustomer()
1894 
 
1895 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1896 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1897 
    args = getCancellableOrdersForCustomer_args()
1898 
    args.customer_id = customer_id
1899 
    args.limit = limit
1900 
    args.write(self._oprot)
1901 
    self._oprot.writeMessageEnd()
1902 
    self._oprot.trans.flush()
1903 
 
1904 
  def recv_getCancellableOrdersForCustomer(self, ):
1905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1906 
    if mtype == TMessageType.EXCEPTION:
1907 
      x = TApplicationException()
1908 
      x.read(self._iprot)
1909 
      self._iprot.readMessageEnd()
1910 
      raise x
1911 
    result = getCancellableOrdersForCustomer_result()
1912 
    result.read(self._iprot)
1913 
    self._iprot.readMessageEnd()
3431 rajveer 1914 
    if result.success is not None:
1382 varun.gupt 1915 
      return result.success
3431 rajveer 1916 
    if result.ex is not None:
1382 varun.gupt 1917 
      raise result.ex
1918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1919 
 
483 rajveer 1920 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1921 
    """
1922 
    Parameters:
483 rajveer 1923 
     - orderId
1924 
     - status
1925 
     - description
94 ashish 1926 
    """
483 rajveer 1927 
    self.send_changeOrderStatus(orderId, status, description)
1928 
    return self.recv_changeOrderStatus()
94 ashish 1929 
 
483 rajveer 1930 
  def send_changeOrderStatus(self, orderId, status, description):
1931 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1932 
    args = changeOrderStatus_args()
1933 
    args.orderId = orderId
1934 
    args.status = status
1935 
    args.description = description
94 ashish 1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
483 rajveer 1940 
  def recv_changeOrderStatus(self, ):
94 ashish 1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
483 rajveer 1947 
    result = changeOrderStatus_result()
94 ashish 1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
3431 rajveer 1950 
    if result.success is not None:
94 ashish 1951 
      return result.success
3431 rajveer 1952 
    if result.ex is not None:
94 ashish 1953 
      raise result.ex
483 rajveer 1954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1955 
 
1528 ankur.sing 1956 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1957 
    """
1528 ankur.sing 1958 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1959 
    only user who owns the transaction can view its order details.
3431 rajveer 1960 
 
94 ashish 1961 
    Parameters:
1962 
     - transactionId
1528 ankur.sing 1963 
     - customerId
94 ashish 1964 
    """
1528 ankur.sing 1965 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1966 
    return self.recv_getOrdersForTransaction()
94 ashish 1967 
 
1528 ankur.sing 1968 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1969 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1970 
    args = getOrdersForTransaction_args()
94 ashish 1971 
    args.transactionId = transactionId
1528 ankur.sing 1972 
    args.customerId = customerId
94 ashish 1973 
    args.write(self._oprot)
1974 
    self._oprot.writeMessageEnd()
1975 
    self._oprot.trans.flush()
1976 
 
483 rajveer 1977 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1979 
    if mtype == TMessageType.EXCEPTION:
1980 
      x = TApplicationException()
1981 
      x.read(self._iprot)
1982 
      self._iprot.readMessageEnd()
1983 
      raise x
483 rajveer 1984 
    result = getOrdersForTransaction_result()
94 ashish 1985 
    result.read(self._iprot)
1986 
    self._iprot.readMessageEnd()
3431 rajveer 1987 
    if result.success is not None:
94 ashish 1988 
      return result.success
3431 rajveer 1989 
    if result.ex is not None:
94 ashish 1990 
      raise result.ex
483 rajveer 1991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1992 
 
3014 chandransh 1993 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1994 
    """
3014 chandransh 1995 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1996 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1997 
 
94 ashish 1998 
    Parameters:
483 rajveer 1999 
     - customerId
2000 
     - from_date
2001 
     - to_date
3014 chandransh 2002 
     - statuses
94 ashish 2003 
    """
3014 chandransh 2004 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2005 
    return self.recv_getOrdersForCustomer()
94 ashish 2006 
 
3014 chandransh 2007 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2008 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2009 
    args = getOrdersForCustomer_args()
2010 
    args.customerId = customerId
2011 
    args.from_date = from_date
2012 
    args.to_date = to_date
3014 chandransh 2013 
    args.statuses = statuses
94 ashish 2014 
    args.write(self._oprot)
2015 
    self._oprot.writeMessageEnd()
2016 
    self._oprot.trans.flush()
2017 
 
483 rajveer 2018 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2020 
    if mtype == TMessageType.EXCEPTION:
2021 
      x = TApplicationException()
2022 
      x.read(self._iprot)
2023 
      self._iprot.readMessageEnd()
2024 
      raise x
483 rajveer 2025 
    result = getOrdersForCustomer_result()
94 ashish 2026 
    result.read(self._iprot)
2027 
    self._iprot.readMessageEnd()
3431 rajveer 2028 
    if result.success is not None:
94 ashish 2029 
      return result.success
3431 rajveer 2030 
    if result.ex is not None:
94 ashish 2031 
      raise result.ex
483 rajveer 2032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2033 
 
483 rajveer 2034 
  def createOrder(self, order):
94 ashish 2035 
    """
2036 
    Parameters:
483 rajveer 2037 
     - order
94 ashish 2038 
    """
483 rajveer 2039 
    self.send_createOrder(order)
2040 
    return self.recv_createOrder()
94 ashish 2041 
 
483 rajveer 2042 
  def send_createOrder(self, order):
2043 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2044 
    args = createOrder_args()
2045 
    args.order = order
94 ashish 2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
483 rajveer 2050 
  def recv_createOrder(self, ):
94 ashish 2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
483 rajveer 2057 
    result = createOrder_result()
94 ashish 2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
3431 rajveer 2060 
    if result.success is not None:
94 ashish 2061 
      return result.success
3431 rajveer 2062 
    if result.ex is not None:
94 ashish 2063 
      raise result.ex
483 rajveer 2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2065 
 
483 rajveer 2066 
  def getOrder(self, id):
94 ashish 2067 
    """
2068 
    Parameters:
483 rajveer 2069 
     - id
94 ashish 2070 
    """
483 rajveer 2071 
    self.send_getOrder(id)
2072 
    return self.recv_getOrder()
94 ashish 2073 
 
483 rajveer 2074 
  def send_getOrder(self, id):
2075 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2076 
    args = getOrder_args()
2077 
    args.id = id
94 ashish 2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
483 rajveer 2082 
  def recv_getOrder(self, ):
94 ashish 2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
483 rajveer 2089 
    result = getOrder_result()
94 ashish 2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
3431 rajveer 2092 
    if result.success is not None:
94 ashish 2093 
      return result.success
3431 rajveer 2094 
    if result.ex is not None:
94 ashish 2095 
      raise result.ex
483 rajveer 2096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2097 
 
483 rajveer 2098 
  def getLineItemsForOrder(self, orderId):
94 ashish 2099 
    """
2100 
    Parameters:
483 rajveer 2101 
     - orderId
94 ashish 2102 
    """
483 rajveer 2103 
    self.send_getLineItemsForOrder(orderId)
2104 
    return self.recv_getLineItemsForOrder()
94 ashish 2105 
 
483 rajveer 2106 
  def send_getLineItemsForOrder(self, orderId):
2107 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2108 
    args = getLineItemsForOrder_args()
2109 
    args.orderId = orderId
94 ashish 2110 
    args.write(self._oprot)
2111 
    self._oprot.writeMessageEnd()
2112 
    self._oprot.trans.flush()
2113 
 
483 rajveer 2114 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2116 
    if mtype == TMessageType.EXCEPTION:
2117 
      x = TApplicationException()
2118 
      x.read(self._iprot)
2119 
      self._iprot.readMessageEnd()
2120 
      raise x
483 rajveer 2121 
    result = getLineItemsForOrder_result()
94 ashish 2122 
    result.read(self._iprot)
2123 
    self._iprot.readMessageEnd()
3431 rajveer 2124 
    if result.success is not None:
94 ashish 2125 
      return result.success
3431 rajveer 2126 
    if result.ex is not None:
94 ashish 2127 
      raise result.ex
483 rajveer 2128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2129 
 
4999 phani.kuma 2130 
  def getOrderList(self, order_ids):
2131 
    """
2132 
    Parameters:
2133 
     - order_ids
2134 
    """
2135 
    self.send_getOrderList(order_ids)
2136 
    return self.recv_getOrderList()
2137 
 
2138 
  def send_getOrderList(self, order_ids):
2139 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2140 
    args = getOrderList_args()
2141 
    args.order_ids = order_ids
2142 
    args.write(self._oprot)
2143 
    self._oprot.writeMessageEnd()
2144 
    self._oprot.trans.flush()
2145 
 
2146 
  def recv_getOrderList(self, ):
2147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2148 
    if mtype == TMessageType.EXCEPTION:
2149 
      x = TApplicationException()
2150 
      x.read(self._iprot)
2151 
      self._iprot.readMessageEnd()
2152 
      raise x
2153 
    result = getOrderList_result()
2154 
    result.read(self._iprot)
2155 
    self._iprot.readMessageEnd()
2156 
    if result.success is not None:
2157 
      return result.success
2158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2159 
 
5386 phani.kuma 2160 
  def getOrderListForVendor(self, order_ids, vendorId):
2161 
    """
2162 
    Parameters:
2163 
     - order_ids
2164 
     - vendorId
2165 
    """
2166 
    self.send_getOrderListForVendor(order_ids, vendorId)
2167 
    return self.recv_getOrderListForVendor()
2168 
 
2169 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2170 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2171 
    args = getOrderListForVendor_args()
2172 
    args.order_ids = order_ids
2173 
    args.vendorId = vendorId
2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
2178 
  def recv_getOrderListForVendor(self, ):
2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
2185 
    result = getOrderListForVendor_result()
2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
2188 
    if result.success is not None:
2189 
      return result.success
2190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2191 
 
1528 ankur.sing 2192 
  def getOrderForCustomer(self, orderId, customerId):
2193 
    """
2194 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2195 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2196 
 
1528 ankur.sing 2197 
    Parameters:
2198 
     - orderId
2199 
     - customerId
2200 
    """
2201 
    self.send_getOrderForCustomer(orderId, customerId)
2202 
    return self.recv_getOrderForCustomer()
2203 
 
2204 
  def send_getOrderForCustomer(self, orderId, customerId):
2205 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2206 
    args = getOrderForCustomer_args()
2207 
    args.orderId = orderId
2208 
    args.customerId = customerId
2209 
    args.write(self._oprot)
2210 
    self._oprot.writeMessageEnd()
2211 
    self._oprot.trans.flush()
2212 
 
2213 
  def recv_getOrderForCustomer(self, ):
2214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2215 
    if mtype == TMessageType.EXCEPTION:
2216 
      x = TApplicationException()
2217 
      x.read(self._iprot)
2218 
      self._iprot.readMessageEnd()
2219 
      raise x
2220 
    result = getOrderForCustomer_result()
2221 
    result.read(self._iprot)
2222 
    self._iprot.readMessageEnd()
3431 rajveer 2223 
    if result.success is not None:
1528 ankur.sing 2224 
      return result.success
3431 rajveer 2225 
    if result.ex is not None:
1528 ankur.sing 2226 
      raise result.ex
2227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2228 
 
4444 rajveer 2229 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2230 
    """
2231 
    Parameters:
4394 rajveer 2232 
     - type
4444 rajveer 2233 
     - warehouseId
4394 rajveer 2234 
     - status
2235 
     - timestamp
3064 chandransh 2236 
    """
4444 rajveer 2237 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2238 
    return self.recv_getAlerts()
2239 
 
4444 rajveer 2240 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2241 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2242 
    args = getAlerts_args()
4394 rajveer 2243 
    args.type = type
4444 rajveer 2244 
    args.warehouseId = warehouseId
4394 rajveer 2245 
    args.status = status
2246 
    args.timestamp = timestamp
3064 chandransh 2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2251 
  def recv_getAlerts(self, ):
2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2258 
    result = getAlerts_result()
2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
3431 rajveer 2261 
    if result.success is not None:
3064 chandransh 2262 
      return result.success
2263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2264 
 
4444 rajveer 2265 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2266 
    """
2267 
    Parameters:
2268 
     - type
4444 rajveer 2269 
     - warehouseId
4394 rajveer 2270 
     - description
3064 chandransh 2271 
    """
4444 rajveer 2272 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2273 
    self.recv_addAlert()
3064 chandransh 2274 
 
4444 rajveer 2275 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2276 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2277 
    args = addAlert_args()
3064 chandransh 2278 
    args.type = type
4444 rajveer 2279 
    args.warehouseId = warehouseId
4394 rajveer 2280 
    args.description = description
3064 chandransh 2281 
    args.write(self._oprot)
2282 
    self._oprot.writeMessageEnd()
2283 
    self._oprot.trans.flush()
2284 
 
4394 rajveer 2285 
  def recv_addAlert(self, ):
3064 chandransh 2286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2287 
    if mtype == TMessageType.EXCEPTION:
2288 
      x = TApplicationException()
2289 
      x.read(self._iprot)
2290 
      self._iprot.readMessageEnd()
2291 
      raise x
4394 rajveer 2292 
    result = addAlert_result()
3064 chandransh 2293 
    result.read(self._iprot)
2294 
    self._iprot.readMessageEnd()
2295 
    return
2296 
 
4444 rajveer 2297 
  def markAlertsAsSeen(self, warehouseId):
2298 
    """
2299 
    Parameters:
2300 
     - warehouseId
2301 
    """
2302 
    self.send_markAlertsAsSeen(warehouseId)
2303 
    self.recv_markAlertsAsSeen()
2304 
 
2305 
  def send_markAlertsAsSeen(self, warehouseId):
2306 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2307 
    args = markAlertsAsSeen_args()
2308 
    args.warehouseId = warehouseId
2309 
    args.write(self._oprot)
2310 
    self._oprot.writeMessageEnd()
2311 
    self._oprot.trans.flush()
2312 
 
2313 
  def recv_markAlertsAsSeen(self, ):
2314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2315 
    if mtype == TMessageType.EXCEPTION:
2316 
      x = TApplicationException()
2317 
      x.read(self._iprot)
2318 
      self._iprot.readMessageEnd()
2319 
      raise x
2320 
    result = markAlertsAsSeen_result()
2321 
    result.read(self._iprot)
2322 
    self._iprot.readMessageEnd()
2323 
    return
2324 
 
3064 chandransh 2325 
  def getValidOrderCount(self, ):
2326 
    """
2327 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2328 
    """
2329 
    self.send_getValidOrderCount()
2330 
    return self.recv_getValidOrderCount()
2331 
 
2332 
  def send_getValidOrderCount(self, ):
2333 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2334 
    args = getValidOrderCount_args()
2335 
    args.write(self._oprot)
2336 
    self._oprot.writeMessageEnd()
2337 
    self._oprot.trans.flush()
2338 
 
2339 
  def recv_getValidOrderCount(self, ):
2340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2341 
    if mtype == TMessageType.EXCEPTION:
2342 
      x = TApplicationException()
2343 
      x.read(self._iprot)
2344 
      self._iprot.readMessageEnd()
2345 
      raise x
2346 
    result = getValidOrderCount_result()
2347 
    result.read(self._iprot)
2348 
    self._iprot.readMessageEnd()
3431 rajveer 2349 
    if result.success is not None:
3064 chandransh 2350 
      return result.success
2351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2352 
 
2353 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2354 
    """
2355 
    Returns the number of distinct customers who have done successful transactions
2356 
    """
2357 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2358 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2359 
 
2360 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2361 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2362 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
3431 rajveer 2377 
    if result.success is not None:
3064 chandransh 2378 
      return result.success
2379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2380 
 
2381 
  def getValidOrdersAmountRange(self, ):
2382 
    """
2383 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2384 
    List contains two values, first minimum amount and second maximum amount.
2385 
    """
2386 
    self.send_getValidOrdersAmountRange()
2387 
    return self.recv_getValidOrdersAmountRange()
2388 
 
2389 
  def send_getValidOrdersAmountRange(self, ):
2390 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2391 
    args = getValidOrdersAmountRange_args()
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_getValidOrdersAmountRange(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = getValidOrdersAmountRange_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
3431 rajveer 2406 
    if result.success is not None:
3064 chandransh 2407 
      return result.success
2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2409 
 
5874 rajveer 2410 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2411 
    """
2412 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2413 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2414 
 
3064 chandransh 2415 
    Parameters:
2416 
     - limit
5874 rajveer 2417 
     - onlyStore
3064 chandransh 2418 
    """
5874 rajveer 2419 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2420 
    return self.recv_getValidOrders()
2421 
 
5874 rajveer 2422 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2423 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2424 
    args = getValidOrders_args()
2425 
    args.limit = limit
5874 rajveer 2426 
    args.onlyStore = onlyStore
3064 chandransh 2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
2431 
  def recv_getValidOrders(self, ):
2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
2438 
    result = getValidOrders_result()
2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
3431 rajveer 2441 
    if result.success is not None:
3064 chandransh 2442 
      return result.success
2443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2444 
 
1220 chandransh 2445 
  def batchOrders(self, warehouseId):
2446 
    """
2447 
    Create a batch of all the pending orders for the given warehouse.
2448 
    The returned list is orderd by created_timestamp.
2449 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2450 
 
1220 chandransh 2451 
    Parameters:
2452 
     - warehouseId
2453 
    """
2454 
    self.send_batchOrders(warehouseId)
2455 
    return self.recv_batchOrders()
2456 
 
2457 
  def send_batchOrders(self, warehouseId):
2458 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2459 
    args = batchOrders_args()
2460 
    args.warehouseId = warehouseId
2461 
    args.write(self._oprot)
2462 
    self._oprot.writeMessageEnd()
2463 
    self._oprot.trans.flush()
2464 
 
2465 
  def recv_batchOrders(self, ):
2466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2467 
    if mtype == TMessageType.EXCEPTION:
2468 
      x = TApplicationException()
2469 
      x.read(self._iprot)
2470 
      self._iprot.readMessageEnd()
2471 
      raise x
2472 
    result = batchOrders_result()
2473 
    result.read(self._iprot)
2474 
    self._iprot.readMessageEnd()
3431 rajveer 2475 
    if result.success is not None:
1220 chandransh 2476 
      return result.success
3431 rajveer 2477 
    if result.ex is not None:
1220 chandransh 2478 
      raise result.ex
2479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2480 
 
1208 chandransh 2481 
  def markOrderAsOutOfStock(self, orderId):
2482 
    """
2483 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2484 
 
1208 chandransh 2485 
    Parameters:
2486 
     - orderId
2487 
    """
2488 
    self.send_markOrderAsOutOfStock(orderId)
2489 
    return self.recv_markOrderAsOutOfStock()
2490 
 
2491 
  def send_markOrderAsOutOfStock(self, orderId):
2492 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2493 
    args = markOrderAsOutOfStock_args()
2494 
    args.orderId = orderId
2495 
    args.write(self._oprot)
2496 
    self._oprot.writeMessageEnd()
2497 
    self._oprot.trans.flush()
2498 
 
2499 
  def recv_markOrderAsOutOfStock(self, ):
2500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2501 
    if mtype == TMessageType.EXCEPTION:
2502 
      x = TApplicationException()
2503 
      x.read(self._iprot)
2504 
      self._iprot.readMessageEnd()
2505 
      raise x
2506 
    result = markOrderAsOutOfStock_result()
2507 
    result.read(self._iprot)
2508 
    self._iprot.readMessageEnd()
3431 rajveer 2509 
    if result.success is not None:
1208 chandransh 2510 
      return result.success
3431 rajveer 2511 
    if result.ex is not None:
1208 chandransh 2512 
      raise result.ex
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2514 
 
3064 chandransh 2515 
  def verifyOrder(self, orderId):
759 chandransh 2516 
    """
3064 chandransh 2517 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2518 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2519 
    used for all other orders as well.
2520 
    Throws an exception if no such order exists.
3431 rajveer 2521 
 
759 chandransh 2522 
    Parameters:
3064 chandransh 2523 
     - orderId
759 chandransh 2524 
    """
3064 chandransh 2525 
    self.send_verifyOrder(orderId)
2526 
    return self.recv_verifyOrder()
759 chandransh 2527 
 
3064 chandransh 2528 
  def send_verifyOrder(self, orderId):
2529 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2530 
    args = verifyOrder_args()
2531 
    args.orderId = orderId
759 chandransh 2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
3064 chandransh 2536 
  def recv_verifyOrder(self, ):
759 chandransh 2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
3064 chandransh 2543 
    result = verifyOrder_result()
759 chandransh 2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
3431 rajveer 2546 
    if result.success is not None:
759 chandransh 2547 
      return result.success
3431 rajveer 2548 
    if result.ex is not None:
759 chandransh 2549 
      raise result.ex
3064 chandransh 2550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2551 
 
3064 chandransh 2552 
  def acceptOrder(self, orderId):
1113 chandransh 2553 
    """
3064 chandransh 2554 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2555 
    given order is not a COD order, it also captures the payment if the same has
2556 
    not been captured.
2557 
    Throws an exception if no such order exists.
3431 rajveer 2558 
 
1113 chandransh 2559 
    Parameters:
3064 chandransh 2560 
     - orderId
1113 chandransh 2561 
    """
3064 chandransh 2562 
    self.send_acceptOrder(orderId)
2563 
    return self.recv_acceptOrder()
1113 chandransh 2564 
 
3064 chandransh 2565 
  def send_acceptOrder(self, orderId):
2566 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2567 
    args = acceptOrder_args()
2568 
    args.orderId = orderId
1113 chandransh 2569 
    args.write(self._oprot)
2570 
    self._oprot.writeMessageEnd()
2571 
    self._oprot.trans.flush()
2572 
 
3064 chandransh 2573 
  def recv_acceptOrder(self, ):
1113 chandransh 2574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2575 
    if mtype == TMessageType.EXCEPTION:
2576 
      x = TApplicationException()
2577 
      x.read(self._iprot)
2578 
      self._iprot.readMessageEnd()
2579 
      raise x
3064 chandransh 2580 
    result = acceptOrder_result()
1113 chandransh 2581 
    result.read(self._iprot)
2582 
    self._iprot.readMessageEnd()
3431 rajveer 2583 
    if result.success is not None:
1113 chandransh 2584 
      return result.success
3431 rajveer 2585 
    if result.ex is not None:
1113 chandransh 2586 
      raise result.ex
3064 chandransh 2587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2588 
 
5110 mandeep.dh 2589 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2590 
    """
3064 chandransh 2591 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2592 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2593 
    the IMEI no. if a -1 is supplied.
2594 
    Also, it generates an invoice number for the order, marks the order as
2595 
    BILLED and sets the billing timestamp.
2596 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2597 
 
1135 chandransh 2598 
    Parameters:
3064 chandransh 2599 
     - orderId
2600 
     - invoice_number
4658 mandeep.dh 2601 
     - serialNumber
4283 anupam.sin 2602 
     - itemNumber
3064 chandransh 2603 
     - billed_by
4264 rajveer 2604 
     - jacketNumber
4283 anupam.sin 2605 
     - billingType
5110 mandeep.dh 2606 
     - fulfilmentWarehouseId
4763 rajveer 2607 
     - authorize
1135 chandransh 2608 
    """
5110 mandeep.dh 2609 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2610 
    return self.recv_addBillingDetails()
1135 chandransh 2611 
 
5110 mandeep.dh 2612 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2613 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2614 
    args = addBillingDetails_args()
2615 
    args.orderId = orderId
2616 
    args.invoice_number = invoice_number
4658 mandeep.dh 2617 
    args.serialNumber = serialNumber
4283 anupam.sin 2618 
    args.itemNumber = itemNumber
3064 chandransh 2619 
    args.billed_by = billed_by
4264 rajveer 2620 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2621 
    args.billingType = billingType
5110 mandeep.dh 2622 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2623 
    args.authorize = authorize
1135 chandransh 2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
3064 chandransh 2628 
  def recv_addBillingDetails(self, ):
1135 chandransh 2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
3064 chandransh 2635 
    result = addBillingDetails_result()
1135 chandransh 2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
3431 rajveer 2638 
    if result.success is not None:
3064 chandransh 2639 
      return result.success
3431 rajveer 2640 
    if result.ex is not None:
1135 chandransh 2641 
      raise result.ex
3064 chandransh 2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2643 
 
4763 rajveer 2644 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2645 
    """
2646 
    Add the invoice number to the order.
2647 
 
2648 
    Parameters:
2649 
     - orderId
2650 
     - invoiceNumber
4763 rajveer 2651 
     - color
4579 rajveer 2652 
    """
4763 rajveer 2653 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2654 
    self.recv_addInvoiceNumber()
2655 
 
4763 rajveer 2656 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2657 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2658 
    args = addInvoiceNumber_args()
2659 
    args.orderId = orderId
2660 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2661 
    args.color = color
4579 rajveer 2662 
    args.write(self._oprot)
2663 
    self._oprot.writeMessageEnd()
2664 
    self._oprot.trans.flush()
2665 
 
2666 
  def recv_addInvoiceNumber(self, ):
2667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2668 
    if mtype == TMessageType.EXCEPTION:
2669 
      x = TApplicationException()
2670 
      x.read(self._iprot)
2671 
      self._iprot.readMessageEnd()
2672 
      raise x
2673 
    result = addInvoiceNumber_result()
2674 
    result.read(self._iprot)
2675 
    self._iprot.readMessageEnd()
2676 
    if result.ex is not None:
2677 
      raise result.ex
2678 
    return
2679 
 
4910 phani.kuma 2680 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2681 
    """
3064 chandransh 2682 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2683 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2684 
 
1408 ankur.sing 2685 
    Parameters:
3064 chandransh 2686 
     - warehouseId
1408 ankur.sing 2687 
     - providerId
3064 chandransh 2688 
     - cod
4910 phani.kuma 2689 
     - orderIds
1408 ankur.sing 2690 
    """
4910 phani.kuma 2691 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2692 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2693 
 
4910 phani.kuma 2694 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2695 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2696 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2697 
    args.warehouseId = warehouseId
1408 ankur.sing 2698 
    args.providerId = providerId
3064 chandransh 2699 
    args.cod = cod
4910 phani.kuma 2700 
    args.orderIds = orderIds
1408 ankur.sing 2701 
    args.write(self._oprot)
2702 
    self._oprot.writeMessageEnd()
2703 
    self._oprot.trans.flush()
2704 
 
4910 phani.kuma 2705 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2707 
    if mtype == TMessageType.EXCEPTION:
2708 
      x = TApplicationException()
2709 
      x.read(self._iprot)
2710 
      self._iprot.readMessageEnd()
2711 
      raise x
4910 phani.kuma 2712 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2713 
    result.read(self._iprot)
2714 
    self._iprot.readMessageEnd()
3431 rajveer 2715 
    if result.success is not None:
1408 ankur.sing 2716 
      return result.success
3431 rajveer 2717 
    if result.ex is not None:
3064 chandransh 2718 
      raise result.ex
4910 phani.kuma 2719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2720 
 
5713 rajveer 2721 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2722 
    """
2723 
    Parameters:
2724 
     - providerId
2725 
     - orderIds
5713 rajveer 2726 
     - awbs
5676 rajveer 2727 
    """
5713 rajveer 2728 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2729 
    return self.recv_markOrdersAsReturnedFromStore()
2730 
 
5713 rajveer 2731 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2732 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2733 
    args = markOrdersAsReturnedFromStore_args()
2734 
    args.providerId = providerId
2735 
    args.orderIds = orderIds
5713 rajveer 2736 
    args.awbs = awbs
5676 rajveer 2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_markOrdersAsReturnedFromStore(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = markOrdersAsReturnedFromStore_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    if result.success is not None:
2752 
      return result.success
2753 
    if result.ex is not None:
2754 
      raise result.ex
2755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2756 
 
4910 phani.kuma 2757 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2758 
    """
4910 phani.kuma 2759 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2760 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2761 
 
2762 
    Parameters:
2763 
     - providerId
4910 phani.kuma 2764 
     - pickupDetails
4410 rajveer 2765 
    """
4910 phani.kuma 2766 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2767 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2768 
 
4910 phani.kuma 2769 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2770 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2771 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2772 
    args.providerId = providerId
4910 phani.kuma 2773 
    args.pickupDetails = pickupDetails
4410 rajveer 2774 
    args.write(self._oprot)
2775 
    self._oprot.writeMessageEnd()
2776 
    self._oprot.trans.flush()
2777 
 
4910 phani.kuma 2778 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2780 
    if mtype == TMessageType.EXCEPTION:
2781 
      x = TApplicationException()
2782 
      x.read(self._iprot)
2783 
      self._iprot.readMessageEnd()
2784 
      raise x
4910 phani.kuma 2785 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2786 
    result.read(self._iprot)
2787 
    self._iprot.readMessageEnd()
2788 
    if result.ex is not None:
2789 
      raise result.ex
4910 phani.kuma 2790 
    return
4410 rajveer 2791 
 
4910 phani.kuma 2792 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2793 
    """
3064 chandransh 2794 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2795 
 
94 ashish 2796 
    Parameters:
3064 chandransh 2797 
     - providerId
304 ashish 2798 
    """
4910 phani.kuma 2799 
    self.send_getOrdersNotPickedUp(providerId)
2800 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2801 
 
4910 phani.kuma 2802 
  def send_getOrdersNotPickedUp(self, providerId):
2803 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2804 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2805 
    args.providerId = providerId
304 ashish 2806 
    args.write(self._oprot)
2807 
    self._oprot.writeMessageEnd()
2808 
    self._oprot.trans.flush()
2809 
 
4910 phani.kuma 2810 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2812 
    if mtype == TMessageType.EXCEPTION:
2813 
      x = TApplicationException()
2814 
      x.read(self._iprot)
2815 
      self._iprot.readMessageEnd()
2816 
      raise x
4910 phani.kuma 2817 
    result = getOrdersNotPickedUp_result()
304 ashish 2818 
    result.read(self._iprot)
2819 
    self._iprot.readMessageEnd()
3431 rajveer 2820 
    if result.success is not None:
304 ashish 2821 
      return result.success
4910 phani.kuma 2822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2823 
 
3064 chandransh 2824 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2825 
    """
3064 chandransh 2826 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2827 
    the name of the receiver.
2828 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2829 
 
304 ashish 2830 
    Parameters:
3064 chandransh 2831 
     - providerId
2832 
     - deliveredOrders
304 ashish 2833 
    """
3064 chandransh 2834 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2835 
    self.recv_markOrdersAsDelivered()
304 ashish 2836 
 
3064 chandransh 2837 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2838 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2839 
    args = markOrdersAsDelivered_args()
2840 
    args.providerId = providerId
2841 
    args.deliveredOrders = deliveredOrders
304 ashish 2842 
    args.write(self._oprot)
2843 
    self._oprot.writeMessageEnd()
2844 
    self._oprot.trans.flush()
2845 
 
3064 chandransh 2846 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2848 
    if mtype == TMessageType.EXCEPTION:
2849 
      x = TApplicationException()
2850 
      x.read(self._iprot)
2851 
      self._iprot.readMessageEnd()
2852 
      raise x
3064 chandransh 2853 
    result = markOrdersAsDelivered_result()
304 ashish 2854 
    result.read(self._iprot)
2855 
    self._iprot.readMessageEnd()
3431 rajveer 2856 
    if result.ex is not None:
3064 chandransh 2857 
      raise result.ex
304 ashish 2858 
    return
2859 
 
4910 phani.kuma 2860 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2861 
    """
4910 phani.kuma 2862 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2863 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2864 
 
3064 chandransh 2865 
    Parameters:
2866 
     - providerId
2867 
     - returnedOrders
1596 ankur.sing 2868 
    """
4910 phani.kuma 2869 
    self.send_markAsRTOrders(providerId, returnedOrders)
2870 
    self.recv_markAsRTOrders()
304 ashish 2871 
 
4910 phani.kuma 2872 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2873 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2874 
    args = markAsRTOrders_args()
3064 chandransh 2875 
    args.providerId = providerId
2876 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
4910 phani.kuma 2881 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
4910 phani.kuma 2888 
    result = markAsRTOrders_result()
1596 ankur.sing 2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
3431 rajveer 2891 
    if result.ex is not None:
3064 chandransh 2892 
      raise result.ex
2893 
    return
1596 ankur.sing 2894 
 
4910 phani.kuma 2895 
  def getRTOrders(self, providerId):
2896 
    """
2897 
    Returns a list of orders that were returned by courier.
2898 
 
2899 
    Parameters:
2900 
     - providerId
2901 
    """
2902 
    self.send_getRTOrders(providerId)
2903 
    return self.recv_getRTOrders()
2904 
 
2905 
  def send_getRTOrders(self, providerId):
2906 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2907 
    args = getRTOrders_args()
2908 
    args.providerId = providerId
2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_getRTOrders(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = getRTOrders_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
2923 
    if result.success is not None:
2924 
      return result.success
2925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2926 
 
3064 chandransh 2927 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2928 
    """
3064 chandransh 2929 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2930 
 
3064 chandransh 2931 
    Parameters:
2932 
     - providerId
2933 
     - undeliveredOrders
1627 ankur.sing 2934 
    """
3064 chandransh 2935 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2936 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2937 
 
3064 chandransh 2938 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2939 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2940 
    args = updateNonDeliveryReason_args()
2941 
    args.providerId = providerId
2942 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
3064 chandransh 2947 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
3064 chandransh 2954 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
4910 phani.kuma 2957 
    if result.ex is not None:
2958 
      raise result.ex
2959 
    return
2960 
 
2961 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2962 
    """
2963 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2964 
 
2965 
    Parameters:
2966 
     - providerId
2967 
    """
2968 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2969 
    return self.recv_getNonDeliveredOrdersbyCourier()
2970 
 
2971 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2972 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2973 
    args = getNonDeliveredOrdersbyCourier_args()
2974 
    args.providerId = providerId
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = getNonDeliveredOrdersbyCourier_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
4581 phani.kuma 2989 
    if result.success is not None:
2990 
      return result.success
4910 phani.kuma 2991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2992 
 
2993 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2994 
    """
2995 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2996 
 
2997 
    Parameters:
2998 
     - providerId
2999 
     - local_connected_orders
3000 
    """
3001 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3002 
    self.recv_markOrdersAsLocalConnected()
3003 
 
3004 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3005 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3006 
    args = markOrdersAsLocalConnected_args()
3007 
    args.providerId = providerId
3008 
    args.local_connected_orders = local_connected_orders
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_markOrdersAsLocalConnected(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = markOrdersAsLocalConnected_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3431 rajveer 3023 
    if result.ex is not None:
3064 chandransh 3024 
      raise result.ex
4910 phani.kuma 3025 
    return
1627 ankur.sing 3026 
 
4910 phani.kuma 3027 
  def getOrdersNotLocalConnected(self, providerId):
3028 
    """
3029 
    Returns a list of orders that were picked up or shipped but pending local connection.
3030 
 
3031 
    Parameters:
3032 
     - providerId
3033 
    """
3034 
    self.send_getOrdersNotLocalConnected(providerId)
3035 
    return self.recv_getOrdersNotLocalConnected()
3036 
 
3037 
  def send_getOrdersNotLocalConnected(self, providerId):
3038 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3039 
    args = getOrdersNotLocalConnected_args()
3040 
    args.providerId = providerId
3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_getOrdersNotLocalConnected(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = getOrdersNotLocalConnected_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.success is not None:
3056 
      return result.success
3057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3058 
 
3059 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3060 
    """
3061 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3062 
 
3063 
    Parameters:
3064 
     - providerId
3065 
     - destination_city_reached_orders
3066 
    """
3067 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3068 
    self.recv_markOrdersAsDestinationCityReached()
3069 
 
3070 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3071 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3072 
    args = markOrdersAsDestinationCityReached_args()
3073 
    args.providerId = providerId
3074 
    args.destination_city_reached_orders = destination_city_reached_orders
3075 
    args.write(self._oprot)
3076 
    self._oprot.writeMessageEnd()
3077 
    self._oprot.trans.flush()
3078 
 
3079 
  def recv_markOrdersAsDestinationCityReached(self, ):
3080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3081 
    if mtype == TMessageType.EXCEPTION:
3082 
      x = TApplicationException()
3083 
      x.read(self._iprot)
3084 
      self._iprot.readMessageEnd()
3085 
      raise x
3086 
    result = markOrdersAsDestinationCityReached_result()
3087 
    result.read(self._iprot)
3088 
    self._iprot.readMessageEnd()
3089 
    if result.ex is not None:
3090 
      raise result.ex
3091 
    return
3092 
 
3093 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3094 
    """
3095 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3096 
 
3097 
    Parameters:
3098 
     - providerId
3099 
     - first_atdl_orders
3100 
    """
3101 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3102 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3103 
 
3104 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3105 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3106 
    args = markOrdersAsFirstDeliveryAttempted_args()
3107 
    args.providerId = providerId
3108 
    args.first_atdl_orders = first_atdl_orders
3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3113 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3120 
    result = markOrdersAsFirstDeliveryAttempted_result()
3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
3123 
    if result.ex is not None:
3124 
      raise result.ex
3125 
    return
3126 
 
3064 chandransh 3127 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3128 
    """
3064 chandransh 3129 
    Returns the list of orders whose delivery time has passed but have not been
3130 
    delivered yet for the given provider and warehouse. To get a complete list of
3131 
    undelivered orders, pass them as -1.
3132 
    Returns an empty list if no such orders exist.
3431 rajveer 3133 
 
1886 ankur.sing 3134 
    Parameters:
3064 chandransh 3135 
     - providerId
3136 
     - warehouseId
1886 ankur.sing 3137 
    """
3064 chandransh 3138 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3139 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3140 
 
3064 chandransh 3141 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3142 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3143 
    args = getUndeliveredOrders_args()
3144 
    args.providerId = providerId
3145 
    args.warehouseId = warehouseId
1886 ankur.sing 3146 
    args.write(self._oprot)
3147 
    self._oprot.writeMessageEnd()
3148 
    self._oprot.trans.flush()
3149 
 
3064 chandransh 3150 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3152 
    if mtype == TMessageType.EXCEPTION:
3153 
      x = TApplicationException()
3154 
      x.read(self._iprot)
3155 
      self._iprot.readMessageEnd()
3156 
      raise x
3064 chandransh 3157 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3158 
    result.read(self._iprot)
3159 
    self._iprot.readMessageEnd()
3431 rajveer 3160 
    if result.success is not None:
1886 ankur.sing 3161 
      return result.success
3064 chandransh 3162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3163 
 
4783 phani.kuma 3164 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3165 
    """
3166 
    Returns the list of orders whose expected delivery date has passed but have not been
3167 
    delivered yet.
3168 
    Returns an empty list if no such orders exist.
3169 
    """
3170 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3171 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3172 
 
3173 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3174 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3175 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3176 
    args.write(self._oprot)
3177 
    self._oprot.writeMessageEnd()
3178 
    self._oprot.trans.flush()
3179 
 
3180 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3182 
    if mtype == TMessageType.EXCEPTION:
3183 
      x = TApplicationException()
3184 
      x.read(self._iprot)
3185 
      self._iprot.readMessageEnd()
3186 
      raise x
3187 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3188 
    result.read(self._iprot)
3189 
    self._iprot.readMessageEnd()
3190 
    if result.success is not None:
3191 
      return result.success
3192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3193 
 
2536 chandransh 3194 
  def toggleDOAFlag(self, orderId):
3195 
    """
3196 
    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.
3197 
    Returns the final flag status.
3198 
    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 3199 
 
2536 chandransh 3200 
    Parameters:
3201 
     - orderId
3202 
    """
3203 
    self.send_toggleDOAFlag(orderId)
3204 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3205 
 
2536 chandransh 3206 
  def send_toggleDOAFlag(self, orderId):
3207 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3208 
    args = toggleDOAFlag_args()
3209 
    args.orderId = orderId
3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_toggleDOAFlag(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = toggleDOAFlag_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3431 rajveer 3224 
    if result.success is not None:
2536 chandransh 3225 
      return result.success
3431 rajveer 3226 
    if result.ex is not None:
2536 chandransh 3227 
      raise result.ex
3228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3229 
 
4712 rajveer 3230 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3231 
    """
3232 
    Parameters:
3233 
     - orderId
3234 
     - deliveryTimestamp
3235 
     - receiver
3236 
    """
3237 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3238 
    self.recv_markOrderAsDelivered()
3239 
 
3240 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3241 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3242 
    args = markOrderAsDelivered_args()
3243 
    args.orderId = orderId
3244 
    args.deliveryTimestamp = deliveryTimestamp
3245 
    args.receiver = receiver
3246 
    args.write(self._oprot)
3247 
    self._oprot.writeMessageEnd()
3248 
    self._oprot.trans.flush()
3249 
 
3250 
  def recv_markOrderAsDelivered(self, ):
3251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3252 
    if mtype == TMessageType.EXCEPTION:
3253 
      x = TApplicationException()
3254 
      x.read(self._iprot)
3255 
      self._iprot.readMessageEnd()
3256 
      raise x
3257 
    result = markOrderAsDelivered_result()
3258 
    result.read(self._iprot)
3259 
    self._iprot.readMessageEnd()
3260 
    if result.ex is not None:
3261 
      raise result.ex
3262 
    return
3263 
 
5553 rajveer 3264 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3265 
    """
3266 
    Parameters:
3267 
     - orderId
3268 
     - deliveryTimestamp
3269 
    """
3270 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3271 
    self.recv_markOrderAsReceivedAtStore()
3272 
 
3273 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3274 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3275 
    args = markOrderAsReceivedAtStore_args()
3276 
    args.orderId = orderId
3277 
    args.deliveryTimestamp = deliveryTimestamp
3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_markOrderAsReceivedAtStore(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = markOrderAsReceivedAtStore_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.ex is not None:
3293 
      raise result.ex
3294 
    return
3295 
 
4454 rajveer 3296 
  def markOrderDoaRequestReceived(self, orderId):
3297 
    """
3298 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3299 
 
3300 
    Parameters:
3301 
     - orderId
3302 
    """
3303 
    self.send_markOrderDoaRequestReceived(orderId)
3304 
    return self.recv_markOrderDoaRequestReceived()
3305 
 
3306 
  def send_markOrderDoaRequestReceived(self, orderId):
3307 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3308 
    args = markOrderDoaRequestReceived_args()
3309 
    args.orderId = orderId
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_markOrderDoaRequestReceived(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = markOrderDoaRequestReceived_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3324 
    if result.success is not None:
3325 
      return result.success
3326 
    if result.ex is not None:
3327 
      raise result.ex
3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3329 
 
3330 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3331 
    """
3332 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3333 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3334 
 
3335 
    Parameters:
3336 
     - orderId
3337 
     - isAuthorized
3338 
    """
3339 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3340 
    return self.recv_markOrderDoaRequestAuthorized()
3341 
 
3342 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3343 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3344 
    args = markOrderDoaRequestAuthorized_args()
3345 
    args.orderId = orderId
3346 
    args.isAuthorized = isAuthorized
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_markOrderDoaRequestAuthorized(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = markOrderDoaRequestAuthorized_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3361 
    if result.success is not None:
3362 
      return result.success
3363 
    if result.ex is not None:
3364 
      raise result.ex
3365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3366 
 
4488 rajveer 3367 
  def markOrderReturnRequestReceived(self, orderId):
3368 
    """
3369 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3370 
 
3371 
    Parameters:
3372 
     - orderId
3373 
    """
3374 
    self.send_markOrderReturnRequestReceived(orderId)
3375 
    return self.recv_markOrderReturnRequestReceived()
3376 
 
3377 
  def send_markOrderReturnRequestReceived(self, orderId):
3378 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3379 
    args = markOrderReturnRequestReceived_args()
3380 
    args.orderId = orderId
3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_markOrderReturnRequestReceived(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = markOrderReturnRequestReceived_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
3395 
    if result.success is not None:
3396 
      return result.success
3397 
    if result.ex is not None:
3398 
      raise result.ex
3399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3400 
 
3401 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3402 
    """
3403 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3404 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3405 
 
3406 
    Parameters:
3407 
     - orderId
3408 
     - isAuthorized
3409 
    """
3410 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3411 
    return self.recv_markOrderReturnRequestAuthorized()
3412 
 
3413 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3414 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3415 
    args = markOrderReturnRequestAuthorized_args()
3416 
    args.orderId = orderId
3417 
    args.isAuthorized = isAuthorized
3418 
    args.write(self._oprot)
3419 
    self._oprot.writeMessageEnd()
3420 
    self._oprot.trans.flush()
3421 
 
3422 
  def recv_markOrderReturnRequestAuthorized(self, ):
3423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3424 
    if mtype == TMessageType.EXCEPTION:
3425 
      x = TApplicationException()
3426 
      x.read(self._iprot)
3427 
      self._iprot.readMessageEnd()
3428 
      raise x
3429 
    result = markOrderReturnRequestAuthorized_result()
3430 
    result.read(self._iprot)
3431 
    self._iprot.readMessageEnd()
3432 
    if result.success is not None:
3433 
      return result.success
3434 
    if result.ex is not None:
3435 
      raise result.ex
3436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3437 
 
4579 rajveer 3438 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3439 
    """
3440 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3441 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3442 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3443 
    For any other status, it returns false.
3444 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3445 
 
2536 chandransh 3446 
    Parameters:
3447 
     - orderId
4579 rajveer 3448 
     - providerId
2536 chandransh 3449 
    """
4579 rajveer 3450 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3451 
    return self.recv_requestPickupNumber()
3452 
 
4579 rajveer 3453 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3454 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3455 
    args = requestPickupNumber_args()
3456 
    args.orderId = orderId
4579 rajveer 3457 
    args.providerId = providerId
2536 chandransh 3458 
    args.write(self._oprot)
3459 
    self._oprot.writeMessageEnd()
3460 
    self._oprot.trans.flush()
3461 
 
3462 
  def recv_requestPickupNumber(self, ):
3463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3464 
    if mtype == TMessageType.EXCEPTION:
3465 
      x = TApplicationException()
3466 
      x.read(self._iprot)
3467 
      self._iprot.readMessageEnd()
3468 
      raise x
3469 
    result = requestPickupNumber_result()
3470 
    result.read(self._iprot)
3471 
    self._iprot.readMessageEnd()
3431 rajveer 3472 
    if result.success is not None:
2536 chandransh 3473 
      return result.success
3431 rajveer 3474 
    if result.ex is not None:
2536 chandransh 3475 
      raise result.ex
3476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3477 
 
4602 rajveer 3478 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3479 
    """
4452 rajveer 3480 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3481 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3482 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3483 
    	3. Returns true
2591 chandransh 3484 
    If the order is in any other status, it returns false.
2536 chandransh 3485 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3486 
 
2536 chandransh 3487 
    Parameters:
3488 
     - orderId
3489 
     - pickupNumber
4602 rajveer 3490 
     - providerId
2536 chandransh 3491 
    """
4602 rajveer 3492 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3493 
    return self.recv_authorizePickup()
3494 
 
4602 rajveer 3495 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3496 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3497 
    args = authorizePickup_args()
3498 
    args.orderId = orderId
3499 
    args.pickupNumber = pickupNumber
4602 rajveer 3500 
    args.providerId = providerId
2536 chandransh 3501 
    args.write(self._oprot)
3502 
    self._oprot.writeMessageEnd()
3503 
    self._oprot.trans.flush()
3504 
 
3505 
  def recv_authorizePickup(self, ):
3506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3507 
    if mtype == TMessageType.EXCEPTION:
3508 
      x = TApplicationException()
3509 
      x.read(self._iprot)
3510 
      self._iprot.readMessageEnd()
3511 
      raise x
3512 
    result = authorizePickup_result()
3513 
    result.read(self._iprot)
3514 
    self._iprot.readMessageEnd()
3431 rajveer 3515 
    if result.success is not None:
2536 chandransh 3516 
      return result.success
3431 rajveer 3517 
    if result.ex is not None:
2536 chandransh 3518 
      raise result.ex
3519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3520 
 
2764 chandransh 3521 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3522 
    """
3523 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3524 
 
2764 chandransh 3525 
    Parameters:
3526 
     - providerId
3527 
     - pickupDetails
3528 
    """
3529 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3530 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3531 
 
3532 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3533 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3534 
    args = markDoasAsPickedUp_args()
3535 
    args.providerId = providerId
3536 
    args.pickupDetails = pickupDetails
3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
3541 
  def recv_markDoasAsPickedUp(self, ):
3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
3548 
    result = markDoasAsPickedUp_result()
3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
4910 phani.kuma 3551 
    return
3552 
 
3553 
  def getDoasNotPickedUp(self, providerId):
3554 
    """
3555 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3556 
 
3557 
    Parameters:
3558 
     - providerId
3559 
    """
3560 
    self.send_getDoasNotPickedUp(providerId)
3561 
    return self.recv_getDoasNotPickedUp()
3562 
 
3563 
  def send_getDoasNotPickedUp(self, providerId):
3564 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3565 
    args = getDoasNotPickedUp_args()
3566 
    args.providerId = providerId
3567 
    args.write(self._oprot)
3568 
    self._oprot.writeMessageEnd()
3569 
    self._oprot.trans.flush()
3570 
 
3571 
  def recv_getDoasNotPickedUp(self, ):
3572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3573 
    if mtype == TMessageType.EXCEPTION:
3574 
      x = TApplicationException()
3575 
      x.read(self._iprot)
3576 
      self._iprot.readMessageEnd()
3577 
      raise x
3578 
    result = getDoasNotPickedUp_result()
3579 
    result.read(self._iprot)
3580 
    self._iprot.readMessageEnd()
3431 rajveer 3581 
    if result.success is not None:
2764 chandransh 3582 
      return result.success
4910 phani.kuma 3583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3584 
 
4741 phani.kuma 3585 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3586 
    """
3587 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3588 
 
3589 
    Parameters:
3590 
     - providerId
3591 
     - pickupDetails
3592 
    """
3593 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3594 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3595 
 
3596 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3597 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3598 
    args = markReturnOrdersAsPickedUp_args()
3599 
    args.providerId = providerId
3600 
    args.pickupDetails = pickupDetails
3601 
    args.write(self._oprot)
3602 
    self._oprot.writeMessageEnd()
3603 
    self._oprot.trans.flush()
3604 
 
3605 
  def recv_markReturnOrdersAsPickedUp(self, ):
3606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3607 
    if mtype == TMessageType.EXCEPTION:
3608 
      x = TApplicationException()
3609 
      x.read(self._iprot)
3610 
      self._iprot.readMessageEnd()
3611 
      raise x
3612 
    result = markReturnOrdersAsPickedUp_result()
3613 
    result.read(self._iprot)
3614 
    self._iprot.readMessageEnd()
4910 phani.kuma 3615 
    return
3616 
 
3617 
  def getReturnOrdersNotPickedUp(self, providerId):
3618 
    """
3619 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3620 
 
3621 
    Parameters:
3622 
     - providerId
3623 
    """
3624 
    self.send_getReturnOrdersNotPickedUp(providerId)
3625 
    return self.recv_getReturnOrdersNotPickedUp()
3626 
 
3627 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3628 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3629 
    args = getReturnOrdersNotPickedUp_args()
3630 
    args.providerId = providerId
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_getReturnOrdersNotPickedUp(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = getReturnOrdersNotPickedUp_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
4741 phani.kuma 3645 
    if result.success is not None:
3646 
      return result.success
4910 phani.kuma 3647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3648 
 
4479 rajveer 3649 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3650 
    """
4452 rajveer 3651 
    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 3652 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3653 
    If the order is in any other state, it returns false.
3654 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3655 
 
2591 chandransh 3656 
    Parameters:
3657 
     - orderId
4479 rajveer 3658 
     - receiveCondition
2591 chandransh 3659 
    """
4479 rajveer 3660 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3661 
    return self.recv_receiveReturn()
2536 chandransh 3662 
 
4479 rajveer 3663 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3664 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3665 
    args = receiveReturn_args()
2591 chandransh 3666 
    args.orderId = orderId
4479 rajveer 3667 
    args.receiveCondition = receiveCondition
2591 chandransh 3668 
    args.write(self._oprot)
3669 
    self._oprot.writeMessageEnd()
3670 
    self._oprot.trans.flush()
3671 
 
2616 chandransh 3672 
  def recv_receiveReturn(self, ):
2591 chandransh 3673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3674 
    if mtype == TMessageType.EXCEPTION:
3675 
      x = TApplicationException()
3676 
      x.read(self._iprot)
3677 
      self._iprot.readMessageEnd()
3678 
      raise x
2616 chandransh 3679 
    result = receiveReturn_result()
2591 chandransh 3680 
    result.read(self._iprot)
3681 
    self._iprot.readMessageEnd()
3431 rajveer 3682 
    if result.success is not None:
2591 chandransh 3683 
      return result.success
3431 rajveer 3684 
    if result.ex is not None:
2591 chandransh 3685 
      raise result.ex
2616 chandransh 3686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3687 
 
3688 
  def validateDoa(self, orderId, isValid):
3689 
    """
4452 rajveer 3690 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3691 
    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 3692 
    If the order is in any other state, it returns false.
3693 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3694 
 
2591 chandransh 3695 
    Parameters:
3696 
     - orderId
3697 
     - isValid
3698 
    """
3699 
    self.send_validateDoa(orderId, isValid)
3700 
    return self.recv_validateDoa()
3701 
 
3702 
  def send_validateDoa(self, orderId, isValid):
3703 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3704 
    args = validateDoa_args()
3705 
    args.orderId = orderId
3706 
    args.isValid = isValid
3707 
    args.write(self._oprot)
3708 
    self._oprot.writeMessageEnd()
3709 
    self._oprot.trans.flush()
3710 
 
3711 
  def recv_validateDoa(self, ):
3712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3713 
    if mtype == TMessageType.EXCEPTION:
3714 
      x = TApplicationException()
3715 
      x.read(self._iprot)
3716 
      self._iprot.readMessageEnd()
3717 
      raise x
3718 
    result = validateDoa_result()
3719 
    result.read(self._iprot)
3720 
    self._iprot.readMessageEnd()
3431 rajveer 3721 
    if result.success is not None:
2591 chandransh 3722 
      return result.success
3431 rajveer 3723 
    if result.ex is not None:
2591 chandransh 3724 
      raise result.ex
3725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3726 
 
4495 rajveer 3727 
  def validateReturnProduct(self, orderId, isUsable):
3728 
    """
3729 
    Parameters:
3730 
     - orderId
3731 
     - isUsable
3732 
    """
3733 
    self.send_validateReturnProduct(orderId, isUsable)
3734 
    return self.recv_validateReturnProduct()
3735 
 
3736 
  def send_validateReturnProduct(self, orderId, isUsable):
3737 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3738 
    args = validateReturnProduct_args()
3739 
    args.orderId = orderId
3740 
    args.isUsable = isUsable
3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
3745 
  def recv_validateReturnProduct(self, ):
3746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3747 
    if mtype == TMessageType.EXCEPTION:
3748 
      x = TApplicationException()
3749 
      x.read(self._iprot)
3750 
      self._iprot.readMessageEnd()
3751 
      raise x
3752 
    result = validateReturnProduct_result()
3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
3755 
    if result.success is not None:
3756 
      return result.success
3757 
    if result.ex is not None:
3758 
      raise result.ex
3759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3760 
 
2616 chandransh 3761 
  def reshipOrder(self, orderId):
3762 
    """
4484 rajveer 3763 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3764 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3765 
    	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 3766 
 
3767 
    If the order is in DOA_CERT_VALID state, it does the following:
3768 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3769 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3770 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3771 
 
2616 chandransh 3772 
    Returns the id of the newly created order.
3431 rajveer 3773 
 
2616 chandransh 3774 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3775 
 
2616 chandransh 3776 
    Parameters:
3777 
     - orderId
3778 
    """
3779 
    self.send_reshipOrder(orderId)
3780 
    return self.recv_reshipOrder()
2591 chandransh 3781 
 
2616 chandransh 3782 
  def send_reshipOrder(self, orderId):
3783 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3784 
    args = reshipOrder_args()
3785 
    args.orderId = orderId
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_reshipOrder(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = reshipOrder_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
3431 rajveer 3800 
    if result.success is not None:
2616 chandransh 3801 
      return result.success
3431 rajveer 3802 
    if result.ex is not None:
2616 chandransh 3803 
      raise result.ex
3804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3805 
 
3226 chandransh 3806 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3807 
    """
4484 rajveer 3808 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3809 
    	1. Creates a refund request for batch processing.
3810 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3811 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3812 
 
2616 chandransh 3813 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3814 
    	1. Creates a refund request for batch processing.
3226 chandransh 3815 
    	2. Cancels the reservation of the item in the warehouse.
3816 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3817 
 
3226 chandransh 3818 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3819 
    	1. Cancels the reservation of the item in the warehouse.
3820 
    	2. Marks the current order as CANCELED.
3821 
 
3822 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3823 
 
2616 chandransh 3824 
    Returns True if it is successful, False otherwise.
3431 rajveer 3825 
 
2616 chandransh 3826 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3827 
 
2616 chandransh 3828 
    Parameters:
3829 
     - orderId
3226 chandransh 3830 
     - refundedBy
3831 
     - reason
2616 chandransh 3832 
    """
3226 chandransh 3833 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3834 
    return self.recv_refundOrder()
3835 
 
3226 chandransh 3836 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3837 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3838 
    args = refundOrder_args()
3839 
    args.orderId = orderId
3226 chandransh 3840 
    args.refundedBy = refundedBy
3841 
    args.reason = reason
2616 chandransh 3842 
    args.write(self._oprot)
3843 
    self._oprot.writeMessageEnd()
3844 
    self._oprot.trans.flush()
3845 
 
3846 
  def recv_refundOrder(self, ):
3847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3848 
    if mtype == TMessageType.EXCEPTION:
3849 
      x = TApplicationException()
3850 
      x.read(self._iprot)
3851 
      self._iprot.readMessageEnd()
3852 
      raise x
3853 
    result = refundOrder_result()
3854 
    result.read(self._iprot)
3855 
    self._iprot.readMessageEnd()
3431 rajveer 3856 
    if result.success is not None:
2616 chandransh 3857 
      return result.success
3431 rajveer 3858 
    if result.ex is not None:
2616 chandransh 3859 
      raise result.ex
3860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3861 
 
2690 chandransh 3862 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3863 
    """
3864 
    Get all return orders created between the from and to dates for the given warehouse.
3865 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3866 
 
2690 chandransh 3867 
    Parameters:
3868 
     - warehouseId
3869 
     - fromDate
3870 
     - toDate
3871 
    """
3872 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3873 
    return self.recv_getReturnOrders()
2616 chandransh 3874 
 
2690 chandransh 3875 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3876 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3877 
    args = getReturnOrders_args()
3878 
    args.warehouseId = warehouseId
3879 
    args.fromDate = fromDate
3880 
    args.toDate = toDate
3881 
    args.write(self._oprot)
3882 
    self._oprot.writeMessageEnd()
3883 
    self._oprot.trans.flush()
3884 
 
3885 
  def recv_getReturnOrders(self, ):
3886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3887 
    if mtype == TMessageType.EXCEPTION:
3888 
      x = TApplicationException()
3889 
      x.read(self._iprot)
3890 
      self._iprot.readMessageEnd()
3891 
      raise x
3892 
    result = getReturnOrders_result()
3893 
    result.read(self._iprot)
3894 
    self._iprot.readMessageEnd()
3431 rajveer 3895 
    if result.success is not None:
2690 chandransh 3896 
      return result.success
3897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3898 
 
5481 phani.kuma 3899 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3900 
    """
3901 
    Get all return orders created between the from and to dates.
3902 
 
3903 
    Parameters:
3904 
     - onlyNotProcessed
3905 
     - fromDate
3906 
     - toDate
3907 
    """
3908 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3909 
    return self.recv_getAllReturnOrders()
3910 
 
3911 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3912 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3913 
    args = getAllReturnOrders_args()
3914 
    args.onlyNotProcessed = onlyNotProcessed
3915 
    args.fromDate = fromDate
3916 
    args.toDate = toDate
3917 
    args.write(self._oprot)
3918 
    self._oprot.writeMessageEnd()
3919 
    self._oprot.trans.flush()
3920 
 
3921 
  def recv_getAllReturnOrders(self, ):
3922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3923 
    if mtype == TMessageType.EXCEPTION:
3924 
      x = TApplicationException()
3925 
      x.read(self._iprot)
3926 
      self._iprot.readMessageEnd()
3927 
      raise x
3928 
    result = getAllReturnOrders_result()
3929 
    result.read(self._iprot)
3930 
    self._iprot.readMessageEnd()
3931 
    if result.success is not None:
3932 
      return result.success
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3934 
 
2700 chandransh 3935 
  def getReturnOrder(self, id):
3936 
    """
3937 
    Returns the ReturnOrder corresponding to the given id.
3938 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3939 
 
2700 chandransh 3940 
    Parameters:
3941 
     - id
3942 
    """
3943 
    self.send_getReturnOrder(id)
3944 
    return self.recv_getReturnOrder()
3945 
 
3946 
  def send_getReturnOrder(self, id):
3947 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3948 
    args = getReturnOrder_args()
3949 
    args.id = id
3950 
    args.write(self._oprot)
3951 
    self._oprot.writeMessageEnd()
3952 
    self._oprot.trans.flush()
3953 
 
3954 
  def recv_getReturnOrder(self, ):
3955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3956 
    if mtype == TMessageType.EXCEPTION:
3957 
      x = TApplicationException()
3958 
      x.read(self._iprot)
3959 
      self._iprot.readMessageEnd()
3960 
      raise x
3961 
    result = getReturnOrder_result()
3962 
    result.read(self._iprot)
3963 
    self._iprot.readMessageEnd()
3431 rajveer 3964 
    if result.success is not None:
2700 chandransh 3965 
      return result.success
3431 rajveer 3966 
    if result.ex is not None:
2700 chandransh 3967 
      raise result.ex
3968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3969 
 
2690 chandransh 3970 
  def processReturn(self, returnOrderId):
3971 
    """
3972 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3973 
 
2690 chandransh 3974 
    Parameters:
3975 
     - returnOrderId
3976 
    """
3977 
    self.send_processReturn(returnOrderId)
3978 
    self.recv_processReturn()
3979 
 
3980 
  def send_processReturn(self, returnOrderId):
3981 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3982 
    args = processReturn_args()
3983 
    args.returnOrderId = returnOrderId
3984 
    args.write(self._oprot)
3985 
    self._oprot.writeMessageEnd()
3986 
    self._oprot.trans.flush()
3987 
 
3988 
  def recv_processReturn(self, ):
3989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3990 
    if mtype == TMessageType.EXCEPTION:
3991 
      x = TApplicationException()
3992 
      x.read(self._iprot)
3993 
      self._iprot.readMessageEnd()
3994 
      raise x
3995 
    result = processReturn_result()
3996 
    result.read(self._iprot)
3997 
    self._iprot.readMessageEnd()
3431 rajveer 3998 
    if result.ex is not None:
2690 chandransh 3999 
      raise result.ex
4000 
    return
4001 
 
3451 chandransh 4002 
  def updateWeight(self, orderId, weight):
4003 
    """
4004 
    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 4005 
 
3451 chandransh 4006 
    Parameters:
4007 
     - orderId
4008 
     - weight
4009 
    """
4010 
    self.send_updateWeight(orderId, weight)
4011 
    return self.recv_updateWeight()
4012 
 
4013 
  def send_updateWeight(self, orderId, weight):
4014 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4015 
    args = updateWeight_args()
4016 
    args.orderId = orderId
4017 
    args.weight = weight
4018 
    args.write(self._oprot)
4019 
    self._oprot.writeMessageEnd()
4020 
    self._oprot.trans.flush()
4021 
 
4022 
  def recv_updateWeight(self, ):
4023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4024 
    if mtype == TMessageType.EXCEPTION:
4025 
      x = TApplicationException()
4026 
      x.read(self._iprot)
4027 
      self._iprot.readMessageEnd()
4028 
      raise x
4029 
    result = updateWeight_result()
4030 
    result.read(self._iprot)
4031 
    self._iprot.readMessageEnd()
4032 
    if result.success is not None:
4033 
      return result.success
4034 
    if result.ex is not None:
4035 
      raise result.ex
4036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4037 
 
3469 chandransh 4038 
  def changeItem(self, orderId, itemId):
4039 
    """
4040 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4041 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4042 
 
3469 chandransh 4043 
    Parameters:
4044 
     - orderId
4045 
     - itemId
4046 
    """
4047 
    self.send_changeItem(orderId, itemId)
4048 
    return self.recv_changeItem()
4049 
 
4050 
  def send_changeItem(self, orderId, itemId):
4051 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4052 
    args = changeItem_args()
4053 
    args.orderId = orderId
4054 
    args.itemId = itemId
4055 
    args.write(self._oprot)
4056 
    self._oprot.writeMessageEnd()
4057 
    self._oprot.trans.flush()
4058 
 
4059 
  def recv_changeItem(self, ):
4060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4061 
    if mtype == TMessageType.EXCEPTION:
4062 
      x = TApplicationException()
4063 
      x.read(self._iprot)
4064 
      self._iprot.readMessageEnd()
4065 
      raise x
4066 
    result = changeItem_result()
4067 
    result.read(self._iprot)
4068 
    self._iprot.readMessageEnd()
4069 
    if result.success is not None:
4070 
      return result.success
4071 
    if result.ex is not None:
4072 
      raise result.ex
4073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4074 
 
4075 
  def shiftToWarehouse(self, orderId, warehouseId):
4076 
    """
4077 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4078 
 
4079 
    Parameters:
4080 
     - orderId
4081 
     - warehouseId
4082 
    """
4083 
    self.send_shiftToWarehouse(orderId, warehouseId)
4084 
    return self.recv_shiftToWarehouse()
4085 
 
4086 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4087 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4088 
    args = shiftToWarehouse_args()
4089 
    args.orderId = orderId
4090 
    args.warehouseId = warehouseId
4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_shiftToWarehouse(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = shiftToWarehouse_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
4105 
    if result.success is not None:
4106 
      return result.success
4107 
    if result.ex is not None:
4108 
      raise result.ex
4109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4110 
 
4647 rajveer 4111 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4112 
    """
4113 
    Adds the given delay reason to the given order.
3986 chandransh 4114 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4115 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4116 
 
3553 chandransh 4117 
    Parameters:
4118 
     - orderId
4119 
     - delayReason
3986 chandransh 4120 
     - furtherDelay
4647 rajveer 4121 
     - delayReasonText
3553 chandransh 4122 
    """
4647 rajveer 4123 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4124 
    return self.recv_addDelayReason()
4125 
 
4647 rajveer 4126 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4127 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4128 
    args = addDelayReason_args()
4129 
    args.orderId = orderId
4130 
    args.delayReason = delayReason
3986 chandransh 4131 
    args.furtherDelay = furtherDelay
4647 rajveer 4132 
    args.delayReasonText = delayReasonText
3553 chandransh 4133 
    args.write(self._oprot)
4134 
    self._oprot.writeMessageEnd()
4135 
    self._oprot.trans.flush()
4136 
 
4137 
  def recv_addDelayReason(self, ):
4138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4139 
    if mtype == TMessageType.EXCEPTION:
4140 
      x = TApplicationException()
4141 
      x.read(self._iprot)
4142 
      self._iprot.readMessageEnd()
4143 
      raise x
4144 
    result = addDelayReason_result()
4145 
    result.read(self._iprot)
4146 
    self._iprot.readMessageEnd()
4147 
    if result.success is not None:
4148 
      return result.success
4149 
    if result.ex is not None:
4150 
      raise result.ex
4151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4152 
 
3956 chandransh 4153 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4154 
    """
4155 
    Marks the COD orders with given AWB nos. as having been processed.
4156 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4157 
 
3956 chandransh 4158 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4159 
    1. There is no order corresponding to an AWB number.
4160 
    2. The captured amount for a payment exceeds the total payment.
4161 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4162 
 
4163 
    Parameters:
4164 
     - collectedAmountMap
4165 
     - xferBy
4166 
     - xferTxnId
4167 
     - xferDate
4168 
    """
4169 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4170 
    return self.recv_reconcileCodCollection()
4171 
 
4172 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4173 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4174 
    args = reconcileCodCollection_args()
4175 
    args.collectedAmountMap = collectedAmountMap
4176 
    args.xferBy = xferBy
4177 
    args.xferTxnId = xferTxnId
4178 
    args.xferDate = xferDate
4179 
    args.write(self._oprot)
4180 
    self._oprot.writeMessageEnd()
4181 
    self._oprot.trans.flush()
4182 
 
4183 
  def recv_reconcileCodCollection(self, ):
4184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4185 
    if mtype == TMessageType.EXCEPTION:
4186 
      x = TApplicationException()
4187 
      x.read(self._iprot)
4188 
      self._iprot.readMessageEnd()
4189 
      raise x
4190 
    result = reconcileCodCollection_result()
4191 
    result.read(self._iprot)
4192 
    self._iprot.readMessageEnd()
4193 
    if result.success is not None:
4194 
      return result.success
4195 
    if result.ex is not None:
4196 
      raise result.ex
4197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4198 
 
4008 mandeep.dh 4199 
  def getTransactionsRequiringExtraProcessing(self, category):
4200 
    """
4065 mandeep.dh 4201 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4202 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4203 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4204 
 
4008 mandeep.dh 4205 
    Parameters:
4206 
     - category
4207 
    """
4208 
    self.send_getTransactionsRequiringExtraProcessing(category)
4209 
    return self.recv_getTransactionsRequiringExtraProcessing()
4210 
 
4211 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4212 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4213 
    args = getTransactionsRequiringExtraProcessing_args()
4214 
    args.category = category
4215 
    args.write(self._oprot)
4216 
    self._oprot.writeMessageEnd()
4217 
    self._oprot.trans.flush()
4218 
 
4219 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4221 
    if mtype == TMessageType.EXCEPTION:
4222 
      x = TApplicationException()
4223 
      x.read(self._iprot)
4224 
      self._iprot.readMessageEnd()
4225 
      raise x
4226 
    result = getTransactionsRequiringExtraProcessing_result()
4227 
    result.read(self._iprot)
4228 
    self._iprot.readMessageEnd()
4229 
    if result.success is not None:
4230 
      return result.success
4231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4232 
 
4233 
  def markTransactionAsProcessed(self, transactionId, category):
4234 
    """
4235 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4236 
    It essentially deletes the transaction id record for a particular
4237 
    processing type category (if present) from DB.
4238 
    This is currently used by CRM application.
4008 mandeep.dh 4239 
 
4240 
    Parameters:
4241 
     - transactionId
4242 
     - category
4243 
    """
4244 
    self.send_markTransactionAsProcessed(transactionId, category)
4245 
    self.recv_markTransactionAsProcessed()
4246 
 
4247 
  def send_markTransactionAsProcessed(self, transactionId, category):
4248 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4249 
    args = markTransactionAsProcessed_args()
4250 
    args.transactionId = transactionId
4251 
    args.category = category
4252 
    args.write(self._oprot)
4253 
    self._oprot.writeMessageEnd()
4254 
    self._oprot.trans.flush()
4255 
 
4256 
  def recv_markTransactionAsProcessed(self, ):
4257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4258 
    if mtype == TMessageType.EXCEPTION:
4259 
      x = TApplicationException()
4260 
      x.read(self._iprot)
4261 
      self._iprot.readMessageEnd()
4262 
      raise x
4263 
    result = markTransactionAsProcessed_result()
4264 
    result.read(self._iprot)
4265 
    self._iprot.readMessageEnd()
4266 
    return
4267 
 
4018 chandransh 4268 
  def getItemWiseRiskyOrdersCount(self, ):
4269 
    """
4270 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4271 
    is defined as one whose shipping date is about to expire.
4272 
    """
4273 
    self.send_getItemWiseRiskyOrdersCount()
4274 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4275 
 
4018 chandransh 4276 
  def send_getItemWiseRiskyOrdersCount(self, ):
4277 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4278 
    args = getItemWiseRiskyOrdersCount_args()
4279 
    args.write(self._oprot)
4280 
    self._oprot.writeMessageEnd()
4281 
    self._oprot.trans.flush()
4282 
 
4283 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4285 
    if mtype == TMessageType.EXCEPTION:
4286 
      x = TApplicationException()
4287 
      x.read(self._iprot)
4288 
      self._iprot.readMessageEnd()
4289 
      raise x
4290 
    result = getItemWiseRiskyOrdersCount_result()
4291 
    result.read(self._iprot)
4292 
    self._iprot.readMessageEnd()
4293 
    if result.success is not None:
4294 
      return result.success
4295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4296 
 
4295 varun.gupt 4297 
  def getOrdersForItemIds(self, itemIds):
4298 
    """
4299 
    Returns a list of all orders which have items with given id
4300 
 
4301 
    Parameters:
4302 
     - itemIds
4303 
    """
4304 
    self.send_getOrdersForItemIds(itemIds)
4305 
    return self.recv_getOrdersForItemIds()
4306 
 
4307 
  def send_getOrdersForItemIds(self, itemIds):
4308 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4309 
    args = getOrdersForItemIds_args()
4310 
    args.itemIds = itemIds
4311 
    args.write(self._oprot)
4312 
    self._oprot.writeMessageEnd()
4313 
    self._oprot.trans.flush()
4314 
 
4315 
  def recv_getOrdersForItemIds(self, ):
4316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4317 
    if mtype == TMessageType.EXCEPTION:
4318 
      x = TApplicationException()
4319 
      x.read(self._iprot)
4320 
      self._iprot.readMessageEnd()
4321 
      raise x
4322 
    result = getOrdersForItemIds_result()
4323 
    result.read(self._iprot)
4324 
    self._iprot.readMessageEnd()
4325 
    if result.success is not None:
4326 
      return result.success
4327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4328 
 
4247 rajveer 4329 
  def markOrderCancellationRequestReceived(self, orderId):
4330 
    """
4331 
    Mark order as cancellation request received. If customer sends request of cancellation of
4332 
    a particular order, this method will be called. It will just change status of the order
4333 
    depending on its current status. It also records the previous status, so that we can move
4334 
    back to that status if cancellation request is denied.
4018 chandransh 4335 
 
4247 rajveer 4336 
    Parameters:
4337 
     - orderId
4338 
    """
4339 
    self.send_markOrderCancellationRequestReceived(orderId)
4340 
    self.recv_markOrderCancellationRequestReceived()
4341 
 
4342 
  def send_markOrderCancellationRequestReceived(self, orderId):
4343 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4344 
    args = markOrderCancellationRequestReceived_args()
4345 
    args.orderId = orderId
4346 
    args.write(self._oprot)
4347 
    self._oprot.writeMessageEnd()
4348 
    self._oprot.trans.flush()
4349 
 
4350 
  def recv_markOrderCancellationRequestReceived(self, ):
4351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4352 
    if mtype == TMessageType.EXCEPTION:
4353 
      x = TApplicationException()
4354 
      x.read(self._iprot)
4355 
      self._iprot.readMessageEnd()
4356 
      raise x
4357 
    result = markOrderCancellationRequestReceived_result()
4358 
    result.read(self._iprot)
4359 
    self._iprot.readMessageEnd()
4360 
    if result.ex is not None:
4361 
      raise result.ex
4362 
    return
4363 
 
4364 
  def markOrderCancellationRequestConfirmed(self, orderId):
4365 
    """
4366 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4367 
    cancellation request confirmed. After this OM will be able to cancel the order.
4368 
 
4369 
    Parameters:
4370 
     - orderId
4371 
    """
4372 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4373 
    self.recv_markOrderCancellationRequestConfirmed()
4374 
 
4375 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4376 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4377 
    args = markOrderCancellationRequestConfirmed_args()
4378 
    args.orderId = orderId
4379 
    args.write(self._oprot)
4380 
    self._oprot.writeMessageEnd()
4381 
    self._oprot.trans.flush()
4382 
 
4383 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4385 
    if mtype == TMessageType.EXCEPTION:
4386 
      x = TApplicationException()
4387 
      x.read(self._iprot)
4388 
      self._iprot.readMessageEnd()
4389 
      raise x
4390 
    result = markOrderCancellationRequestConfirmed_result()
4391 
    result.read(self._iprot)
4392 
    self._iprot.readMessageEnd()
4393 
    if result.ex is not None:
4394 
      raise result.ex
4395 
    return
4396 
 
4397 
  def markOrderCancellationRequestDenied(self, orderId):
4398 
    """
4399 
    If we decide to not to cancel order, we will move the order ro previous status.
4400 
 
4401 
    Parameters:
4402 
     - orderId
4403 
    """
4404 
    self.send_markOrderCancellationRequestDenied(orderId)
4405 
    self.recv_markOrderCancellationRequestDenied()
4406 
 
4407 
  def send_markOrderCancellationRequestDenied(self, orderId):
4408 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4409 
    args = markOrderCancellationRequestDenied_args()
4410 
    args.orderId = orderId
4411 
    args.write(self._oprot)
4412 
    self._oprot.writeMessageEnd()
4413 
    self._oprot.trans.flush()
4414 
 
4415 
  def recv_markOrderCancellationRequestDenied(self, ):
4416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4417 
    if mtype == TMessageType.EXCEPTION:
4418 
      x = TApplicationException()
4419 
      x.read(self._iprot)
4420 
      self._iprot.readMessageEnd()
4421 
      raise x
4422 
    result = markOrderCancellationRequestDenied_result()
4423 
    result.read(self._iprot)
4424 
    self._iprot.readMessageEnd()
4425 
    if result.ex is not None:
4426 
      raise result.ex
4427 
    return
4428 
 
4258 rajveer 4429 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4430 
    """
4258 rajveer 4431 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4432 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4433 
 
4434 
    Parameters:
4258 rajveer 4435 
     - transactionId
4247 rajveer 4436 
    """
4258 rajveer 4437 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4438 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4439 
 
4258 rajveer 4440 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4441 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4442 
    args = markTransactionAsPaymentFlagRemoved_args()
4443 
    args.transactionId = transactionId
4247 rajveer 4444 
    args.write(self._oprot)
4445 
    self._oprot.writeMessageEnd()
4446 
    self._oprot.trans.flush()
4447 
 
4258 rajveer 4448 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4450 
    if mtype == TMessageType.EXCEPTION:
4451 
      x = TApplicationException()
4452 
      x.read(self._iprot)
4453 
      self._iprot.readMessageEnd()
4454 
      raise x
4258 rajveer 4455 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4456 
    result.read(self._iprot)
4457 
    self._iprot.readMessageEnd()
4458 
    if result.ex is not None:
4459 
      raise result.ex
4460 
    return
4461 
 
4259 anupam.sin 4462 
  def refundTransaction(self, transactionId, refundedBy, reason):
4463 
    """
4464 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4465 
    need to be cancelled
4247 rajveer 4466 
 
4259 anupam.sin 4467 
    Parameters:
4468 
     - transactionId
4469 
     - refundedBy
4470 
     - reason
4471 
    """
4472 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4473 
    self.recv_refundTransaction()
4474 
 
4475 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4476 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4477 
    args = refundTransaction_args()
4478 
    args.transactionId = transactionId
4479 
    args.refundedBy = refundedBy
4480 
    args.reason = reason
4481 
    args.write(self._oprot)
4482 
    self._oprot.writeMessageEnd()
4483 
    self._oprot.trans.flush()
4484 
 
4485 
  def recv_refundTransaction(self, ):
4486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4487 
    if mtype == TMessageType.EXCEPTION:
4488 
      x = TApplicationException()
4489 
      x.read(self._iprot)
4490 
      self._iprot.readMessageEnd()
4491 
      raise x
4492 
    result = refundTransaction_result()
4493 
    result.read(self._iprot)
4494 
    self._iprot.readMessageEnd()
4495 
    if result.ex is not None:
4496 
      raise result.ex
4497 
    return
4498 
 
4324 mandeep.dh 4499 
  def updateShipmentAddress(self, orderId, addressId):
4500 
    """
4501 
    Updates shipment address of an order. Delivery and shipping date estimates
4502 
    etc. are also updated here.
4503 
 
4504 
    Throws TransactionServiceException in case address change is not
4505 
    possible due to certain reasons such as new pincode in address is
4506 
    not serviceable etc.
4507 
 
4508 
    Parameters:
4509 
     - orderId
4510 
     - addressId
4511 
    """
4512 
    self.send_updateShipmentAddress(orderId, addressId)
4513 
    self.recv_updateShipmentAddress()
4514 
 
4515 
  def send_updateShipmentAddress(self, orderId, addressId):
4516 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4517 
    args = updateShipmentAddress_args()
4518 
    args.orderId = orderId
4519 
    args.addressId = addressId
4520 
    args.write(self._oprot)
4521 
    self._oprot.writeMessageEnd()
4522 
    self._oprot.trans.flush()
4523 
 
4524 
  def recv_updateShipmentAddress(self, ):
4525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4526 
    if mtype == TMessageType.EXCEPTION:
4527 
      x = TApplicationException()
4528 
      x.read(self._iprot)
4529 
      self._iprot.readMessageEnd()
4530 
      raise x
4531 
    result = updateShipmentAddress_result()
4532 
    result.read(self._iprot)
4533 
    self._iprot.readMessageEnd()
4534 
    if result.ex is not None:
4535 
      raise result.ex
4536 
    return
4537 
 
4285 rajveer 4538 
  def acceptOrdersForItemId(self, itemId, inventory):
4539 
    """
4540 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4541 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4542 
 
4285 rajveer 4543 
    Parameters:
4544 
     - itemId
4545 
     - inventory
4546 
    """
4547 
    self.send_acceptOrdersForItemId(itemId, inventory)
4548 
    return self.recv_acceptOrdersForItemId()
4549 
 
4550 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4551 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4552 
    args = acceptOrdersForItemId_args()
4553 
    args.itemId = itemId
4554 
    args.inventory = inventory
4555 
    args.write(self._oprot)
4556 
    self._oprot.writeMessageEnd()
4557 
    self._oprot.trans.flush()
4558 
 
4559 
  def recv_acceptOrdersForItemId(self, ):
4560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4561 
    if mtype == TMessageType.EXCEPTION:
4562 
      x = TApplicationException()
4563 
      x.read(self._iprot)
4564 
      self._iprot.readMessageEnd()
4565 
      raise x
4566 
    result = acceptOrdersForItemId_result()
4567 
    result.read(self._iprot)
4568 
    self._iprot.readMessageEnd()
4569 
    if result.success is not None:
4570 
      return result.success
4571 
    if result.ex is not None:
4572 
      raise result.ex
4573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4574 
 
4369 rajveer 4575 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4576 
    """
4577 
    Parameters:
4578 
     - vendorId
4579 
     - itemId
4580 
     - quantity
4581 
     - estimate
4369 rajveer 4582 
     - isReminder
4303 rajveer 4583 
    """
4369 rajveer 4584 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4585 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4586 
 
4369 rajveer 4587 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4588 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4589 
    args = markOrdersAsPORaised_args()
4590 
    args.vendorId = vendorId
4591 
    args.itemId = itemId
4592 
    args.quantity = quantity
4593 
    args.estimate = estimate
4369 rajveer 4594 
    args.isReminder = isReminder
4303 rajveer 4595 
    args.write(self._oprot)
4596 
    self._oprot.writeMessageEnd()
4597 
    self._oprot.trans.flush()
4598 
 
4599 
  def recv_markOrdersAsPORaised(self, ):
4600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4601 
    if mtype == TMessageType.EXCEPTION:
4602 
      x = TApplicationException()
4603 
      x.read(self._iprot)
4604 
      self._iprot.readMessageEnd()
4605 
      raise x
4606 
    result = markOrdersAsPORaised_result()
4607 
    result.read(self._iprot)
4608 
    self._iprot.readMessageEnd()
4609 
    if result.ex is not None:
4610 
      raise result.ex
4611 
    return
4612 
 
4369 rajveer 4613 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4614 
    """
4615 
    Parameters:
4616 
     - vendorId
4617 
     - itemId
4618 
     - quantity
4619 
     - estimate
4369 rajveer 4620 
     - isReminder
4303 rajveer 4621 
    """
4369 rajveer 4622 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4623 
    self.recv_markOrdersAsReversalInitiated()
4624 
 
4369 rajveer 4625 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4626 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4627 
    args = markOrdersAsReversalInitiated_args()
4628 
    args.vendorId = vendorId
4629 
    args.itemId = itemId
4630 
    args.quantity = quantity
4631 
    args.estimate = estimate
4369 rajveer 4632 
    args.isReminder = isReminder
4303 rajveer 4633 
    args.write(self._oprot)
4634 
    self._oprot.writeMessageEnd()
4635 
    self._oprot.trans.flush()
4636 
 
4637 
  def recv_markOrdersAsReversalInitiated(self, ):
4638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4639 
    if mtype == TMessageType.EXCEPTION:
4640 
      x = TApplicationException()
4641 
      x.read(self._iprot)
4642 
      self._iprot.readMessageEnd()
4643 
      raise x
4644 
    result = markOrdersAsReversalInitiated_result()
4645 
    result.read(self._iprot)
4646 
    self._iprot.readMessageEnd()
4647 
    if result.ex is not None:
4648 
      raise result.ex
4649 
    return
4650 
 
4369 rajveer 4651 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4652 
    """
4653 
    Parameters:
4654 
     - vendorId
4655 
     - itemId
4656 
     - quantity
4657 
     - estimate
4369 rajveer 4658 
     - isReminder
4303 rajveer 4659 
    """
4369 rajveer 4660 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4661 
    self.recv_markOrdersAsNotAvailabke()
4662 
 
4369 rajveer 4663 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4664 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4665 
    args = markOrdersAsNotAvailabke_args()
4666 
    args.vendorId = vendorId
4667 
    args.itemId = itemId
4668 
    args.quantity = quantity
4669 
    args.estimate = estimate
4369 rajveer 4670 
    args.isReminder = isReminder
4303 rajveer 4671 
    args.write(self._oprot)
4672 
    self._oprot.writeMessageEnd()
4673 
    self._oprot.trans.flush()
4674 
 
4675 
  def recv_markOrdersAsNotAvailabke(self, ):
4676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4677 
    if mtype == TMessageType.EXCEPTION:
4678 
      x = TApplicationException()
4679 
      x.read(self._iprot)
4680 
      self._iprot.readMessageEnd()
4681 
      raise x
4682 
    result = markOrdersAsNotAvailabke_result()
4683 
    result.read(self._iprot)
4684 
    self._iprot.readMessageEnd()
4685 
    if result.ex is not None:
4686 
      raise result.ex
4687 
    return
4688 
 
4369 rajveer 4689 
  def markOrdersAsTimeout(self, vendorId):
4690 
    """
4691 
    Parameters:
4692 
     - vendorId
4693 
    """
4694 
    self.send_markOrdersAsTimeout(vendorId)
4695 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4696 
 
4369 rajveer 4697 
  def send_markOrdersAsTimeout(self, vendorId):
4698 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4699 
    args = markOrdersAsTimeout_args()
4700 
    args.vendorId = vendorId
4701 
    args.write(self._oprot)
4702 
    self._oprot.writeMessageEnd()
4703 
    self._oprot.trans.flush()
4704 
 
4705 
  def recv_markOrdersAsTimeout(self, ):
4706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4707 
    if mtype == TMessageType.EXCEPTION:
4708 
      x = TApplicationException()
4709 
      x.read(self._iprot)
4710 
      self._iprot.readMessageEnd()
4711 
      raise x
4712 
    result = markOrdersAsTimeout_result()
4713 
    result.read(self._iprot)
4714 
    self._iprot.readMessageEnd()
4715 
    if result.success is not None:
4716 
      return result.success
4717 
    if result.ex is not None:
4718 
      raise result.ex
4719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4720 
 
4662 rajveer 4721 
  def markOrderAsLostInTransit(self, orderId):
4722 
    """
4723 
    Mark order as LOST_IN_TRANSIT
4724 
 
4725 
    Parameters:
4726 
     - orderId
4727 
    """
4728 
    self.send_markOrderAsLostInTransit(orderId)
4729 
    return self.recv_markOrderAsLostInTransit()
4730 
 
4731 
  def send_markOrderAsLostInTransit(self, orderId):
4732 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4733 
    args = markOrderAsLostInTransit_args()
4734 
    args.orderId = orderId
4735 
    args.write(self._oprot)
4736 
    self._oprot.writeMessageEnd()
4737 
    self._oprot.trans.flush()
4738 
 
4739 
  def recv_markOrderAsLostInTransit(self, ):
4740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4741 
    if mtype == TMessageType.EXCEPTION:
4742 
      x = TApplicationException()
4743 
      x.read(self._iprot)
4744 
      self._iprot.readMessageEnd()
4745 
      raise x
4746 
    result = markOrderAsLostInTransit_result()
4747 
    result.read(self._iprot)
4748 
    self._iprot.readMessageEnd()
4749 
    if result.success is not None:
4750 
      return result.success
4751 
    if result.ex is not None:
4752 
      raise result.ex
4753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4754 
 
4386 anupam.sin 4755 
  def getOrderForAwb(self, awb):
4756 
    """
4757 
    Returns the order corresponding to an AWB number
4369 rajveer 4758 
 
4386 anupam.sin 4759 
    Parameters:
4760 
     - awb
4761 
    """
4762 
    self.send_getOrderForAwb(awb)
4763 
    return self.recv_getOrderForAwb()
4764 
 
4765 
  def send_getOrderForAwb(self, awb):
4766 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4767 
    args = getOrderForAwb_args()
4768 
    args.awb = awb
4769 
    args.write(self._oprot)
4770 
    self._oprot.writeMessageEnd()
4771 
    self._oprot.trans.flush()
4772 
 
4773 
  def recv_getOrderForAwb(self, ):
4774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4775 
    if mtype == TMessageType.EXCEPTION:
4776 
      x = TApplicationException()
4777 
      x.read(self._iprot)
4778 
      self._iprot.readMessageEnd()
4779 
      raise x
4780 
    result = getOrderForAwb_result()
4781 
    result.read(self._iprot)
4782 
    self._iprot.readMessageEnd()
4783 
    if result.success is not None:
4784 
      return result.success
4785 
    if result.ex is not None:
4786 
      raise result.ex
4787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4788 
 
4910 phani.kuma 4789 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4790 
    """
4910 phani.kuma 4791 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4792 
 
4506 phani.kuma 4793 
    Parameters:
4794 
     - logistics_provider_id
4910 phani.kuma 4795 
     - order_status_list
4506 phani.kuma 4796 
    """
4910 phani.kuma 4797 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4798 
    return self.recv_getOrdersForProviderForStatus()
4799 
 
4910 phani.kuma 4800 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4801 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4802 
    args = getOrdersForProviderForStatus_args()
4803 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4804 
    args.order_status_list = order_status_list
4506 phani.kuma 4805 
    args.write(self._oprot)
4806 
    self._oprot.writeMessageEnd()
4807 
    self._oprot.trans.flush()
4808 
 
4809 
  def recv_getOrdersForProviderForStatus(self, ):
4810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4811 
    if mtype == TMessageType.EXCEPTION:
4812 
      x = TApplicationException()
4813 
      x.read(self._iprot)
4814 
      self._iprot.readMessageEnd()
4815 
      raise x
4816 
    result = getOrdersForProviderForStatus_result()
4817 
    result.read(self._iprot)
4818 
    self._iprot.readMessageEnd()
4819 
    if result.success is not None:
4820 
      return result.success
4821 
    if result.ex is not None:
4822 
      raise result.ex
4823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4824 
 
4600 varun.gupt 4825 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4826 
    """
4827 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4828 
 
4600 varun.gupt 4829 
    Parameters:
4830 
     - vendorId
4831 
     - billingDateFrom
4832 
     - billingDateTo
4833 
    """
4834 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4835 
    return self.recv_getBilledOrdersForVendor()
4836 
 
4837 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4838 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4839 
    args = getBilledOrdersForVendor_args()
4840 
    args.vendorId = vendorId
4841 
    args.billingDateFrom = billingDateFrom
4842 
    args.billingDateTo = billingDateTo
4843 
    args.write(self._oprot)
4844 
    self._oprot.writeMessageEnd()
4845 
    self._oprot.trans.flush()
4846 
 
4847 
  def recv_getBilledOrdersForVendor(self, ):
4848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4849 
    if mtype == TMessageType.EXCEPTION:
4850 
      x = TApplicationException()
4851 
      x.read(self._iprot)
4852 
      self._iprot.readMessageEnd()
4853 
      raise x
4854 
    result = getBilledOrdersForVendor_result()
4855 
    result.read(self._iprot)
4856 
    self._iprot.readMessageEnd()
4857 
    if result.success is not None:
4858 
      return result.success
4859 
    if result.ex is not None:
4860 
      raise result.ex
4861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4862 
 
4607 rajveer 4863 
  def getSlippedSippingDateOrders(self, ):
4864 
    self.send_getSlippedSippingDateOrders()
4865 
    return self.recv_getSlippedSippingDateOrders()
4866 
 
4867 
  def send_getSlippedSippingDateOrders(self, ):
4868 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4869 
    args = getSlippedSippingDateOrders_args()
4870 
    args.write(self._oprot)
4871 
    self._oprot.writeMessageEnd()
4872 
    self._oprot.trans.flush()
4873 
 
4874 
  def recv_getSlippedSippingDateOrders(self, ):
4875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4876 
    if mtype == TMessageType.EXCEPTION:
4877 
      x = TApplicationException()
4878 
      x.read(self._iprot)
4879 
      self._iprot.readMessageEnd()
4880 
      raise x
4881 
    result = getSlippedSippingDateOrders_result()
4882 
    result.read(self._iprot)
4883 
    self._iprot.readMessageEnd()
4884 
    if result.success is not None:
4885 
      return result.success
4886 
    if result.ex is not None:
4887 
      raise result.ex
4888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4889 
 
4709 rajveer 4890 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4891 
    """
4892 
    Parameters:
4893 
     - cancelDateFrom
4894 
     - cancelDateTo
4895 
    """
4896 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4897 
    return self.recv_getCancelledOrders()
4898 
 
4899 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4900 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4901 
    args = getCancelledOrders_args()
4902 
    args.cancelDateFrom = cancelDateFrom
4903 
    args.cancelDateTo = cancelDateTo
4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
4908 
  def recv_getCancelledOrders(self, ):
4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
4915 
    result = getCancelledOrders_result()
4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    if result.ex is not None:
4921 
      raise result.ex
4922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4923 
 
4600 varun.gupt 4924 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4925 
    """
4926 
    Parameters:
4927 
     - mapAWBAndAmount
4928 
    """
4929 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4930 
    self.recv_saveBluedartSettlements()
4931 
 
4932 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4933 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4934 
    args = saveBluedartSettlements_args()
4935 
    args.mapAWBAndAmount = mapAWBAndAmount
4936 
    args.write(self._oprot)
4937 
    self._oprot.writeMessageEnd()
4938 
    self._oprot.trans.flush()
4939 
 
4940 
  def recv_saveBluedartSettlements(self, ):
4941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4942 
    if mtype == TMessageType.EXCEPTION:
4943 
      x = TApplicationException()
4944 
      x.read(self._iprot)
4945 
      self._iprot.readMessageEnd()
4946 
      raise x
4947 
    result = saveBluedartSettlements_result()
4948 
    result.read(self._iprot)
4949 
    self._iprot.readMessageEnd()
4950 
    if result.ex is not None:
4951 
      raise result.ex
4952 
    return
4953 
 
4905 varun.gupt 4954 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4955 
    """
4956 
    Parameters:
4957 
     - settlementDate
4958 
     - paymentGatewayId
4905 varun.gupt 4959 
     - referenceId
4600 varun.gupt 4960 
     - serviceTax
4961 
     - otherCharges
4962 
     - netCollection
4963 
    """
4905 varun.gupt 4964 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4965 
    self.recv_savePaymentSettlements()
4966 
 
4905 varun.gupt 4967 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4968 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4969 
    args = savePaymentSettlements_args()
4970 
    args.settlementDate = settlementDate
4971 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4972 
    args.referenceId = referenceId
4600 varun.gupt 4973 
    args.serviceTax = serviceTax
4974 
    args.otherCharges = otherCharges
4975 
    args.netCollection = netCollection
4976 
    args.write(self._oprot)
4977 
    self._oprot.writeMessageEnd()
4978 
    self._oprot.trans.flush()
4979 
 
4980 
  def recv_savePaymentSettlements(self, ):
4981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4982 
    if mtype == TMessageType.EXCEPTION:
4983 
      x = TApplicationException()
4984 
      x.read(self._iprot)
4985 
      self._iprot.readMessageEnd()
4986 
      raise x
4987 
    result = savePaymentSettlements_result()
4988 
    result.read(self._iprot)
4989 
    self._iprot.readMessageEnd()
4990 
    if result.ex is not None:
4991 
      raise result.ex
4992 
    return
4993 
 
4994 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4995 
    """
4996 
    Parameters:
4997 
     - settlementId
4998 
     - settlementDate
4999 
     - transactionDateFrom
5000 
     - transactionDateTo
5001 
     - amount
5002 
    """
5003 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5004 
    self.recv_saveEBSSettlementSummary()
5005 
 
5006 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5007 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5008 
    args = saveEBSSettlementSummary_args()
5009 
    args.settlementId = settlementId
5010 
    args.settlementDate = settlementDate
5011 
    args.transactionDateFrom = transactionDateFrom
5012 
    args.transactionDateTo = transactionDateTo
5013 
    args.amount = amount
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_saveEBSSettlementSummary(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = saveEBSSettlementSummary_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.ex is not None:
5029 
      raise result.ex
5030 
    return
5031 
 
5386 phani.kuma 5032 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5033 
    """
5034 
    Parameters:
5189 varun.gupt 5035 
     - referenceId
5036 
     - isRefund
4600 varun.gupt 5037 
    """
5386 phani.kuma 5038 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5039 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5040 
 
5386 phani.kuma 5041 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5042 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5043 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5044 
    args.referenceId = referenceId
5045 
    args.isRefund = isRefund
4600 varun.gupt 5046 
    args.write(self._oprot)
5047 
    self._oprot.writeMessageEnd()
5048 
    self._oprot.trans.flush()
5049 
 
5386 phani.kuma 5050 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5052 
    if mtype == TMessageType.EXCEPTION:
5053 
      x = TApplicationException()
5054 
      x.read(self._iprot)
5055 
      self._iprot.readMessageEnd()
5056 
      raise x
5386 phani.kuma 5057 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5058 
    result.read(self._iprot)
5059 
    self._iprot.readMessageEnd()
5060 
    if result.success is not None:
5061 
      return result.success
5062 
    if result.ex is not None:
5063 
      raise result.ex
5386 phani.kuma 5064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5065 
 
5386 phani.kuma 5066 
  def getSettlementForCod(self, orderId, isRefund):
5067 
    """
5068 
    Parameters:
5069 
     - orderId
5070 
     - isRefund
5071 
    """
5072 
    self.send_getSettlementForCod(orderId, isRefund)
5073 
    return self.recv_getSettlementForCod()
5074 
 
5075 
  def send_getSettlementForCod(self, orderId, isRefund):
5076 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5077 
    args = getSettlementForCod_args()
5078 
    args.orderId = orderId
5079 
    args.isRefund = isRefund
5080 
    args.write(self._oprot)
5081 
    self._oprot.writeMessageEnd()
5082 
    self._oprot.trans.flush()
5083 
 
5084 
  def recv_getSettlementForCod(self, ):
5085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5086 
    if mtype == TMessageType.EXCEPTION:
5087 
      x = TApplicationException()
5088 
      x.read(self._iprot)
5089 
      self._iprot.readMessageEnd()
5090 
      raise x
5091 
    result = getSettlementForCod_result()
5092 
    result.read(self._iprot)
5093 
    self._iprot.readMessageEnd()
5094 
    if result.success is not None:
5095 
      return result.success
5096 
    if result.ex is not None:
5097 
      raise result.ex
5098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5099 
 
4600 varun.gupt 5100 
  def getEBSSettlementSummaries(self, ):
5101 
    self.send_getEBSSettlementSummaries()
5102 
    return self.recv_getEBSSettlementSummaries()
5103 
 
5104 
  def send_getEBSSettlementSummaries(self, ):
5105 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5106 
    args = getEBSSettlementSummaries_args()
5107 
    args.write(self._oprot)
5108 
    self._oprot.writeMessageEnd()
5109 
    self._oprot.trans.flush()
5110 
 
5111 
  def recv_getEBSSettlementSummaries(self, ):
5112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5113 
    if mtype == TMessageType.EXCEPTION:
5114 
      x = TApplicationException()
5115 
      x.read(self._iprot)
5116 
      self._iprot.readMessageEnd()
5117 
      raise x
5118 
    result = getEBSSettlementSummaries_result()
5119 
    result.read(self._iprot)
5120 
    self._iprot.readMessageEnd()
5121 
    if result.success is not None:
5122 
      return result.success
5123 
    if result.ex is not None:
5124 
      raise result.ex
5125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5126 
 
5127 
  def markEBSSettlementUploaded(self, settlementId):
5128 
    """
5129 
    Parameters:
5130 
     - settlementId
5131 
    """
5132 
    self.send_markEBSSettlementUploaded(settlementId)
5133 
    self.recv_markEBSSettlementUploaded()
5134 
 
5135 
  def send_markEBSSettlementUploaded(self, settlementId):
5136 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5137 
    args = markEBSSettlementUploaded_args()
5138 
    args.settlementId = settlementId
5139 
    args.write(self._oprot)
5140 
    self._oprot.writeMessageEnd()
5141 
    self._oprot.trans.flush()
5142 
 
5143 
  def recv_markEBSSettlementUploaded(self, ):
5144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5145 
    if mtype == TMessageType.EXCEPTION:
5146 
      x = TApplicationException()
5147 
      x.read(self._iprot)
5148 
      self._iprot.readMessageEnd()
5149 
      raise x
5150 
    result = markEBSSettlementUploaded_result()
5151 
    result.read(self._iprot)
5152 
    self._iprot.readMessageEnd()
5153 
    if result.ex is not None:
5154 
      raise result.ex
5155 
    return
5156 
 
5157 
  def getEBSSettlementDate(self, settlementId):
5158 
    """
5159 
    Parameters:
5160 
     - settlementId
5161 
    """
5162 
    self.send_getEBSSettlementDate(settlementId)
5163 
    return self.recv_getEBSSettlementDate()
5164 
 
5165 
  def send_getEBSSettlementDate(self, settlementId):
5166 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5167 
    args = getEBSSettlementDate_args()
5168 
    args.settlementId = settlementId
5169 
    args.write(self._oprot)
5170 
    self._oprot.writeMessageEnd()
5171 
    self._oprot.trans.flush()
5172 
 
5173 
  def recv_getEBSSettlementDate(self, ):
5174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5175 
    if mtype == TMessageType.EXCEPTION:
5176 
      x = TApplicationException()
5177 
      x.read(self._iprot)
5178 
      self._iprot.readMessageEnd()
5179 
      raise x
5180 
    result = getEBSSettlementDate_result()
5181 
    result.read(self._iprot)
5182 
    self._iprot.readMessageEnd()
5183 
    if result.success is not None:
5184 
      return result.success
5185 
    if result.ex is not None:
5186 
      raise result.ex
5187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5188 
 
4715 varun.gupt 5189 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5190 
    """
5191 
    Parameters:
5192 
     - settlementDateFrom
5193 
     - settlementDateTo
5194 
     - isRefund
5195 
    """
5196 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5197 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5198 
 
4715 varun.gupt 5199 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5200 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5201 
    args = getSettlementsByDate_args()
5202 
    args.settlementDateFrom = settlementDateFrom
5203 
    args.settlementDateTo = settlementDateTo
5204 
    args.isRefund = isRefund
5205 
    args.write(self._oprot)
5206 
    self._oprot.writeMessageEnd()
5207 
    self._oprot.trans.flush()
5208 
 
5209 
  def recv_getSettlementsByDate(self, ):
5210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5211 
    if mtype == TMessageType.EXCEPTION:
5212 
      x = TApplicationException()
5213 
      x.read(self._iprot)
5214 
      self._iprot.readMessageEnd()
5215 
      raise x
5216 
    result = getSettlementsByDate_result()
5217 
    result.read(self._iprot)
5218 
    self._iprot.readMessageEnd()
5219 
    if result.success is not None:
5220 
      return result.success
5221 
    if result.ex is not None:
5222 
      raise result.ex
5223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5224 
 
5225 
  def getReshippedOrderIds(self, orderIds):
5226 
    """
5227 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5228 
 
5229 
    Parameters:
5230 
     - orderIds
5231 
    """
5232 
    self.send_getReshippedOrderIds(orderIds)
5233 
    return self.recv_getReshippedOrderIds()
5234 
 
5235 
  def send_getReshippedOrderIds(self, orderIds):
5236 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5237 
    args = getReshippedOrderIds_args()
5238 
    args.orderIds = orderIds
5239 
    args.write(self._oprot)
5240 
    self._oprot.writeMessageEnd()
5241 
    self._oprot.trans.flush()
5242 
 
5243 
  def recv_getReshippedOrderIds(self, ):
5244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5245 
    if mtype == TMessageType.EXCEPTION:
5246 
      x = TApplicationException()
5247 
      x.read(self._iprot)
5248 
      self._iprot.readMessageEnd()
5249 
      raise x
5250 
    result = getReshippedOrderIds_result()
5251 
    result.read(self._iprot)
5252 
    self._iprot.readMessageEnd()
5253 
    if result.success is not None:
5254 
      return result.success
5255 
    if result.ex is not None:
5256 
      raise result.ex
5257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5258 
 
5481 phani.kuma 5259 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5260 
    """
5261 
    Parameters:
5262 
     - vendorId
5481 phani.kuma 5263 
     - onlyVendorNotPaid
5264 
     - billingDateFrom
5265 
     - billingDateTo
4875 varun.gupt 5266 
    """
5481 phani.kuma 5267 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5268 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5269 
 
5481 phani.kuma 5270 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5271 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5272 
    args = getBilledOrders_args()
4875 varun.gupt 5273 
    args.vendorId = vendorId
5481 phani.kuma 5274 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5275 
    args.billingDateFrom = billingDateFrom
5276 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5277 
    args.write(self._oprot)
5278 
    self._oprot.writeMessageEnd()
5279 
    self._oprot.trans.flush()
5280 
 
5481 phani.kuma 5281 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5283 
    if mtype == TMessageType.EXCEPTION:
5284 
      x = TApplicationException()
5285 
      x.read(self._iprot)
5286 
      self._iprot.readMessageEnd()
5287 
      raise x
5481 phani.kuma 5288 
    result = getBilledOrders_result()
4875 varun.gupt 5289 
    result.read(self._iprot)
5290 
    self._iprot.readMessageEnd()
5291 
    if result.success is not None:
5292 
      return result.success
5293 
    if result.ex is not None:
5294 
      raise result.ex
5481 phani.kuma 5295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5296 
 
5031 varun.gupt 5297 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5298 
    """
5299 
    Parameters:
5300 
     - startDate
5301 
     - endDate
5302 
    """
5303 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5304 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5305 
 
5031 varun.gupt 5306 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5307 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5308 
    args = getStatusDistributionOfOrders_args()
5309 
    args.startDate = startDate
5310 
    args.endDate = endDate
5311 
    args.write(self._oprot)
5312 
    self._oprot.writeMessageEnd()
5313 
    self._oprot.trans.flush()
5314 
 
5315 
  def recv_getStatusDistributionOfOrders(self, ):
5316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5317 
    if mtype == TMessageType.EXCEPTION:
5318 
      x = TApplicationException()
5319 
      x.read(self._iprot)
5320 
      self._iprot.readMessageEnd()
5321 
      raise x
5322 
    result = getStatusDistributionOfOrders_result()
5323 
    result.read(self._iprot)
5324 
    self._iprot.readMessageEnd()
5325 
    if result.success is not None:
5326 
      return result.success
5327 
    if result.ex is not None:
5328 
      raise result.ex
5329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5330 
 
5067 varun.gupt 5331 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5332 
    """
5333 
    Parameters:
5334 
     - status
5335 
     - startDatetime
5336 
     - endDatetime
5337 
    """
5338 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5339 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5340 
 
5067 varun.gupt 5341 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5342 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5343 
    args = getOrderIdsForStatus_args()
5344 
    args.status = status
5345 
    args.startDatetime = startDatetime
5346 
    args.endDatetime = endDatetime
5347 
    args.write(self._oprot)
5348 
    self._oprot.writeMessageEnd()
5349 
    self._oprot.trans.flush()
5350 
 
5351 
  def recv_getOrderIdsForStatus(self, ):
5352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5353 
    if mtype == TMessageType.EXCEPTION:
5354 
      x = TApplicationException()
5355 
      x.read(self._iprot)
5356 
      self._iprot.readMessageEnd()
5357 
      raise x
5358 
    result = getOrderIdsForStatus_result()
5359 
    result.read(self._iprot)
5360 
    self._iprot.readMessageEnd()
5361 
    if result.success is not None:
5362 
      return result.success
5363 
    if result.ex is not None:
5364 
      raise result.ex
5365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5366 
 
5348 anupam.sin 5367 
  def updateCODAgent(self, agent, orderId):
5368 
    """
5369 
    Updates the agent who handled the COD verification call
5370 
 
5371 
    Parameters:
5372 
     - agent
5373 
     - orderId
5374 
    """
5375 
    self.send_updateCODAgent(agent, orderId)
5376 
    self.recv_updateCODAgent()
5377 
 
5378 
  def send_updateCODAgent(self, agent, orderId):
5379 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5380 
    args = updateCODAgent_args()
5381 
    args.agent = agent
5382 
    args.orderId = orderId
5383 
    args.write(self._oprot)
5384 
    self._oprot.writeMessageEnd()
5385 
    self._oprot.trans.flush()
5386 
 
5387 
  def recv_updateCODAgent(self, ):
5388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5389 
    if mtype == TMessageType.EXCEPTION:
5390 
      x = TApplicationException()
5391 
      x.read(self._iprot)
5392 
      self._iprot.readMessageEnd()
5393 
      raise x
5394 
    result = updateCODAgent_result()
5395 
    result.read(self._iprot)
5396 
    self._iprot.readMessageEnd()
5397 
    if result.ex is not None:
5398 
      raise result.ex
5399 
    return
5400 
 
5099 varun.gupt 5401 
  def updateOrderAsPaidToVendor(self, orderId):
5402 
    """
5403 
    Parameters:
5404 
     - orderId
5405 
    """
5406 
    self.send_updateOrderAsPaidToVendor(orderId)
5407 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5408 
 
5099 varun.gupt 5409 
  def send_updateOrderAsPaidToVendor(self, orderId):
5410 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5411 
    args = updateOrderAsPaidToVendor_args()
5412 
    args.orderId = orderId
5413 
    args.write(self._oprot)
5414 
    self._oprot.writeMessageEnd()
5415 
    self._oprot.trans.flush()
5416 
 
5417 
  def recv_updateOrderAsPaidToVendor(self, ):
5418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5419 
    if mtype == TMessageType.EXCEPTION:
5420 
      x = TApplicationException()
5421 
      x.read(self._iprot)
5422 
      self._iprot.readMessageEnd()
5423 
      raise x
5424 
    result = updateOrderAsPaidToVendor_result()
5425 
    result.read(self._iprot)
5426 
    self._iprot.readMessageEnd()
5427 
    if result.ex is not None:
5428 
      raise result.ex
5429 
    return
5430 
 
5386 phani.kuma 5431 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5432 
    """
5433 
    Parameters:
5434 
     - orderId
5435 
    """
5436 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5437 
    self.recv_updateOrderOnlyAsPaidToVendor()
5438 
 
5439 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5440 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5441 
    args = updateOrderOnlyAsPaidToVendor_args()
5442 
    args.orderId = orderId
5443 
    args.write(self._oprot)
5444 
    self._oprot.writeMessageEnd()
5445 
    self._oprot.trans.flush()
5446 
 
5447 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5449 
    if mtype == TMessageType.EXCEPTION:
5450 
      x = TApplicationException()
5451 
      x.read(self._iprot)
5452 
      self._iprot.readMessageEnd()
5453 
      raise x
5454 
    result = updateOrderOnlyAsPaidToVendor_result()
5455 
    result.read(self._iprot)
5456 
    self._iprot.readMessageEnd()
5457 
    if result.ex is not None:
5458 
      raise result.ex
5459 
    return
5460 
 
5208 varun.gupt 5461 
  def getRefundedOrdersMarkedPaid(self, ):
5462 
    self.send_getRefundedOrdersMarkedPaid()
5463 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5464 
 
5208 varun.gupt 5465 
  def send_getRefundedOrdersMarkedPaid(self, ):
5466 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5467 
    args = getRefundedOrdersMarkedPaid_args()
5468 
    args.write(self._oprot)
5469 
    self._oprot.writeMessageEnd()
5470 
    self._oprot.trans.flush()
5471 
 
5472 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5474 
    if mtype == TMessageType.EXCEPTION:
5475 
      x = TApplicationException()
5476 
      x.read(self._iprot)
5477 
      self._iprot.readMessageEnd()
5478 
      raise x
5479 
    result = getRefundedOrdersMarkedPaid_result()
5480 
    result.read(self._iprot)
5481 
    self._iprot.readMessageEnd()
5482 
    if result.success is not None:
5483 
      return result.success
5484 
    if result.ex is not None:
5485 
      raise result.ex
5486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5487 
 
5447 anupam.sin 5488 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5489 
    """
5490 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5491 
 
5447 anupam.sin 5492 
 
5493 
    Parameters:
5494 
     - minOrderId
5495 
     - maxOrderId
5496 
    """
5497 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5498 
    return self.recv_getAllVerificationAgents()
5499 
 
5500 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5501 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5502 
    args = getAllVerificationAgents_args()
5503 
    args.minOrderId = minOrderId
5504 
    args.maxOrderId = maxOrderId
5505 
    args.write(self._oprot)
5506 
    self._oprot.writeMessageEnd()
5507 
    self._oprot.trans.flush()
5508 
 
5509 
  def recv_getAllVerificationAgents(self, ):
5510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5511 
    if mtype == TMessageType.EXCEPTION:
5512 
      x = TApplicationException()
5513 
      x.read(self._iprot)
5514 
      self._iprot.readMessageEnd()
5515 
      raise x
5516 
    result = getAllVerificationAgents_result()
5517 
    result.read(self._iprot)
5518 
    self._iprot.readMessageEnd()
5519 
    if result.success is not None:
5520 
      return result.success
5521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5522 
 
5527 anupam.sin 5523 
  def getAllAttributesForOrderId(self, orderId):
5524 
    """
5525 
    gets all attributes for a given orderId
5447 anupam.sin 5526 
 
5527 anupam.sin 5527 
    Parameters:
5528 
     - orderId
5529 
    """
5530 
    self.send_getAllAttributesForOrderId(orderId)
5531 
    return self.recv_getAllAttributesForOrderId()
5532 
 
5533 
  def send_getAllAttributesForOrderId(self, orderId):
5534 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5535 
    args = getAllAttributesForOrderId_args()
5536 
    args.orderId = orderId
5537 
    args.write(self._oprot)
5538 
    self._oprot.writeMessageEnd()
5539 
    self._oprot.trans.flush()
5540 
 
5541 
  def recv_getAllAttributesForOrderId(self, ):
5542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5543 
    if mtype == TMessageType.EXCEPTION:
5544 
      x = TApplicationException()
5545 
      x.read(self._iprot)
5546 
      self._iprot.readMessageEnd()
5547 
      raise x
5548 
    result = getAllAttributesForOrderId_result()
5549 
    result.read(self._iprot)
5550 
    self._iprot.readMessageEnd()
5551 
    if result.success is not None:
5552 
      return result.success
5553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5554 
 
5676 rajveer 5555 
  def setOrderAttributes(self, orderId, attributes):
5556 
    """
5557 
    sets attributes for an order
5558 
 
5559 
    Parameters:
5560 
     - orderId
5561 
     - attributes
5562 
    """
5563 
    self.send_setOrderAttributes(orderId, attributes)
5564 
    self.recv_setOrderAttributes()
5565 
 
5566 
  def send_setOrderAttributes(self, orderId, attributes):
5567 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5568 
    args = setOrderAttributes_args()
5569 
    args.orderId = orderId
5570 
    args.attributes = attributes
5571 
    args.write(self._oprot)
5572 
    self._oprot.writeMessageEnd()
5573 
    self._oprot.trans.flush()
5574 
 
5575 
  def recv_setOrderAttributes(self, ):
5576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5577 
    if mtype == TMessageType.EXCEPTION:
5578 
      x = TApplicationException()
5579 
      x.read(self._iprot)
5580 
      self._iprot.readMessageEnd()
5581 
      raise x
5582 
    result = setOrderAttributes_result()
5583 
    result.read(self._iprot)
5584 
    self._iprot.readMessageEnd()
5585 
    return
5586 
 
5527 anupam.sin 5587 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5588 
    """
5589 
    sets attributes for all orders in a transaction
5590 
 
5591 
    Parameters:
5592 
     - transactionId
5593 
     - attribute
5594 
    """
5595 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5596 
    self.recv_setOrderAttributeForTransaction()
5597 
 
5598 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5599 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5600 
    args = setOrderAttributeForTransaction_args()
5601 
    args.transactionId = transactionId
5602 
    args.attribute = attribute
5603 
    args.write(self._oprot)
5604 
    self._oprot.writeMessageEnd()
5605 
    self._oprot.trans.flush()
5606 
 
5607 
  def recv_setOrderAttributeForTransaction(self, ):
5608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5609 
    if mtype == TMessageType.EXCEPTION:
5610 
      x = TApplicationException()
5611 
      x.read(self._iprot)
5612 
      self._iprot.readMessageEnd()
5613 
      raise x
5614 
    result = setOrderAttributeForTransaction_result()
5615 
    result.read(self._iprot)
5616 
    self._iprot.readMessageEnd()
5617 
    return
5618 
 
5553 rajveer 5619 
  def getReceivePendingOrders(self, storeId):
5620 
    """
5621 
    Parameters:
5622 
     - storeId
5623 
    """
5624 
    self.send_getReceivePendingOrders(storeId)
5625 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5626 
 
5553 rajveer 5627 
  def send_getReceivePendingOrders(self, storeId):
5628 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5629 
    args = getReceivePendingOrders_args()
5630 
    args.storeId = storeId
5631 
    args.write(self._oprot)
5632 
    self._oprot.writeMessageEnd()
5633 
    self._oprot.trans.flush()
5634 
 
5635 
  def recv_getReceivePendingOrders(self, ):
5636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5637 
    if mtype == TMessageType.EXCEPTION:
5638 
      x = TApplicationException()
5639 
      x.read(self._iprot)
5640 
      self._iprot.readMessageEnd()
5641 
      raise x
5642 
    result = getReceivePendingOrders_result()
5643 
    result.read(self._iprot)
5644 
    self._iprot.readMessageEnd()
5645 
    if result.success is not None:
5646 
      return result.success
5647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5648 
 
5649 
  def getReceivedAtStoreOrders(self, storeId):
5650 
    """
5651 
    Parameters:
5652 
     - storeId
5653 
    """
5654 
    self.send_getReceivedAtStoreOrders(storeId)
5655 
    return self.recv_getReceivedAtStoreOrders()
5656 
 
5657 
  def send_getReceivedAtStoreOrders(self, storeId):
5658 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5659 
    args = getReceivedAtStoreOrders_args()
5660 
    args.storeId = storeId
5661 
    args.write(self._oprot)
5662 
    self._oprot.writeMessageEnd()
5663 
    self._oprot.trans.flush()
5664 
 
5665 
  def recv_getReceivedAtStoreOrders(self, ):
5666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5667 
    if mtype == TMessageType.EXCEPTION:
5668 
      x = TApplicationException()
5669 
      x.read(self._iprot)
5670 
      self._iprot.readMessageEnd()
5671 
      raise x
5672 
    result = getReceivedAtStoreOrders_result()
5673 
    result.read(self._iprot)
5674 
    self._iprot.readMessageEnd()
5675 
    if result.success is not None:
5676 
      return result.success
5677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5678 
 
5713 rajveer 5679 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5680 
    """
5681 
    Parameters:
5682 
     - storeId
5683 
     - fromDate
5684 
     - toDate
5685 
     - onlyCod
5686 
    """
5687 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5688 
    return self.recv_getOrdersCollectionAtStore()
5689 
 
5690 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5691 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5692 
    args = getOrdersCollectionAtStore_args()
5693 
    args.storeId = storeId
5694 
    args.fromDate = fromDate
5695 
    args.toDate = toDate
5696 
    args.onlyCod = onlyCod
5697 
    args.write(self._oprot)
5698 
    self._oprot.writeMessageEnd()
5699 
    self._oprot.trans.flush()
5700 
 
5701 
  def recv_getOrdersCollectionAtStore(self, ):
5702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5703 
    if mtype == TMessageType.EXCEPTION:
5704 
      x = TApplicationException()
5705 
      x.read(self._iprot)
5706 
      self._iprot.readMessageEnd()
5707 
      raise x
5708 
    result = getOrdersCollectionAtStore_result()
5709 
    result.read(self._iprot)
5710 
    self._iprot.readMessageEnd()
5711 
    if result.success is not None:
5712 
      return result.success
5713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5714 
 
5833 rajveer 5715 
  def getOrderAttributeValue(self, orderId, attributeName):
5716 
    """
5717 
    Parameters:
5718 
     - orderId
5719 
     - attributeName
5720 
    """
5721 
    self.send_getOrderAttributeValue(orderId, attributeName)
5722 
    return self.recv_getOrderAttributeValue()
5723 
 
5724 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5725 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5726 
    args = getOrderAttributeValue_args()
5727 
    args.orderId = orderId
5728 
    args.attributeName = attributeName
5729 
    args.write(self._oprot)
5730 
    self._oprot.writeMessageEnd()
5731 
    self._oprot.trans.flush()
5732 
 
5733 
  def recv_getOrderAttributeValue(self, ):
5734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5735 
    if mtype == TMessageType.EXCEPTION:
5736 
      x = TApplicationException()
5737 
      x.read(self._iprot)
5738 
      self._iprot.readMessageEnd()
5739 
      raise x
5740 
    result = getOrderAttributeValue_result()
5741 
    result.read(self._iprot)
5742 
    self._iprot.readMessageEnd()
5743 
    if result.success is not None:
5744 
      return result.success
5745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5746 
 
6019 rajveer 5747 
  def changeJacketNumber(self, orderId, jacketNumber):
5748 
    """
5749 
    Parameters:
5750 
     - orderId
5751 
     - jacketNumber
5752 
    """
5753 
    self.send_changeJacketNumber(orderId, jacketNumber)
5754 
    return self.recv_changeJacketNumber()
5755 
 
5756 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5757 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5758 
    args = changeJacketNumber_args()
5759 
    args.orderId = orderId
5760 
    args.jacketNumber = jacketNumber
5761 
    args.write(self._oprot)
5762 
    self._oprot.writeMessageEnd()
5763 
    self._oprot.trans.flush()
5764 
 
5765 
  def recv_changeJacketNumber(self, ):
5766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5767 
    if mtype == TMessageType.EXCEPTION:
5768 
      x = TApplicationException()
5769 
      x.read(self._iprot)
5770 
      self._iprot.readMessageEnd()
5771 
      raise x
5772 
    result = changeJacketNumber_result()
5773 
    result.read(self._iprot)
5774 
    self._iprot.readMessageEnd()
5775 
    if result.success is not None:
5776 
      return result.success
5777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5778 
 
5779 
  def markOrderAsRtoInTransit(self, orderId):
5780 
    """
5781 
    Parameters:
5782 
     - orderId
5783 
    """
5784 
    self.send_markOrderAsRtoInTransit(orderId)
5785 
    return self.recv_markOrderAsRtoInTransit()
5786 
 
5787 
  def send_markOrderAsRtoInTransit(self, orderId):
5788 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5789 
    args = markOrderAsRtoInTransit_args()
5790 
    args.orderId = orderId
5791 
    args.write(self._oprot)
5792 
    self._oprot.writeMessageEnd()
5793 
    self._oprot.trans.flush()
5794 
 
5795 
  def recv_markOrderAsRtoInTransit(self, ):
5796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5797 
    if mtype == TMessageType.EXCEPTION:
5798 
      x = TApplicationException()
5799 
      x.read(self._iprot)
5800 
      self._iprot.readMessageEnd()
5801 
      raise x
5802 
    result = markOrderAsRtoInTransit_result()
5803 
    result.read(self._iprot)
5804 
    self._iprot.readMessageEnd()
5805 
    if result.success is not None:
5806 
      return result.success
5807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5808 
 
5593 mandeep.dh 5809 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5810 
    """
5811 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5812 
    invoked while scanning IN of items.
5553 rajveer 5813 
 
5593 mandeep.dh 5814 
    Parameters:
5815 
     - itemId
5816 
     - quantity
5817 
     - fulfilmentWarehouseId
5818 
     - billingWarehouseId
5819 
    """
5820 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5821 
    self.recv_acceptOrderForItem()
5822 
 
5823 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5824 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5825 
    args = acceptOrderForItem_args()
5826 
    args.itemId = itemId
5827 
    args.quantity = quantity
5828 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5829 
    args.billingWarehouseId = billingWarehouseId
5830 
    args.write(self._oprot)
5831 
    self._oprot.writeMessageEnd()
5832 
    self._oprot.trans.flush()
5833 
 
5834 
  def recv_acceptOrderForItem(self, ):
5835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5836 
    if mtype == TMessageType.EXCEPTION:
5837 
      x = TApplicationException()
5838 
      x.read(self._iprot)
5839 
      self._iprot.readMessageEnd()
5840 
      raise x
5841 
    result = acceptOrderForItem_result()
5842 
    result.read(self._iprot)
5843 
    self._iprot.readMessageEnd()
5844 
    return
5845 
 
6000 mandeep.dh 5846 
  def createRechargeOrder(self, rechargeOrder):
5847 
    """
5848 
    Parameters:
5849 
     - rechargeOrder
5850 
    """
5851 
    self.send_createRechargeOrder(rechargeOrder)
5852 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5853 
 
6000 mandeep.dh 5854 
  def send_createRechargeOrder(self, rechargeOrder):
5855 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5856 
    args = createRechargeOrder_args()
5857 
    args.rechargeOrder = rechargeOrder
5858 
    args.write(self._oprot)
5859 
    self._oprot.writeMessageEnd()
5860 
    self._oprot.trans.flush()
5861 
 
5862 
  def recv_createRechargeOrder(self, ):
5863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5864 
    if mtype == TMessageType.EXCEPTION:
5865 
      x = TApplicationException()
5866 
      x.read(self._iprot)
5867 
      self._iprot.readMessageEnd()
5868 
      raise x
5869 
    result = createRechargeOrder_result()
5870 
    result.read(self._iprot)
5871 
    self._iprot.readMessageEnd()
5872 
    if result.success is not None:
5873 
      return result.success
5874 
    if result.ex is not None:
5875 
      raise result.ex
5876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5877 
 
6031 rajveer 5878 
  def getRechargeOrder(self, rechargeRrderId):
5879 
    """
5880 
    Parameters:
5881 
     - rechargeRrderId
5882 
    """
5883 
    self.send_getRechargeOrder(rechargeRrderId)
5884 
    return self.recv_getRechargeOrder()
5885 
 
5886 
  def send_getRechargeOrder(self, rechargeRrderId):
5887 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5888 
    args = getRechargeOrder_args()
5889 
    args.rechargeRrderId = rechargeRrderId
5890 
    args.write(self._oprot)
5891 
    self._oprot.writeMessageEnd()
5892 
    self._oprot.trans.flush()
5893 
 
5894 
  def recv_getRechargeOrder(self, ):
5895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5896 
    if mtype == TMessageType.EXCEPTION:
5897 
      x = TApplicationException()
5898 
      x.read(self._iprot)
5899 
      self._iprot.readMessageEnd()
5900 
      raise x
5901 
    result = getRechargeOrder_result()
5902 
    result.read(self._iprot)
5903 
    self._iprot.readMessageEnd()
5904 
    if result.success is not None:
5905 
      return result.success
5906 
    if result.ex is not None:
5907 
      raise result.ex
5908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5909 
 
5910 
  def getRechargeOrders(self, userId):
5911 
    """
5912 
    Parameters:
5913 
     - userId
5914 
    """
5915 
    self.send_getRechargeOrders(userId)
5916 
    return self.recv_getRechargeOrders()
5917 
 
5918 
  def send_getRechargeOrders(self, userId):
5919 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5920 
    args = getRechargeOrders_args()
5921 
    args.userId = userId
5922 
    args.write(self._oprot)
5923 
    self._oprot.writeMessageEnd()
5924 
    self._oprot.trans.flush()
5925 
 
5926 
  def recv_getRechargeOrders(self, ):
5927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5928 
    if mtype == TMessageType.EXCEPTION:
5929 
      x = TApplicationException()
5930 
      x.read(self._iprot)
5931 
      self._iprot.readMessageEnd()
5932 
      raise x
5933 
    result = getRechargeOrders_result()
5934 
    result.read(self._iprot)
5935 
    self._iprot.readMessageEnd()
5936 
    if result.success is not None:
5937 
      return result.success
5938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5939 
 
6000 mandeep.dh 5940 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5941 
    """
5942 
    Parameters:
5943 
     - rechargeOrderId
5944 
     - rechargeOrderStatus
5945 
    """
5946 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5947 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5948 
 
5949 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5950 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5951 
    args = updateRechargeOrderStatus_args()
5952 
    args.rechargeOrderId = rechargeOrderId
5953 
    args.rechargeOrderStatus = rechargeOrderStatus
5954 
    args.write(self._oprot)
5955 
    self._oprot.writeMessageEnd()
5956 
    self._oprot.trans.flush()
5957 
 
5958 
  def recv_updateRechargeOrderStatus(self, ):
5959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5960 
    if mtype == TMessageType.EXCEPTION:
5961 
      x = TApplicationException()
5962 
      x.read(self._iprot)
5963 
      self._iprot.readMessageEnd()
5964 
      raise x
5965 
    result = updateRechargeOrderStatus_result()
5966 
    result.read(self._iprot)
5967 
    self._iprot.readMessageEnd()
6031 rajveer 5968 
    if result.success is not None:
5969 
      return result.success
6000 mandeep.dh 5970 
    if result.ex is not None:
5971 
      raise result.ex
6031 rajveer 5972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5973 
 
6031 rajveer 5974 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5975 
    """
5976 
    Parameters:
6031 rajveer 5977 
     - rechargeOrderId
6000 mandeep.dh 5978 
    """
6031 rajveer 5979 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5980 
    return self.recv_activateRechargeTxn()
5981 
 
6031 rajveer 5982 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5983 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5984 
    args = activateRechargeTxn_args()
6031 rajveer 5985 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5986 
    args.write(self._oprot)
5987 
    self._oprot.writeMessageEnd()
5988 
    self._oprot.trans.flush()
5989 
 
5990 
  def recv_activateRechargeTxn(self, ):
5991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5992 
    if mtype == TMessageType.EXCEPTION:
5993 
      x = TApplicationException()
5994 
      x.read(self._iprot)
5995 
      self._iprot.readMessageEnd()
5996 
      raise x
5997 
    result = activateRechargeTxn_result()
5998 
    result.read(self._iprot)
5999 
    self._iprot.readMessageEnd()
6000 
    if result.success is not None:
6001 
      return result.success
6002 
    if result.ex is not None:
6003 
      raise result.ex
6004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6005 
 
6031 rajveer 6006 
  def getUserWallet(self, userId):
6000 mandeep.dh 6007 
    """
6008 
    Parameters:
6031 rajveer 6009 
     - userId
6000 mandeep.dh 6010 
    """
6031 rajveer 6011 
    self.send_getUserWallet(userId)
6012 
    return self.recv_getUserWallet()
6000 mandeep.dh 6013 
 
6031 rajveer 6014 
  def send_getUserWallet(self, userId):
6015 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6016 
    args = getUserWallet_args()
6017 
    args.userId = userId
6000 mandeep.dh 6018 
    args.write(self._oprot)
6019 
    self._oprot.writeMessageEnd()
6020 
    self._oprot.trans.flush()
6021 
 
6031 rajveer 6022 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6024 
    if mtype == TMessageType.EXCEPTION:
6025 
      x = TApplicationException()
6026 
      x.read(self._iprot)
6027 
      self._iprot.readMessageEnd()
6028 
      raise x
6031 rajveer 6029 
    result = getUserWallet_result()
6000 mandeep.dh 6030 
    result.read(self._iprot)
6031 
    self._iprot.readMessageEnd()
6032 
    if result.success is not None:
6033 
      return result.success
6031 rajveer 6034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6035 
 
6031 rajveer 6036 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6037 
    """
6038 
    Parameters:
6031 rajveer 6039 
     - userId
6000 mandeep.dh 6040 
    """
6031 rajveer 6041 
    self.send_getUserWalletHistory(userId)
6042 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6043 
 
6031 rajveer 6044 
  def send_getUserWalletHistory(self, userId):
6045 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6046 
    args = getUserWalletHistory_args()
6047 
    args.userId = userId
6000 mandeep.dh 6048 
    args.write(self._oprot)
6049 
    self._oprot.writeMessageEnd()
6050 
    self._oprot.trans.flush()
6051 
 
6031 rajveer 6052 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6054 
    if mtype == TMessageType.EXCEPTION:
6055 
      x = TApplicationException()
6056 
      x.read(self._iprot)
6057 
      self._iprot.readMessageEnd()
6058 
      raise x
6031 rajveer 6059 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6060 
    result.read(self._iprot)
6061 
    self._iprot.readMessageEnd()
6062 
    if result.success is not None:
6063 
      return result.success
6031 rajveer 6064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6065 
 
6050 anupam.sin 6066 
  def getRechargeOrdersForTransaction(self, txnId):
6067 
    """
6068 
    Returns a recharge order for a given transactionId
6069 
 
6070 
    Parameters:
6071 
     - txnId
6072 
    """
6073 
    self.send_getRechargeOrdersForTransaction(txnId)
6074 
    return self.recv_getRechargeOrdersForTransaction()
6075 
 
6076 
  def send_getRechargeOrdersForTransaction(self, txnId):
6077 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6078 
    args = getRechargeOrdersForTransaction_args()
6079 
    args.txnId = txnId
6080 
    args.write(self._oprot)
6081 
    self._oprot.writeMessageEnd()
6082 
    self._oprot.trans.flush()
6083 
 
6084 
  def recv_getRechargeOrdersForTransaction(self, ):
6085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6086 
    if mtype == TMessageType.EXCEPTION:
6087 
      x = TApplicationException()
6088 
      x.read(self._iprot)
6089 
      self._iprot.readMessageEnd()
6090 
      raise x
6091 
    result = getRechargeOrdersForTransaction_result()
6092 
    result.read(self._iprot)
6093 
    self._iprot.readMessageEnd()
6094 
    if result.success is not None:
6095 
      return result.success
6096 
    if result.ex is not None:
6097 
      raise result.ex
6098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6099 
 
6206 rajveer 6100 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6101 
    """
6102 
    Parameters:
6103 
     - rechargeType
6206 rajveer 6104 
     - onlyActive
6048 rajveer 6105 
    """
6206 rajveer 6106 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6107 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6108 
 
6206 rajveer 6109 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6110 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6111 
    args = getServiceProviders_args()
6112 
    args.rechargeType = rechargeType
6206 rajveer 6113 
    args.onlyActive = onlyActive
6048 rajveer 6114 
    args.write(self._oprot)
6115 
    self._oprot.writeMessageEnd()
6116 
    self._oprot.trans.flush()
6117 
 
6118 
  def recv_getServiceProviders(self, ):
6119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6120 
    if mtype == TMessageType.EXCEPTION:
6121 
      x = TApplicationException()
6122 
      x.read(self._iprot)
6123 
      self._iprot.readMessageEnd()
6124 
      raise x
6125 
    result = getServiceProviders_result()
6126 
    result.read(self._iprot)
6127 
    self._iprot.readMessageEnd()
6128 
    if result.success is not None:
6129 
      return result.success
6130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6131 
 
6049 rajveer 6132 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6133 
    """
6134 
    Parameters:
6049 rajveer 6135 
     - rechargeType
6048 rajveer 6136 
     - deviceNumber
6137 
    """
6049 rajveer 6138 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6139 
    return self.recv_getServiceProviderForDevice()
6140 
 
6049 rajveer 6141 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6142 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6143 
    args = getServiceProviderForDevice_args()
6049 rajveer 6144 
    args.rechargeType = rechargeType
6048 rajveer 6145 
    args.deviceNumber = deviceNumber
6146 
    args.write(self._oprot)
6147 
    self._oprot.writeMessageEnd()
6148 
    self._oprot.trans.flush()
6149 
 
6150 
  def recv_getServiceProviderForDevice(self, ):
6151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6152 
    if mtype == TMessageType.EXCEPTION:
6153 
      x = TApplicationException()
6154 
      x.read(self._iprot)
6155 
      self._iprot.readMessageEnd()
6156 
      raise x
6157 
    result = getServiceProviderForDevice_result()
6158 
    result.read(self._iprot)
6159 
    self._iprot.readMessageEnd()
6160 
    if result.success is not None:
6161 
      return result.success
6162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6163 
 
6269 rajveer 6164 
  def validateRecharge(self, rechargeType, deviceNumber):
6165 
    """
6166 
    Parameters:
6167 
     - rechargeType
6168 
     - deviceNumber
6169 
    """
6170 
    self.send_validateRecharge(rechargeType, deviceNumber)
6171 
    return self.recv_validateRecharge()
6172 
 
6173 
  def send_validateRecharge(self, rechargeType, deviceNumber):
6174 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6175 
    args = validateRecharge_args()
6176 
    args.rechargeType = rechargeType
6177 
    args.deviceNumber = deviceNumber
6178 
    args.write(self._oprot)
6179 
    self._oprot.writeMessageEnd()
6180 
    self._oprot.trans.flush()
6181 
 
6182 
  def recv_validateRecharge(self, ):
6183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6184 
    if mtype == TMessageType.EXCEPTION:
6185 
      x = TApplicationException()
6186 
      x.read(self._iprot)
6187 
      self._iprot.readMessageEnd()
6188 
      raise x
6189 
    result = validateRecharge_result()
6190 
    result.read(self._iprot)
6191 
    self._iprot.readMessageEnd()
6192 
    if result.success is not None:
6193 
      return result.success
6194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6195 
 
6094 rajveer 6196 
  def getRechargeOrdersForDevice(self, deviceNumber):
6197 
    """
6198 
    Parameters:
6199 
     - deviceNumber
6200 
    """
6201 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6202 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6203 
 
6094 rajveer 6204 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6205 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6206 
    args = getRechargeOrdersForDevice_args()
6207 
    args.deviceNumber = deviceNumber
6208 
    args.write(self._oprot)
6209 
    self._oprot.writeMessageEnd()
6210 
    self._oprot.trans.flush()
6211 
 
6212 
  def recv_getRechargeOrdersForDevice(self, ):
6213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6214 
    if mtype == TMessageType.EXCEPTION:
6215 
      x = TApplicationException()
6216 
      x.read(self._iprot)
6217 
      self._iprot.readMessageEnd()
6218 
      raise x
6219 
    result = getRechargeOrdersForDevice_result()
6220 
    result.read(self._iprot)
6221 
    self._iprot.readMessageEnd()
6222 
    if result.success is not None:
6223 
      return result.success
6224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6225 
 
6226 
  def addAmountToWallet(self, userId, orderId, amount):
6227 
    """
6228 
    Parameters:
6229 
     - userId
6230 
     - orderId
6231 
     - amount
6232 
    """
6233 
    self.send_addAmountToWallet(userId, orderId, amount)
6234 
    self.recv_addAmountToWallet()
6235 
 
6236 
  def send_addAmountToWallet(self, userId, orderId, amount):
6237 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6238 
    args = addAmountToWallet_args()
6239 
    args.userId = userId
6240 
    args.orderId = orderId
6241 
    args.amount = amount
6242 
    args.write(self._oprot)
6243 
    self._oprot.writeMessageEnd()
6244 
    self._oprot.trans.flush()
6245 
 
6246 
  def recv_addAmountToWallet(self, ):
6247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6248 
    if mtype == TMessageType.EXCEPTION:
6249 
      x = TApplicationException()
6250 
      x.read(self._iprot)
6251 
      self._iprot.readMessageEnd()
6252 
      raise x
6253 
    result = addAmountToWallet_result()
6254 
    result.read(self._iprot)
6255 
    self._iprot.readMessageEnd()
6256 
    return
6257 
 
6188 rajveer 6258 
  def getRechargeStatistics(self, ):
6259 
    self.send_getRechargeStatistics()
6260 
    return self.recv_getRechargeStatistics()
6261 
 
6262 
  def send_getRechargeStatistics(self, ):
6263 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6264 
    args = getRechargeStatistics_args()
6265 
    args.write(self._oprot)
6266 
    self._oprot.writeMessageEnd()
6267 
    self._oprot.trans.flush()
6268 
 
6269 
  def recv_getRechargeStatistics(self, ):
6270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6271 
    if mtype == TMessageType.EXCEPTION:
6272 
      x = TApplicationException()
6273 
      x.read(self._iprot)
6274 
      self._iprot.readMessageEnd()
6275 
      raise x
6276 
    result = getRechargeStatistics_result()
6277 
    result.read(self._iprot)
6278 
    self._iprot.readMessageEnd()
6279 
    if result.success is not None:
6280 
      return result.success
6281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6282 
 
6154 rajveer 6283 
  def getRechargeOrdersForStatus(self, status):
6284 
    """
6285 
    Parameters:
6286 
     - status
6287 
    """
6288 
    self.send_getRechargeOrdersForStatus(status)
6289 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6290 
 
6154 rajveer 6291 
  def send_getRechargeOrdersForStatus(self, status):
6292 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6293 
    args = getRechargeOrdersForStatus_args()
6294 
    args.status = status
6295 
    args.write(self._oprot)
6296 
    self._oprot.writeMessageEnd()
6297 
    self._oprot.trans.flush()
6298 
 
6299 
  def recv_getRechargeOrdersForStatus(self, ):
6300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6301 
    if mtype == TMessageType.EXCEPTION:
6302 
      x = TApplicationException()
6303 
      x.read(self._iprot)
6304 
      self._iprot.readMessageEnd()
6305 
      raise x
6306 
    result = getRechargeOrdersForStatus_result()
6307 
    result.read(self._iprot)
6308 
    self._iprot.readMessageEnd()
6309 
    if result.success is not None:
6310 
      return result.success
6311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6312 
 
6159 rajveer 6313 
  def getPlansForOperator(self, operatorId):
6314 
    """
6315 
    Parameters:
6316 
     - operatorId
6317 
    """
6318 
    self.send_getPlansForOperator(operatorId)
6319 
    return self.recv_getPlansForOperator()
6154 rajveer 6320 
 
6159 rajveer 6321 
  def send_getPlansForOperator(self, operatorId):
6322 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6323 
    args = getPlansForOperator_args()
6324 
    args.operatorId = operatorId
6325 
    args.write(self._oprot)
6326 
    self._oprot.writeMessageEnd()
6327 
    self._oprot.trans.flush()
6328 
 
6329 
  def recv_getPlansForOperator(self, ):
6330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6331 
    if mtype == TMessageType.EXCEPTION:
6332 
      x = TApplicationException()
6333 
      x.read(self._iprot)
6334 
      self._iprot.readMessageEnd()
6335 
      raise x
6336 
    result = getPlansForOperator_result()
6337 
    result.read(self._iprot)
6338 
    self._iprot.readMessageEnd()
6339 
    if result.success is not None:
6340 
      return result.success
6341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6342 
 
6343 
 
3376 rajveer 6344 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6345 
  def __init__(self, handler):
3376 rajveer 6346 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6347 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6348 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6349 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6350 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6351 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6352 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6353 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6354 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6355 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6356 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6357 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6358 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6359 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6360 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6361 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6362 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6363 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6364 
    self._processMap["createOrder"] = Processor.process_createOrder
6365 
    self._processMap["getOrder"] = Processor.process_getOrder
6366 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6367 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6368 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6369 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6370 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6371 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6372 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6373 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6374 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6375 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6376 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6377 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6378 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6379 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6380 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6381 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6382 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6383 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6384 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6385 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6386 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6387 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6388 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6389 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6390 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6391 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6392 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6393 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6394 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6395 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6396 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6397 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6398 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6399 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6400 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6401 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6402 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6403 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6404 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6405 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6406 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6407 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6408 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6409 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6410 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6411 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6412 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6413 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6414 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6415 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6416 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6417 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6418 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6419 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6420 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6421 
    self._processMap["changeItem"] = Processor.process_changeItem
6422 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6423 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6424 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6425 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6426 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6427 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6428 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6429 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6430 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6431 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6432 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6433 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6434 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6435 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6436 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6437 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6438 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6439 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6440 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6441 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6442 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6443 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6444 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6445 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6446 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6447 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6448 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6449 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6450 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6451 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6452 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6453 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6454 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6455 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6456 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6457 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6458 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6459 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6460 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6461 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6462 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6463 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6464 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6465 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6466 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6467 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6468 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6469 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6470 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6471 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6472 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6473 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6474 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6475 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6476 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6477 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6478 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6479 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6480 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6481 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6482 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6483 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6484 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6485 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6486 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6487 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6488 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6489 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
94 ashish 6490 
 
6491 
  def process(self, iprot, oprot):
6492 
    (name, type, seqid) = iprot.readMessageBegin()
6493 
    if name not in self._processMap:
6494 
      iprot.skip(TType.STRUCT)
6495 
      iprot.readMessageEnd()
6496 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6497 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6498 
      x.write(oprot)
6499 
      oprot.writeMessageEnd()
6500 
      oprot.trans.flush()
6501 
      return
6502 
    else:
6503 
      self._processMap[name](self, seqid, iprot, oprot)
6504 
    return True
6505 
 
6506 
  def process_createTransaction(self, seqid, iprot, oprot):
6507 
    args = createTransaction_args()
6508 
    args.read(iprot)
6509 
    iprot.readMessageEnd()
6510 
    result = createTransaction_result()
6511 
    try:
132 ashish 6512 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6513 
    except TransactionServiceException, ex:
6514 
      result.ex = ex
6515 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6516 
    result.write(oprot)
6517 
    oprot.writeMessageEnd()
6518 
    oprot.trans.flush()
6519 
 
6520 
  def process_getTransaction(self, seqid, iprot, oprot):
6521 
    args = getTransaction_args()
6522 
    args.read(iprot)
6523 
    iprot.readMessageEnd()
6524 
    result = getTransaction_result()
6525 
    try:
6526 
      result.success = self._handler.getTransaction(args.id)
6527 
    except TransactionServiceException, ex:
6528 
      result.ex = ex
6529 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6530 
    result.write(oprot)
6531 
    oprot.writeMessageEnd()
6532 
    oprot.trans.flush()
6533 
 
6534 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6535 
    args = getTransactionsForCustomer_args()
6536 
    args.read(iprot)
6537 
    iprot.readMessageEnd()
6538 
    result = getTransactionsForCustomer_result()
6539 
    try:
6540 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6541 
    except TransactionServiceException, ex:
6542 
      result.ex = ex
6543 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6544 
    result.write(oprot)
6545 
    oprot.writeMessageEnd()
6546 
    oprot.trans.flush()
6547 
 
132 ashish 6548 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6549 
    args = getTransactionsForShoppingCartId_args()
6550 
    args.read(iprot)
6551 
    iprot.readMessageEnd()
6552 
    result = getTransactionsForShoppingCartId_result()
6553 
    try:
6554 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6555 
    except TransactionServiceException, ex:
6556 
      result.ex = ex
6557 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6558 
    result.write(oprot)
6559 
    oprot.writeMessageEnd()
6560 
    oprot.trans.flush()
6561 
 
94 ashish 6562 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6563 
    args = getTransactionStatus_args()
6564 
    args.read(iprot)
6565 
    iprot.readMessageEnd()
6566 
    result = getTransactionStatus_result()
6567 
    try:
6568 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6569 
    except TransactionServiceException, ex:
6570 
      result.ex = ex
6571 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
6576 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6577 
    args = changeTransactionStatus_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = changeTransactionStatus_result()
6581 
    try:
5527 anupam.sin 6582 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6583 
    except TransactionServiceException, ex:
6584 
      result.ex = ex
6585 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
1398 varun.gupt 6590 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6591 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
1398 varun.gupt 6594 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6595 
    try:
1398 varun.gupt 6596 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6597 
    except TransactionServiceException, ex:
6598 
      result.ex = ex
1398 varun.gupt 6599 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
483 rajveer 6604 
  def process_getAllOrders(self, seqid, iprot, oprot):
6605 
    args = getAllOrders_args()
94 ashish 6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
483 rajveer 6608 
    result = getAllOrders_result()
94 ashish 6609 
    try:
4801 anupam.sin 6610 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6611 
    except TransactionServiceException, ex:
6612 
      result.ex = ex
483 rajveer 6613 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6614 
    result.write(oprot)
6615 
    oprot.writeMessageEnd()
6616 
    oprot.trans.flush()
6617 
 
4133 chandransh 6618 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6619 
    args = getOrdersInBatch_args()
6620 
    args.read(iprot)
6621 
    iprot.readMessageEnd()
6622 
    result = getOrdersInBatch_result()
6623 
    try:
6624 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6625 
    except TransactionServiceException, ex:
6626 
      result.ex = ex
6627 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6628 
    result.write(oprot)
6629 
    oprot.writeMessageEnd()
6630 
    oprot.trans.flush()
6631 
 
6632 
  def process_getOrderCount(self, seqid, iprot, oprot):
6633 
    args = getOrderCount_args()
6634 
    args.read(iprot)
6635 
    iprot.readMessageEnd()
6636 
    result = getOrderCount_result()
6637 
    try:
6638 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6639 
    except TransactionServiceException, ex:
6640 
      result.ex = ex
6641 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6642 
    result.write(oprot)
6643 
    oprot.writeMessageEnd()
6644 
    oprot.trans.flush()
6645 
 
999 varun.gupt 6646 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6647 
    args = getOrdersByBillingDate_args()
6648 
    args.read(iprot)
6649 
    iprot.readMessageEnd()
6650 
    result = getOrdersByBillingDate_result()
6651 
    try:
6652 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6653 
    except TransactionServiceException, ex:
6654 
      result.ex = ex
6655 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6656 
    result.write(oprot)
6657 
    oprot.writeMessageEnd()
6658 
    oprot.trans.flush()
6659 
 
3427 chandransh 6660 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6661 
    args = getOrdersByShippingDate_args()
6662 
    args.read(iprot)
6663 
    iprot.readMessageEnd()
6664 
    result = getOrdersByShippingDate_result()
6665 
    try:
3451 chandransh 6666 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6667 
    except TransactionServiceException, ex:
6668 
      result.ex = ex
6669 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6670 
    result.write(oprot)
6671 
    oprot.writeMessageEnd()
6672 
    oprot.trans.flush()
6673 
 
1382 varun.gupt 6674 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6675 
    args = getReturnableOrdersForCustomer_args()
6676 
    args.read(iprot)
6677 
    iprot.readMessageEnd()
6678 
    result = getReturnableOrdersForCustomer_result()
6679 
    try:
6680 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6681 
    except TransactionServiceException, ex:
6682 
      result.ex = ex
6683 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6684 
    result.write(oprot)
6685 
    oprot.writeMessageEnd()
6686 
    oprot.trans.flush()
6687 
 
6688 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6689 
    args = getCancellableOrdersForCustomer_args()
6690 
    args.read(iprot)
6691 
    iprot.readMessageEnd()
6692 
    result = getCancellableOrdersForCustomer_result()
6693 
    try:
6694 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6695 
    except TransactionServiceException, ex:
6696 
      result.ex = ex
6697 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6698 
    result.write(oprot)
6699 
    oprot.writeMessageEnd()
6700 
    oprot.trans.flush()
6701 
 
483 rajveer 6702 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6703 
    args = changeOrderStatus_args()
94 ashish 6704 
    args.read(iprot)
6705 
    iprot.readMessageEnd()
483 rajveer 6706 
    result = changeOrderStatus_result()
94 ashish 6707 
    try:
483 rajveer 6708 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6709 
    except TransactionServiceException, ex:
6710 
      result.ex = ex
483 rajveer 6711 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6712 
    result.write(oprot)
6713 
    oprot.writeMessageEnd()
6714 
    oprot.trans.flush()
6715 
 
483 rajveer 6716 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6717 
    args = getOrdersForTransaction_args()
94 ashish 6718 
    args.read(iprot)
6719 
    iprot.readMessageEnd()
483 rajveer 6720 
    result = getOrdersForTransaction_result()
94 ashish 6721 
    try:
1528 ankur.sing 6722 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6723 
    except TransactionServiceException, ex:
6724 
      result.ex = ex
483 rajveer 6725 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
483 rajveer 6730 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6731 
    args = getOrdersForCustomer_args()
94 ashish 6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
483 rajveer 6734 
    result = getOrdersForCustomer_result()
94 ashish 6735 
    try:
3014 chandransh 6736 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6737 
    except TransactionServiceException, ex:
6738 
      result.ex = ex
483 rajveer 6739 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6743 
 
483 rajveer 6744 
  def process_createOrder(self, seqid, iprot, oprot):
6745 
    args = createOrder_args()
94 ashish 6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
483 rajveer 6748 
    result = createOrder_result()
94 ashish 6749 
    try:
483 rajveer 6750 
      result.success = self._handler.createOrder(args.order)
94 ashish 6751 
    except TransactionServiceException, ex:
6752 
      result.ex = ex
483 rajveer 6753 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6754 
    result.write(oprot)
6755 
    oprot.writeMessageEnd()
6756 
    oprot.trans.flush()
6757 
 
483 rajveer 6758 
  def process_getOrder(self, seqid, iprot, oprot):
6759 
    args = getOrder_args()
94 ashish 6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
483 rajveer 6762 
    result = getOrder_result()
94 ashish 6763 
    try:
483 rajveer 6764 
      result.success = self._handler.getOrder(args.id)
94 ashish 6765 
    except TransactionServiceException, ex:
6766 
      result.ex = ex
483 rajveer 6767 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6768 
    result.write(oprot)
6769 
    oprot.writeMessageEnd()
6770 
    oprot.trans.flush()
6771 
 
483 rajveer 6772 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6773 
    args = getLineItemsForOrder_args()
94 ashish 6774 
    args.read(iprot)
6775 
    iprot.readMessageEnd()
483 rajveer 6776 
    result = getLineItemsForOrder_result()
94 ashish 6777 
    try:
483 rajveer 6778 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6779 
    except TransactionServiceException, ex:
6780 
      result.ex = ex
483 rajveer 6781 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6782 
    result.write(oprot)
6783 
    oprot.writeMessageEnd()
6784 
    oprot.trans.flush()
6785 
 
4999 phani.kuma 6786 
  def process_getOrderList(self, seqid, iprot, oprot):
6787 
    args = getOrderList_args()
6788 
    args.read(iprot)
6789 
    iprot.readMessageEnd()
6790 
    result = getOrderList_result()
6791 
    result.success = self._handler.getOrderList(args.order_ids)
6792 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6793 
    result.write(oprot)
6794 
    oprot.writeMessageEnd()
6795 
    oprot.trans.flush()
6796 
 
5386 phani.kuma 6797 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6798 
    args = getOrderListForVendor_args()
6799 
    args.read(iprot)
6800 
    iprot.readMessageEnd()
6801 
    result = getOrderListForVendor_result()
6802 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6803 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6804 
    result.write(oprot)
6805 
    oprot.writeMessageEnd()
6806 
    oprot.trans.flush()
6807 
 
1528 ankur.sing 6808 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6809 
    args = getOrderForCustomer_args()
6810 
    args.read(iprot)
6811 
    iprot.readMessageEnd()
6812 
    result = getOrderForCustomer_result()
6813 
    try:
6814 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6815 
    except TransactionServiceException, ex:
6816 
      result.ex = ex
6817 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6818 
    result.write(oprot)
6819 
    oprot.writeMessageEnd()
6820 
    oprot.trans.flush()
6821 
 
3064 chandransh 6822 
  def process_getAlerts(self, seqid, iprot, oprot):
6823 
    args = getAlerts_args()
6824 
    args.read(iprot)
6825 
    iprot.readMessageEnd()
6826 
    result = getAlerts_result()
4444 rajveer 6827 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6828 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6829 
    result.write(oprot)
6830 
    oprot.writeMessageEnd()
6831 
    oprot.trans.flush()
6832 
 
4394 rajveer 6833 
  def process_addAlert(self, seqid, iprot, oprot):
6834 
    args = addAlert_args()
3064 chandransh 6835 
    args.read(iprot)
6836 
    iprot.readMessageEnd()
4394 rajveer 6837 
    result = addAlert_result()
4444 rajveer 6838 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6839 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6840 
    result.write(oprot)
6841 
    oprot.writeMessageEnd()
6842 
    oprot.trans.flush()
6843 
 
4444 rajveer 6844 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6845 
    args = markAlertsAsSeen_args()
6846 
    args.read(iprot)
6847 
    iprot.readMessageEnd()
6848 
    result = markAlertsAsSeen_result()
6849 
    self._handler.markAlertsAsSeen(args.warehouseId)
6850 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6851 
    result.write(oprot)
6852 
    oprot.writeMessageEnd()
6853 
    oprot.trans.flush()
6854 
 
3064 chandransh 6855 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6856 
    args = getValidOrderCount_args()
6857 
    args.read(iprot)
6858 
    iprot.readMessageEnd()
6859 
    result = getValidOrderCount_result()
6860 
    result.success = self._handler.getValidOrderCount()
6861 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6862 
    result.write(oprot)
6863 
    oprot.writeMessageEnd()
6864 
    oprot.trans.flush()
6865 
 
6866 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6867 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6868 
    args.read(iprot)
6869 
    iprot.readMessageEnd()
6870 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6871 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6872 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6873 
    result.write(oprot)
6874 
    oprot.writeMessageEnd()
6875 
    oprot.trans.flush()
6876 
 
6877 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6878 
    args = getValidOrdersAmountRange_args()
6879 
    args.read(iprot)
6880 
    iprot.readMessageEnd()
6881 
    result = getValidOrdersAmountRange_result()
6882 
    result.success = self._handler.getValidOrdersAmountRange()
6883 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6884 
    result.write(oprot)
6885 
    oprot.writeMessageEnd()
6886 
    oprot.trans.flush()
6887 
 
6888 
  def process_getValidOrders(self, seqid, iprot, oprot):
6889 
    args = getValidOrders_args()
6890 
    args.read(iprot)
6891 
    iprot.readMessageEnd()
6892 
    result = getValidOrders_result()
5874 rajveer 6893 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6894 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6895 
    result.write(oprot)
6896 
    oprot.writeMessageEnd()
6897 
    oprot.trans.flush()
6898 
 
1220 chandransh 6899 
  def process_batchOrders(self, seqid, iprot, oprot):
6900 
    args = batchOrders_args()
6901 
    args.read(iprot)
6902 
    iprot.readMessageEnd()
6903 
    result = batchOrders_result()
6904 
    try:
6905 
      result.success = self._handler.batchOrders(args.warehouseId)
6906 
    except TransactionServiceException, ex:
6907 
      result.ex = ex
6908 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6909 
    result.write(oprot)
6910 
    oprot.writeMessageEnd()
6911 
    oprot.trans.flush()
6912 
 
1208 chandransh 6913 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6914 
    args = markOrderAsOutOfStock_args()
6915 
    args.read(iprot)
6916 
    iprot.readMessageEnd()
6917 
    result = markOrderAsOutOfStock_result()
6918 
    try:
6919 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6920 
    except TransactionServiceException, ex:
6921 
      result.ex = ex
6922 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6923 
    result.write(oprot)
6924 
    oprot.writeMessageEnd()
6925 
    oprot.trans.flush()
6926 
 
3064 chandransh 6927 
  def process_verifyOrder(self, seqid, iprot, oprot):
6928 
    args = verifyOrder_args()
759 chandransh 6929 
    args.read(iprot)
6930 
    iprot.readMessageEnd()
3064 chandransh 6931 
    result = verifyOrder_result()
759 chandransh 6932 
    try:
3064 chandransh 6933 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6934 
    except TransactionServiceException, ex:
6935 
      result.ex = ex
3064 chandransh 6936 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
6940 
 
3064 chandransh 6941 
  def process_acceptOrder(self, seqid, iprot, oprot):
6942 
    args = acceptOrder_args()
1113 chandransh 6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
3064 chandransh 6945 
    result = acceptOrder_result()
1113 chandransh 6946 
    try:
3064 chandransh 6947 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6948 
    except TransactionServiceException, ex:
6949 
      result.ex = ex
3064 chandransh 6950 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
3064 chandransh 6955 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6956 
    args = addBillingDetails_args()
1135 chandransh 6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
3064 chandransh 6959 
    result = addBillingDetails_result()
1135 chandransh 6960 
    try:
5110 mandeep.dh 6961 
      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 6962 
    except TransactionServiceException, ex:
6963 
      result.ex = ex
3064 chandransh 6964 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
6968 
 
4579 rajveer 6969 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6970 
    args = addInvoiceNumber_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = addInvoiceNumber_result()
6974 
    try:
4763 rajveer 6975 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
6978 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
4410 rajveer 6983 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6984 
    args = markOrdersAsShippedFromWarehouse_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = markOrdersAsShippedFromWarehouse_result()
6988 
    try:
4789 rajveer 6989 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
6992 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
5676 rajveer 6997 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6998 
    args = markOrdersAsReturnedFromStore_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = markOrdersAsReturnedFromStore_result()
7002 
    try:
5713 rajveer 7003 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7004 
    except TransactionServiceException, ex:
7005 
      result.ex = ex
7006 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7007 
    result.write(oprot)
7008 
    oprot.writeMessageEnd()
7009 
    oprot.trans.flush()
7010 
 
3064 chandransh 7011 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7012 
    args = markOrdersAsPickedUp_args()
304 ashish 7013 
    args.read(iprot)
7014 
    iprot.readMessageEnd()
3064 chandransh 7015 
    result = markOrdersAsPickedUp_result()
7016 
    try:
4910 phani.kuma 7017 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7018 
    except TransactionServiceException, ex:
7019 
      result.ex = ex
7020 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
94 ashish 7024 
 
4910 phani.kuma 7025 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7026 
    args = getOrdersNotPickedUp_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = getOrdersNotPickedUp_result()
7030 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7031 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
3064 chandransh 7036 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7037 
    args = markOrdersAsDelivered_args()
304 ashish 7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
3064 chandransh 7040 
    result = markOrdersAsDelivered_result()
7041 
    try:
7042 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
7045 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
4910 phani.kuma 7050 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7051 
    args = markAsRTOrders_args()
1596 ankur.sing 7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
4910 phani.kuma 7054 
    result = markAsRTOrders_result()
3064 chandransh 7055 
    try:
4910 phani.kuma 7056 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
4910 phani.kuma 7059 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
304 ashish 7063 
 
4910 phani.kuma 7064 
  def process_getRTOrders(self, seqid, iprot, oprot):
7065 
    args = getRTOrders_args()
7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
7068 
    result = getRTOrders_result()
7069 
    result.success = self._handler.getRTOrders(args.providerId)
7070 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7071 
    result.write(oprot)
7072 
    oprot.writeMessageEnd()
7073 
    oprot.trans.flush()
7074 
 
3064 chandransh 7075 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7076 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7077 
    args.read(iprot)
7078 
    iprot.readMessageEnd()
3064 chandransh 7079 
    result = updateNonDeliveryReason_result()
7080 
    try:
4910 phani.kuma 7081 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7082 
    except TransactionServiceException, ex:
7083 
      result.ex = ex
7084 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7085 
    result.write(oprot)
7086 
    oprot.writeMessageEnd()
7087 
    oprot.trans.flush()
1596 ankur.sing 7088 
 
4910 phani.kuma 7089 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7090 
    args = getNonDeliveredOrdersbyCourier_args()
7091 
    args.read(iprot)
7092 
    iprot.readMessageEnd()
7093 
    result = getNonDeliveredOrdersbyCourier_result()
7094 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7095 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7096 
    result.write(oprot)
7097 
    oprot.writeMessageEnd()
7098 
    oprot.trans.flush()
7099 
 
7100 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7101 
    args = markOrdersAsLocalConnected_args()
7102 
    args.read(iprot)
7103 
    iprot.readMessageEnd()
7104 
    result = markOrdersAsLocalConnected_result()
7105 
    try:
7106 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7107 
    except TransactionServiceException, ex:
7108 
      result.ex = ex
7109 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7110 
    result.write(oprot)
7111 
    oprot.writeMessageEnd()
7112 
    oprot.trans.flush()
7113 
 
7114 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7115 
    args = getOrdersNotLocalConnected_args()
7116 
    args.read(iprot)
7117 
    iprot.readMessageEnd()
7118 
    result = getOrdersNotLocalConnected_result()
7119 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7120 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7121 
    result.write(oprot)
7122 
    oprot.writeMessageEnd()
7123 
    oprot.trans.flush()
7124 
 
7125 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7126 
    args = markOrdersAsDestinationCityReached_args()
7127 
    args.read(iprot)
7128 
    iprot.readMessageEnd()
7129 
    result = markOrdersAsDestinationCityReached_result()
7130 
    try:
7131 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7132 
    except TransactionServiceException, ex:
7133 
      result.ex = ex
7134 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
7138 
 
7139 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7140 
    args = markOrdersAsFirstDeliveryAttempted_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = markOrdersAsFirstDeliveryAttempted_result()
7144 
    try:
7145 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7146 
    except TransactionServiceException, ex:
7147 
      result.ex = ex
7148 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
7152 
 
3064 chandransh 7153 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7154 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
3064 chandransh 7157 
    result = getUndeliveredOrders_result()
7158 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7159 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
7163 
 
4783 phani.kuma 7164 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7165 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7169 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7170 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
7174 
 
2536 chandransh 7175 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7176 
    args = toggleDOAFlag_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = toggleDOAFlag_result()
7180 
    try:
7181 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7182 
    except TransactionServiceException, ex:
7183 
      result.ex = ex
7184 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7185 
    result.write(oprot)
7186 
    oprot.writeMessageEnd()
7187 
    oprot.trans.flush()
1886 ankur.sing 7188 
 
4712 rajveer 7189 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7190 
    args = markOrderAsDelivered_args()
7191 
    args.read(iprot)
7192 
    iprot.readMessageEnd()
7193 
    result = markOrderAsDelivered_result()
7194 
    try:
7195 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7196 
    except TransactionServiceException, ex:
7197 
      result.ex = ex
7198 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7199 
    result.write(oprot)
7200 
    oprot.writeMessageEnd()
7201 
    oprot.trans.flush()
7202 
 
5553 rajveer 7203 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7204 
    args = markOrderAsReceivedAtStore_args()
7205 
    args.read(iprot)
7206 
    iprot.readMessageEnd()
7207 
    result = markOrderAsReceivedAtStore_result()
7208 
    try:
7209 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7210 
    except TransactionServiceException, ex:
7211 
      result.ex = ex
7212 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7213 
    result.write(oprot)
7214 
    oprot.writeMessageEnd()
7215 
    oprot.trans.flush()
7216 
 
4454 rajveer 7217 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7218 
    args = markOrderDoaRequestReceived_args()
7219 
    args.read(iprot)
7220 
    iprot.readMessageEnd()
7221 
    result = markOrderDoaRequestReceived_result()
7222 
    try:
7223 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7224 
    except TransactionServiceException, ex:
7225 
      result.ex = ex
7226 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7227 
    result.write(oprot)
7228 
    oprot.writeMessageEnd()
7229 
    oprot.trans.flush()
7230 
 
7231 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7232 
    args = markOrderDoaRequestAuthorized_args()
7233 
    args.read(iprot)
7234 
    iprot.readMessageEnd()
7235 
    result = markOrderDoaRequestAuthorized_result()
7236 
    try:
7237 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7238 
    except TransactionServiceException, ex:
7239 
      result.ex = ex
7240 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7241 
    result.write(oprot)
7242 
    oprot.writeMessageEnd()
7243 
    oprot.trans.flush()
7244 
 
4488 rajveer 7245 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7246 
    args = markOrderReturnRequestReceived_args()
7247 
    args.read(iprot)
7248 
    iprot.readMessageEnd()
7249 
    result = markOrderReturnRequestReceived_result()
7250 
    try:
7251 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7252 
    except TransactionServiceException, ex:
7253 
      result.ex = ex
7254 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7255 
    result.write(oprot)
7256 
    oprot.writeMessageEnd()
7257 
    oprot.trans.flush()
7258 
 
7259 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7260 
    args = markOrderReturnRequestAuthorized_args()
7261 
    args.read(iprot)
7262 
    iprot.readMessageEnd()
7263 
    result = markOrderReturnRequestAuthorized_result()
7264 
    try:
7265 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7266 
    except TransactionServiceException, ex:
7267 
      result.ex = ex
7268 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7269 
    result.write(oprot)
7270 
    oprot.writeMessageEnd()
7271 
    oprot.trans.flush()
7272 
 
2536 chandransh 7273 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7274 
    args = requestPickupNumber_args()
7275 
    args.read(iprot)
7276 
    iprot.readMessageEnd()
7277 
    result = requestPickupNumber_result()
7278 
    try:
4579 rajveer 7279 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7280 
    except TransactionServiceException, ex:
7281 
      result.ex = ex
7282 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7283 
    result.write(oprot)
7284 
    oprot.writeMessageEnd()
7285 
    oprot.trans.flush()
7286 
 
7287 
  def process_authorizePickup(self, seqid, iprot, oprot):
7288 
    args = authorizePickup_args()
7289 
    args.read(iprot)
7290 
    iprot.readMessageEnd()
7291 
    result = authorizePickup_result()
7292 
    try:
4602 rajveer 7293 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7294 
    except TransactionServiceException, ex:
7295 
      result.ex = ex
7296 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7297 
    result.write(oprot)
7298 
    oprot.writeMessageEnd()
7299 
    oprot.trans.flush()
7300 
 
2764 chandransh 7301 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7302 
    args = markDoasAsPickedUp_args()
7303 
    args.read(iprot)
7304 
    iprot.readMessageEnd()
7305 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7306 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7307 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7308 
    result.write(oprot)
7309 
    oprot.writeMessageEnd()
7310 
    oprot.trans.flush()
7311 
 
4910 phani.kuma 7312 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7313 
    args = getDoasNotPickedUp_args()
7314 
    args.read(iprot)
7315 
    iprot.readMessageEnd()
7316 
    result = getDoasNotPickedUp_result()
7317 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7318 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7319 
    result.write(oprot)
7320 
    oprot.writeMessageEnd()
7321 
    oprot.trans.flush()
7322 
 
4741 phani.kuma 7323 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7324 
    args = markReturnOrdersAsPickedUp_args()
7325 
    args.read(iprot)
7326 
    iprot.readMessageEnd()
7327 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7328 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7329 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7330 
    result.write(oprot)
7331 
    oprot.writeMessageEnd()
7332 
    oprot.trans.flush()
7333 
 
4910 phani.kuma 7334 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7335 
    args = getReturnOrdersNotPickedUp_args()
7336 
    args.read(iprot)
7337 
    iprot.readMessageEnd()
7338 
    result = getReturnOrdersNotPickedUp_result()
7339 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7340 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7341 
    result.write(oprot)
7342 
    oprot.writeMessageEnd()
7343 
    oprot.trans.flush()
7344 
 
2616 chandransh 7345 
  def process_receiveReturn(self, seqid, iprot, oprot):
7346 
    args = receiveReturn_args()
2591 chandransh 7347 
    args.read(iprot)
7348 
    iprot.readMessageEnd()
2616 chandransh 7349 
    result = receiveReturn_result()
2591 chandransh 7350 
    try:
4479 rajveer 7351 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7352 
    except TransactionServiceException, ex:
7353 
      result.ex = ex
2616 chandransh 7354 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7355 
    result.write(oprot)
7356 
    oprot.writeMessageEnd()
7357 
    oprot.trans.flush()
2536 chandransh 7358 
 
2591 chandransh 7359 
  def process_validateDoa(self, seqid, iprot, oprot):
7360 
    args = validateDoa_args()
7361 
    args.read(iprot)
7362 
    iprot.readMessageEnd()
7363 
    result = validateDoa_result()
7364 
    try:
7365 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7366 
    except TransactionServiceException, ex:
7367 
      result.ex = ex
7368 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7369 
    result.write(oprot)
7370 
    oprot.writeMessageEnd()
7371 
    oprot.trans.flush()
7372 
 
4495 rajveer 7373 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7374 
    args = validateReturnProduct_args()
7375 
    args.read(iprot)
7376 
    iprot.readMessageEnd()
7377 
    result = validateReturnProduct_result()
7378 
    try:
7379 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7380 
    except TransactionServiceException, ex:
7381 
      result.ex = ex
7382 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7383 
    result.write(oprot)
7384 
    oprot.writeMessageEnd()
7385 
    oprot.trans.flush()
7386 
 
2616 chandransh 7387 
  def process_reshipOrder(self, seqid, iprot, oprot):
7388 
    args = reshipOrder_args()
7389 
    args.read(iprot)
7390 
    iprot.readMessageEnd()
7391 
    result = reshipOrder_result()
7392 
    try:
7393 
      result.success = self._handler.reshipOrder(args.orderId)
7394 
    except TransactionServiceException, ex:
7395 
      result.ex = ex
7396 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7397 
    result.write(oprot)
7398 
    oprot.writeMessageEnd()
7399 
    oprot.trans.flush()
2591 chandransh 7400 
 
2616 chandransh 7401 
  def process_refundOrder(self, seqid, iprot, oprot):
7402 
    args = refundOrder_args()
7403 
    args.read(iprot)
7404 
    iprot.readMessageEnd()
7405 
    result = refundOrder_result()
7406 
    try:
3226 chandransh 7407 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7408 
    except TransactionServiceException, ex:
7409 
      result.ex = ex
7410 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7411 
    result.write(oprot)
7412 
    oprot.writeMessageEnd()
7413 
    oprot.trans.flush()
7414 
 
2690 chandransh 7415 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7416 
    args = getReturnOrders_args()
7417 
    args.read(iprot)
7418 
    iprot.readMessageEnd()
7419 
    result = getReturnOrders_result()
7420 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7421 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7422 
    result.write(oprot)
7423 
    oprot.writeMessageEnd()
7424 
    oprot.trans.flush()
2616 chandransh 7425 
 
5481 phani.kuma 7426 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7427 
    args = getAllReturnOrders_args()
7428 
    args.read(iprot)
7429 
    iprot.readMessageEnd()
7430 
    result = getAllReturnOrders_result()
7431 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7432 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7433 
    result.write(oprot)
7434 
    oprot.writeMessageEnd()
7435 
    oprot.trans.flush()
7436 
 
2700 chandransh 7437 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7438 
    args = getReturnOrder_args()
7439 
    args.read(iprot)
7440 
    iprot.readMessageEnd()
7441 
    result = getReturnOrder_result()
7442 
    try:
7443 
      result.success = self._handler.getReturnOrder(args.id)
7444 
    except TransactionServiceException, ex:
7445 
      result.ex = ex
7446 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7447 
    result.write(oprot)
7448 
    oprot.writeMessageEnd()
7449 
    oprot.trans.flush()
7450 
 
2690 chandransh 7451 
  def process_processReturn(self, seqid, iprot, oprot):
7452 
    args = processReturn_args()
7453 
    args.read(iprot)
7454 
    iprot.readMessageEnd()
7455 
    result = processReturn_result()
7456 
    try:
7457 
      self._handler.processReturn(args.returnOrderId)
7458 
    except TransactionServiceException, ex:
7459 
      result.ex = ex
7460 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7461 
    result.write(oprot)
7462 
    oprot.writeMessageEnd()
7463 
    oprot.trans.flush()
7464 
 
3451 chandransh 7465 
  def process_updateWeight(self, seqid, iprot, oprot):
7466 
    args = updateWeight_args()
7467 
    args.read(iprot)
7468 
    iprot.readMessageEnd()
7469 
    result = updateWeight_result()
7470 
    try:
7471 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7472 
    except TransactionServiceException, ex:
7473 
      result.ex = ex
7474 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7475 
    result.write(oprot)
7476 
    oprot.writeMessageEnd()
7477 
    oprot.trans.flush()
2819 chandransh 7478 
 
3469 chandransh 7479 
  def process_changeItem(self, seqid, iprot, oprot):
7480 
    args = changeItem_args()
7481 
    args.read(iprot)
7482 
    iprot.readMessageEnd()
7483 
    result = changeItem_result()
7484 
    try:
7485 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7486 
    except TransactionServiceException, ex:
7487 
      result.ex = ex
7488 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7489 
    result.write(oprot)
7490 
    oprot.writeMessageEnd()
7491 
    oprot.trans.flush()
3451 chandransh 7492 
 
3469 chandransh 7493 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7494 
    args = shiftToWarehouse_args()
7495 
    args.read(iprot)
7496 
    iprot.readMessageEnd()
7497 
    result = shiftToWarehouse_result()
7498 
    try:
7499 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7500 
    except TransactionServiceException, ex:
7501 
      result.ex = ex
7502 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7506 
 
3553 chandransh 7507 
  def process_addDelayReason(self, seqid, iprot, oprot):
7508 
    args = addDelayReason_args()
7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
7511 
    result = addDelayReason_result()
7512 
    try:
4647 rajveer 7513 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7514 
    except TransactionServiceException, ex:
7515 
      result.ex = ex
7516 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
3469 chandransh 7520 
 
3956 chandransh 7521 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7522 
    args = reconcileCodCollection_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = reconcileCodCollection_result()
7526 
    try:
7527 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
7530 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
3553 chandransh 7534 
 
4008 mandeep.dh 7535 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7536 
    args = getTransactionsRequiringExtraProcessing_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = getTransactionsRequiringExtraProcessing_result()
7540 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7541 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7542 
    result.write(oprot)
7543 
    oprot.writeMessageEnd()
7544 
    oprot.trans.flush()
3956 chandransh 7545 
 
4008 mandeep.dh 7546 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7547 
    args = markTransactionAsProcessed_args()
7548 
    args.read(iprot)
7549 
    iprot.readMessageEnd()
7550 
    result = markTransactionAsProcessed_result()
7551 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7552 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7553 
    result.write(oprot)
7554 
    oprot.writeMessageEnd()
7555 
    oprot.trans.flush()
7556 
 
4018 chandransh 7557 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7558 
    args = getItemWiseRiskyOrdersCount_args()
7559 
    args.read(iprot)
7560 
    iprot.readMessageEnd()
7561 
    result = getItemWiseRiskyOrdersCount_result()
7562 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7563 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7564 
    result.write(oprot)
7565 
    oprot.writeMessageEnd()
7566 
    oprot.trans.flush()
4008 mandeep.dh 7567 
 
4295 varun.gupt 7568 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7569 
    args = getOrdersForItemIds_args()
7570 
    args.read(iprot)
7571 
    iprot.readMessageEnd()
7572 
    result = getOrdersForItemIds_result()
7573 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7574 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7575 
    result.write(oprot)
7576 
    oprot.writeMessageEnd()
7577 
    oprot.trans.flush()
7578 
 
4247 rajveer 7579 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7580 
    args = markOrderCancellationRequestReceived_args()
7581 
    args.read(iprot)
7582 
    iprot.readMessageEnd()
7583 
    result = markOrderCancellationRequestReceived_result()
7584 
    try:
7585 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7586 
    except TransactionServiceException, ex:
7587 
      result.ex = ex
7588 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7589 
    result.write(oprot)
7590 
    oprot.writeMessageEnd()
7591 
    oprot.trans.flush()
4018 chandransh 7592 
 
4247 rajveer 7593 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7594 
    args = markOrderCancellationRequestConfirmed_args()
7595 
    args.read(iprot)
7596 
    iprot.readMessageEnd()
7597 
    result = markOrderCancellationRequestConfirmed_result()
7598 
    try:
7599 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7600 
    except TransactionServiceException, ex:
7601 
      result.ex = ex
7602 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7603 
    result.write(oprot)
7604 
    oprot.writeMessageEnd()
7605 
    oprot.trans.flush()
7606 
 
7607 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7608 
    args = markOrderCancellationRequestDenied_args()
7609 
    args.read(iprot)
7610 
    iprot.readMessageEnd()
7611 
    result = markOrderCancellationRequestDenied_result()
7612 
    try:
7613 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7614 
    except TransactionServiceException, ex:
7615 
      result.ex = ex
7616 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7617 
    result.write(oprot)
7618 
    oprot.writeMessageEnd()
7619 
    oprot.trans.flush()
7620 
 
4258 rajveer 7621 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7622 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7623 
    args.read(iprot)
7624 
    iprot.readMessageEnd()
4258 rajveer 7625 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7626 
    try:
4258 rajveer 7627 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7628 
    except TransactionServiceException, ex:
7629 
      result.ex = ex
4258 rajveer 7630 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
4259 anupam.sin 7635 
  def process_refundTransaction(self, seqid, iprot, oprot):
7636 
    args = refundTransaction_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = refundTransaction_result()
7640 
    try:
7641 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7642 
    except TransactionServiceException, ex:
7643 
      result.ex = ex
7644 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7645 
    result.write(oprot)
7646 
    oprot.writeMessageEnd()
7647 
    oprot.trans.flush()
4247 rajveer 7648 
 
4324 mandeep.dh 7649 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7650 
    args = updateShipmentAddress_args()
7651 
    args.read(iprot)
7652 
    iprot.readMessageEnd()
7653 
    result = updateShipmentAddress_result()
7654 
    try:
7655 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7656 
    except TransactionServiceException, ex:
7657 
      result.ex = ex
7658 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7659 
    result.write(oprot)
7660 
    oprot.writeMessageEnd()
7661 
    oprot.trans.flush()
7662 
 
4285 rajveer 7663 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7664 
    args = acceptOrdersForItemId_args()
7665 
    args.read(iprot)
7666 
    iprot.readMessageEnd()
7667 
    result = acceptOrdersForItemId_result()
7668 
    try:
7669 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7670 
    except TransactionServiceException, ex:
7671 
      result.ex = ex
7672 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7673 
    result.write(oprot)
7674 
    oprot.writeMessageEnd()
7675 
    oprot.trans.flush()
4259 anupam.sin 7676 
 
4303 rajveer 7677 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7678 
    args = markOrdersAsPORaised_args()
7679 
    args.read(iprot)
7680 
    iprot.readMessageEnd()
7681 
    result = markOrdersAsPORaised_result()
7682 
    try:
4369 rajveer 7683 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7684 
    except TransactionServiceException, ex:
7685 
      result.ex = ex
7686 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7687 
    result.write(oprot)
7688 
    oprot.writeMessageEnd()
7689 
    oprot.trans.flush()
4285 rajveer 7690 
 
4303 rajveer 7691 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7692 
    args = markOrdersAsReversalInitiated_args()
7693 
    args.read(iprot)
7694 
    iprot.readMessageEnd()
7695 
    result = markOrdersAsReversalInitiated_result()
7696 
    try:
4369 rajveer 7697 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7698 
    except TransactionServiceException, ex:
7699 
      result.ex = ex
7700 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
7704 
 
7705 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7706 
    args = markOrdersAsNotAvailabke_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = markOrdersAsNotAvailabke_result()
7710 
    try:
4369 rajveer 7711 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7712 
    except TransactionServiceException, ex:
7713 
      result.ex = ex
7714 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
4369 rajveer 7719 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7720 
    args = markOrdersAsTimeout_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = markOrdersAsTimeout_result()
7724 
    try:
7725 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7726 
    except TransactionServiceException, ex:
7727 
      result.ex = ex
7728 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7729 
    result.write(oprot)
7730 
    oprot.writeMessageEnd()
7731 
    oprot.trans.flush()
4303 rajveer 7732 
 
4662 rajveer 7733 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7734 
    args = markOrderAsLostInTransit_args()
7735 
    args.read(iprot)
7736 
    iprot.readMessageEnd()
7737 
    result = markOrderAsLostInTransit_result()
7738 
    try:
7739 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7740 
    except TransactionServiceException, ex:
7741 
      result.ex = ex
7742 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
7746 
 
4386 anupam.sin 7747 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7748 
    args = getOrderForAwb_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = getOrderForAwb_result()
7752 
    try:
7753 
      result.success = self._handler.getOrderForAwb(args.awb)
7754 
    except TransactionServiceException, ex:
7755 
      result.ex = ex
7756 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7757 
    result.write(oprot)
7758 
    oprot.writeMessageEnd()
7759 
    oprot.trans.flush()
4369 rajveer 7760 
 
4506 phani.kuma 7761 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7762 
    args = getOrdersForProviderForStatus_args()
7763 
    args.read(iprot)
7764 
    iprot.readMessageEnd()
7765 
    result = getOrdersForProviderForStatus_result()
7766 
    try:
4910 phani.kuma 7767 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7768 
    except TransactionServiceException, ex:
7769 
      result.ex = ex
7770 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
4386 anupam.sin 7774 
 
4600 varun.gupt 7775 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7776 
    args = getBilledOrdersForVendor_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = getBilledOrdersForVendor_result()
7780 
    try:
7781 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7782 
    except TransactionServiceException, ex:
7783 
      result.ex = ex
7784 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
4506 phani.kuma 7788 
 
4607 rajveer 7789 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7790 
    args = getSlippedSippingDateOrders_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = getSlippedSippingDateOrders_result()
7794 
    try:
7795 
      result.success = self._handler.getSlippedSippingDateOrders()
7796 
    except TransactionServiceException, ex:
7797 
      result.ex = ex
7798 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7799 
    result.write(oprot)
7800 
    oprot.writeMessageEnd()
7801 
    oprot.trans.flush()
7802 
 
4709 rajveer 7803 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7804 
    args = getCancelledOrders_args()
7805 
    args.read(iprot)
7806 
    iprot.readMessageEnd()
7807 
    result = getCancelledOrders_result()
7808 
    try:
7809 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7810 
    except TransactionServiceException, ex:
7811 
      result.ex = ex
7812 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7813 
    result.write(oprot)
7814 
    oprot.writeMessageEnd()
7815 
    oprot.trans.flush()
7816 
 
4600 varun.gupt 7817 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7818 
    args = saveBluedartSettlements_args()
7819 
    args.read(iprot)
7820 
    iprot.readMessageEnd()
7821 
    result = saveBluedartSettlements_result()
7822 
    try:
7823 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7824 
    except TransactionServiceException, ex:
7825 
      result.ex = ex
7826 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7827 
    result.write(oprot)
7828 
    oprot.writeMessageEnd()
7829 
    oprot.trans.flush()
7830 
 
7831 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7832 
    args = savePaymentSettlements_args()
7833 
    args.read(iprot)
7834 
    iprot.readMessageEnd()
7835 
    result = savePaymentSettlements_result()
7836 
    try:
4905 varun.gupt 7837 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7838 
    except TransactionServiceException, ex:
7839 
      result.ex = ex
7840 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
7844 
 
7845 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7846 
    args = saveEBSSettlementSummary_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = saveEBSSettlementSummary_result()
7850 
    try:
7851 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7852 
    except TransactionServiceException, ex:
7853 
      result.ex = ex
7854 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
5386 phani.kuma 7859 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7860 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
5386 phani.kuma 7863 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7864 
    try:
5386 phani.kuma 7865 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7866 
    except TransactionServiceException, ex:
7867 
      result.ex = ex
5386 phani.kuma 7868 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
5386 phani.kuma 7873 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7874 
    args = getSettlementForCod_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = getSettlementForCod_result()
7878 
    try:
7879 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7880 
    except TransactionServiceException, ex:
7881 
      result.ex = ex
7882 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
4600 varun.gupt 7887 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7888 
    args = getEBSSettlementSummaries_args()
7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
7891 
    result = getEBSSettlementSummaries_result()
7892 
    try:
7893 
      result.success = self._handler.getEBSSettlementSummaries()
7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
7896 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
7900 
 
7901 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7902 
    args = markEBSSettlementUploaded_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = markEBSSettlementUploaded_result()
7906 
    try:
7907 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
7914 
 
7915 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7916 
    args = getEBSSettlementDate_args()
7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
7919 
    result = getEBSSettlementDate_result()
7920 
    try:
7921 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7922 
    except TransactionServiceException, ex:
7923 
      result.ex = ex
7924 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
4715 varun.gupt 7929 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7930 
    args = getSettlementsByDate_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = getSettlementsByDate_result()
7934 
    try:
7935 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
4600 varun.gupt 7942 
 
4715 varun.gupt 7943 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7944 
    args = getReshippedOrderIds_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = getReshippedOrderIds_result()
7948 
    try:
7949 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7950 
    except TransactionServiceException, ex:
7951 
      result.ex = ex
7952 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7953 
    result.write(oprot)
7954 
    oprot.writeMessageEnd()
7955 
    oprot.trans.flush()
7956 
 
5481 phani.kuma 7957 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7958 
    args = getBilledOrders_args()
4875 varun.gupt 7959 
    args.read(iprot)
7960 
    iprot.readMessageEnd()
5481 phani.kuma 7961 
    result = getBilledOrders_result()
4875 varun.gupt 7962 
    try:
5481 phani.kuma 7963 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7964 
    except TransactionServiceException, ex:
7965 
      result.ex = ex
5481 phani.kuma 7966 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7967 
    result.write(oprot)
7968 
    oprot.writeMessageEnd()
7969 
    oprot.trans.flush()
4757 mandeep.dh 7970 
 
5031 varun.gupt 7971 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7972 
    args = getStatusDistributionOfOrders_args()
7973 
    args.read(iprot)
7974 
    iprot.readMessageEnd()
7975 
    result = getStatusDistributionOfOrders_result()
7976 
    try:
7977 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7978 
    except TransactionServiceException, ex:
7979 
      result.ex = ex
7980 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7981 
    result.write(oprot)
7982 
    oprot.writeMessageEnd()
7983 
    oprot.trans.flush()
4875 varun.gupt 7984 
 
5067 varun.gupt 7985 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7986 
    args = getOrderIdsForStatus_args()
7987 
    args.read(iprot)
7988 
    iprot.readMessageEnd()
7989 
    result = getOrderIdsForStatus_result()
7990 
    try:
7991 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7992 
    except TransactionServiceException, ex:
7993 
      result.ex = ex
7994 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
5031 varun.gupt 7998 
 
5348 anupam.sin 7999 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8000 
    args = updateCODAgent_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = updateCODAgent_result()
8004 
    try:
8005 
      self._handler.updateCODAgent(args.agent, args.orderId)
8006 
    except TransactionServiceException, ex:
8007 
      result.ex = ex
8008 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8009 
    result.write(oprot)
8010 
    oprot.writeMessageEnd()
8011 
    oprot.trans.flush()
8012 
 
5099 varun.gupt 8013 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8014 
    args = updateOrderAsPaidToVendor_args()
8015 
    args.read(iprot)
8016 
    iprot.readMessageEnd()
8017 
    result = updateOrderAsPaidToVendor_result()
8018 
    try:
8019 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8020 
    except TransactionServiceException, ex:
8021 
      result.ex = ex
8022 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8023 
    result.write(oprot)
8024 
    oprot.writeMessageEnd()
8025 
    oprot.trans.flush()
5067 varun.gupt 8026 
 
5386 phani.kuma 8027 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8028 
    args = updateOrderOnlyAsPaidToVendor_args()
8029 
    args.read(iprot)
8030 
    iprot.readMessageEnd()
8031 
    result = updateOrderOnlyAsPaidToVendor_result()
8032 
    try:
8033 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8034 
    except TransactionServiceException, ex:
8035 
      result.ex = ex
8036 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8037 
    result.write(oprot)
8038 
    oprot.writeMessageEnd()
8039 
    oprot.trans.flush()
8040 
 
5208 varun.gupt 8041 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8042 
    args = getRefundedOrdersMarkedPaid_args()
8043 
    args.read(iprot)
8044 
    iprot.readMessageEnd()
8045 
    result = getRefundedOrdersMarkedPaid_result()
8046 
    try:
8047 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8048 
    except TransactionServiceException, ex:
8049 
      result.ex = ex
8050 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8051 
    result.write(oprot)
8052 
    oprot.writeMessageEnd()
8053 
    oprot.trans.flush()
5099 varun.gupt 8054 
 
5447 anupam.sin 8055 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8056 
    args = getAllVerificationAgents_args()
8057 
    args.read(iprot)
8058 
    iprot.readMessageEnd()
8059 
    result = getAllVerificationAgents_result()
8060 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8061 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8062 
    result.write(oprot)
8063 
    oprot.writeMessageEnd()
8064 
    oprot.trans.flush()
5208 varun.gupt 8065 
 
5527 anupam.sin 8066 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8067 
    args = getAllAttributesForOrderId_args()
8068 
    args.read(iprot)
8069 
    iprot.readMessageEnd()
8070 
    result = getAllAttributesForOrderId_result()
8071 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8072 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8073 
    result.write(oprot)
8074 
    oprot.writeMessageEnd()
8075 
    oprot.trans.flush()
5447 anupam.sin 8076 
 
5676 rajveer 8077 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8078 
    args = setOrderAttributes_args()
8079 
    args.read(iprot)
8080 
    iprot.readMessageEnd()
8081 
    result = setOrderAttributes_result()
8082 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8083 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8084 
    result.write(oprot)
8085 
    oprot.writeMessageEnd()
8086 
    oprot.trans.flush()
8087 
 
5527 anupam.sin 8088 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8089 
    args = setOrderAttributeForTransaction_args()
8090 
    args.read(iprot)
8091 
    iprot.readMessageEnd()
8092 
    result = setOrderAttributeForTransaction_result()
8093 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8094 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
8098 
 
5553 rajveer 8099 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8100 
    args = getReceivePendingOrders_args()
8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
8103 
    result = getReceivePendingOrders_result()
8104 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8105 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8106 
    result.write(oprot)
8107 
    oprot.writeMessageEnd()
8108 
    oprot.trans.flush()
5527 anupam.sin 8109 
 
5553 rajveer 8110 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8111 
    args = getReceivedAtStoreOrders_args()
8112 
    args.read(iprot)
8113 
    iprot.readMessageEnd()
8114 
    result = getReceivedAtStoreOrders_result()
8115 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8116 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
8120 
 
5713 rajveer 8121 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8122 
    args = getOrdersCollectionAtStore_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = getOrdersCollectionAtStore_result()
8126 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8127 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8128 
    result.write(oprot)
8129 
    oprot.writeMessageEnd()
8130 
    oprot.trans.flush()
8131 
 
5833 rajveer 8132 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8133 
    args = getOrderAttributeValue_args()
8134 
    args.read(iprot)
8135 
    iprot.readMessageEnd()
8136 
    result = getOrderAttributeValue_result()
8137 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8138 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8139 
    result.write(oprot)
8140 
    oprot.writeMessageEnd()
8141 
    oprot.trans.flush()
8142 
 
6019 rajveer 8143 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8144 
    args = changeJacketNumber_args()
8145 
    args.read(iprot)
8146 
    iprot.readMessageEnd()
8147 
    result = changeJacketNumber_result()
8148 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8149 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8150 
    result.write(oprot)
8151 
    oprot.writeMessageEnd()
8152 
    oprot.trans.flush()
8153 
 
8154 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8155 
    args = markOrderAsRtoInTransit_args()
8156 
    args.read(iprot)
8157 
    iprot.readMessageEnd()
8158 
    result = markOrderAsRtoInTransit_result()
8159 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8160 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8161 
    result.write(oprot)
8162 
    oprot.writeMessageEnd()
8163 
    oprot.trans.flush()
8164 
 
5593 mandeep.dh 8165 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8166 
    args = acceptOrderForItem_args()
8167 
    args.read(iprot)
8168 
    iprot.readMessageEnd()
8169 
    result = acceptOrderForItem_result()
8170 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8171 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8172 
    result.write(oprot)
8173 
    oprot.writeMessageEnd()
8174 
    oprot.trans.flush()
5553 rajveer 8175 
 
6000 mandeep.dh 8176 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8177 
    args = createRechargeOrder_args()
8178 
    args.read(iprot)
8179 
    iprot.readMessageEnd()
8180 
    result = createRechargeOrder_result()
8181 
    try:
8182 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8183 
    except TransactionServiceException, ex:
8184 
      result.ex = ex
8185 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8186 
    result.write(oprot)
8187 
    oprot.writeMessageEnd()
8188 
    oprot.trans.flush()
5593 mandeep.dh 8189 
 
6031 rajveer 8190 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8191 
    args = getRechargeOrder_args()
8192 
    args.read(iprot)
8193 
    iprot.readMessageEnd()
8194 
    result = getRechargeOrder_result()
8195 
    try:
8196 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8197 
    except TransactionServiceException, ex:
8198 
      result.ex = ex
8199 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8200 
    result.write(oprot)
8201 
    oprot.writeMessageEnd()
8202 
    oprot.trans.flush()
8203 
 
8204 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8205 
    args = getRechargeOrders_args()
8206 
    args.read(iprot)
8207 
    iprot.readMessageEnd()
8208 
    result = getRechargeOrders_result()
8209 
    result.success = self._handler.getRechargeOrders(args.userId)
8210 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
6000 mandeep.dh 8215 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8216 
    args = updateRechargeOrderStatus_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = updateRechargeOrderStatus_result()
8220 
    try:
6031 rajveer 8221 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8222 
    except TransactionServiceException, ex:
8223 
      result.ex = ex
8224 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
8228 
 
8229 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8230 
    args = activateRechargeTxn_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = activateRechargeTxn_result()
8234 
    try:
6031 rajveer 8235 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8236 
    except TransactionServiceException, ex:
8237 
      result.ex = ex
8238 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8239 
    result.write(oprot)
8240 
    oprot.writeMessageEnd()
8241 
    oprot.trans.flush()
8242 
 
6031 rajveer 8243 
  def process_getUserWallet(self, seqid, iprot, oprot):
8244 
    args = getUserWallet_args()
6000 mandeep.dh 8245 
    args.read(iprot)
8246 
    iprot.readMessageEnd()
6031 rajveer 8247 
    result = getUserWallet_result()
8248 
    result.success = self._handler.getUserWallet(args.userId)
8249 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8250 
    result.write(oprot)
8251 
    oprot.writeMessageEnd()
8252 
    oprot.trans.flush()
8253 
 
6031 rajveer 8254 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8255 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8256 
    args.read(iprot)
8257 
    iprot.readMessageEnd()
6031 rajveer 8258 
    result = getUserWalletHistory_result()
8259 
    result.success = self._handler.getUserWalletHistory(args.userId)
8260 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8261 
    result.write(oprot)
8262 
    oprot.writeMessageEnd()
8263 
    oprot.trans.flush()
8264 
 
6050 anupam.sin 8265 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8266 
    args = getRechargeOrdersForTransaction_args()
8267 
    args.read(iprot)
8268 
    iprot.readMessageEnd()
8269 
    result = getRechargeOrdersForTransaction_result()
8270 
    try:
8271 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8272 
    except TransactionServiceException, ex:
8273 
      result.ex = ex
8274 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
8278 
 
6048 rajveer 8279 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8280 
    args = getServiceProviders_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = getServiceProviders_result()
6206 rajveer 8284 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8285 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8286 
    result.write(oprot)
8287 
    oprot.writeMessageEnd()
8288 
    oprot.trans.flush()
6000 mandeep.dh 8289 
 
6048 rajveer 8290 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8291 
    args = getServiceProviderForDevice_args()
8292 
    args.read(iprot)
8293 
    iprot.readMessageEnd()
8294 
    result = getServiceProviderForDevice_result()
6049 rajveer 8295 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8296 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8297 
    result.write(oprot)
8298 
    oprot.writeMessageEnd()
8299 
    oprot.trans.flush()
8300 
 
6269 rajveer 8301 
  def process_validateRecharge(self, seqid, iprot, oprot):
8302 
    args = validateRecharge_args()
8303 
    args.read(iprot)
8304 
    iprot.readMessageEnd()
8305 
    result = validateRecharge_result()
8306 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber)
8307 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8308 
    result.write(oprot)
8309 
    oprot.writeMessageEnd()
8310 
    oprot.trans.flush()
8311 
 
6094 rajveer 8312 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8313 
    args = getRechargeOrdersForDevice_args()
8314 
    args.read(iprot)
8315 
    iprot.readMessageEnd()
8316 
    result = getRechargeOrdersForDevice_result()
8317 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8318 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8319 
    result.write(oprot)
8320 
    oprot.writeMessageEnd()
8321 
    oprot.trans.flush()
6048 rajveer 8322 
 
6094 rajveer 8323 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8324 
    args = addAmountToWallet_args()
8325 
    args.read(iprot)
8326 
    iprot.readMessageEnd()
8327 
    result = addAmountToWallet_result()
8328 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8329 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8330 
    result.write(oprot)
8331 
    oprot.writeMessageEnd()
8332 
    oprot.trans.flush()
8333 
 
6188 rajveer 8334 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8335 
    args = getRechargeStatistics_args()
8336 
    args.read(iprot)
8337 
    iprot.readMessageEnd()
8338 
    result = getRechargeStatistics_result()
8339 
    result.success = self._handler.getRechargeStatistics()
8340 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8341 
    result.write(oprot)
8342 
    oprot.writeMessageEnd()
8343 
    oprot.trans.flush()
8344 
 
6154 rajveer 8345 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8346 
    args = getRechargeOrdersForStatus_args()
8347 
    args.read(iprot)
8348 
    iprot.readMessageEnd()
8349 
    result = getRechargeOrdersForStatus_result()
8350 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8351 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8352 
    result.write(oprot)
8353 
    oprot.writeMessageEnd()
8354 
    oprot.trans.flush()
6094 rajveer 8355 
 
6159 rajveer 8356 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8357 
    args = getPlansForOperator_args()
8358 
    args.read(iprot)
8359 
    iprot.readMessageEnd()
8360 
    result = getPlansForOperator_result()
8361 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8362 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8363 
    result.write(oprot)
8364 
    oprot.writeMessageEnd()
8365 
    oprot.trans.flush()
6154 rajveer 8366 
 
6159 rajveer 8367 
 
94 ashish 8368 
# HELPER FUNCTIONS AND STRUCTURES
8369 
 
8370 
class createTransaction_args:
8371 
  """
8372 
  Attributes:
8373 
   - transaction
8374 
  """
8375 
 
8376 
  thrift_spec = (
8377 
    None, # 0
8378 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8379 
  )
8380 
 
8381 
  def __init__(self, transaction=None,):
8382 
    self.transaction = transaction
8383 
 
8384 
  def read(self, iprot):
8385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8387 
      return
8388 
    iprot.readStructBegin()
8389 
    while True:
8390 
      (fname, ftype, fid) = iprot.readFieldBegin()
8391 
      if ftype == TType.STOP:
8392 
        break
8393 
      if fid == 1:
8394 
        if ftype == TType.STRUCT:
8395 
          self.transaction = Transaction()
8396 
          self.transaction.read(iprot)
8397 
        else:
8398 
          iprot.skip(ftype)
8399 
      else:
8400 
        iprot.skip(ftype)
8401 
      iprot.readFieldEnd()
8402 
    iprot.readStructEnd()
8403 
 
8404 
  def write(self, oprot):
8405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8407 
      return
8408 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8409 
    if self.transaction is not None:
94 ashish 8410 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8411 
      self.transaction.write(oprot)
8412 
      oprot.writeFieldEnd()
8413 
    oprot.writeFieldStop()
8414 
    oprot.writeStructEnd()
8415 
 
3431 rajveer 8416 
  def validate(self):
8417 
    return
8418 
 
8419 
 
94 ashish 8420 
  def __repr__(self):
8421 
    L = ['%s=%r' % (key, value)
8422 
      for key, value in self.__dict__.iteritems()]
8423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8424 
 
8425 
  def __eq__(self, other):
8426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8427 
 
8428 
  def __ne__(self, other):
8429 
    return not (self == other)
8430 
 
8431 
class createTransaction_result:
8432 
  """
8433 
  Attributes:
132 ashish 8434 
   - success
94 ashish 8435 
   - ex
8436 
  """
8437 
 
8438 
  thrift_spec = (
132 ashish 8439 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8441 
  )
8442 
 
132 ashish 8443 
  def __init__(self, success=None, ex=None,):
8444 
    self.success = success
94 ashish 8445 
    self.ex = ex
8446 
 
8447 
  def read(self, iprot):
8448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8450 
      return
8451 
    iprot.readStructBegin()
8452 
    while True:
8453 
      (fname, ftype, fid) = iprot.readFieldBegin()
8454 
      if ftype == TType.STOP:
8455 
        break
132 ashish 8456 
      if fid == 0:
8457 
        if ftype == TType.I64:
8458 
          self.success = iprot.readI64();
8459 
        else:
8460 
          iprot.skip(ftype)
8461 
      elif fid == 1:
94 ashish 8462 
        if ftype == TType.STRUCT:
8463 
          self.ex = TransactionServiceException()
8464 
          self.ex.read(iprot)
8465 
        else:
8466 
          iprot.skip(ftype)
8467 
      else:
8468 
        iprot.skip(ftype)
8469 
      iprot.readFieldEnd()
8470 
    iprot.readStructEnd()
8471 
 
8472 
  def write(self, oprot):
8473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8475 
      return
8476 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8477 
    if self.success is not None:
132 ashish 8478 
      oprot.writeFieldBegin('success', TType.I64, 0)
8479 
      oprot.writeI64(self.success)
8480 
      oprot.writeFieldEnd()
3431 rajveer 8481 
    if self.ex is not None:
94 ashish 8482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8483 
      self.ex.write(oprot)
8484 
      oprot.writeFieldEnd()
8485 
    oprot.writeFieldStop()
8486 
    oprot.writeStructEnd()
8487 
 
3431 rajveer 8488 
  def validate(self):
8489 
    return
8490 
 
8491 
 
94 ashish 8492 
  def __repr__(self):
8493 
    L = ['%s=%r' % (key, value)
8494 
      for key, value in self.__dict__.iteritems()]
8495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8496 
 
8497 
  def __eq__(self, other):
8498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8499 
 
8500 
  def __ne__(self, other):
8501 
    return not (self == other)
8502 
 
8503 
class getTransaction_args:
8504 
  """
8505 
  Attributes:
8506 
   - id
8507 
  """
8508 
 
8509 
  thrift_spec = (
8510 
    None, # 0
8511 
    (1, TType.I64, 'id', None, None, ), # 1
8512 
  )
8513 
 
8514 
  def __init__(self, id=None,):
8515 
    self.id = id
8516 
 
8517 
  def read(self, iprot):
8518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8520 
      return
8521 
    iprot.readStructBegin()
8522 
    while True:
8523 
      (fname, ftype, fid) = iprot.readFieldBegin()
8524 
      if ftype == TType.STOP:
8525 
        break
8526 
      if fid == 1:
8527 
        if ftype == TType.I64:
8528 
          self.id = iprot.readI64();
8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      else:
8532 
        iprot.skip(ftype)
8533 
      iprot.readFieldEnd()
8534 
    iprot.readStructEnd()
8535 
 
8536 
  def write(self, oprot):
8537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8539 
      return
8540 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8541 
    if self.id is not None:
94 ashish 8542 
      oprot.writeFieldBegin('id', TType.I64, 1)
8543 
      oprot.writeI64(self.id)
8544 
      oprot.writeFieldEnd()
8545 
    oprot.writeFieldStop()
8546 
    oprot.writeStructEnd()
8547 
 
3431 rajveer 8548 
  def validate(self):
8549 
    return
8550 
 
8551 
 
94 ashish 8552 
  def __repr__(self):
8553 
    L = ['%s=%r' % (key, value)
8554 
      for key, value in self.__dict__.iteritems()]
8555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8556 
 
8557 
  def __eq__(self, other):
8558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8559 
 
8560 
  def __ne__(self, other):
8561 
    return not (self == other)
8562 
 
8563 
class getTransaction_result:
8564 
  """
8565 
  Attributes:
8566 
   - success
8567 
   - ex
8568 
  """
8569 
 
8570 
  thrift_spec = (
8571 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8573 
  )
8574 
 
8575 
  def __init__(self, success=None, ex=None,):
8576 
    self.success = success
8577 
    self.ex = ex
8578 
 
8579 
  def read(self, iprot):
8580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8582 
      return
8583 
    iprot.readStructBegin()
8584 
    while True:
8585 
      (fname, ftype, fid) = iprot.readFieldBegin()
8586 
      if ftype == TType.STOP:
8587 
        break
8588 
      if fid == 0:
8589 
        if ftype == TType.STRUCT:
8590 
          self.success = Transaction()
8591 
          self.success.read(iprot)
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      elif fid == 1:
8595 
        if ftype == TType.STRUCT:
8596 
          self.ex = TransactionServiceException()
8597 
          self.ex.read(iprot)
8598 
        else:
8599 
          iprot.skip(ftype)
8600 
      else:
8601 
        iprot.skip(ftype)
8602 
      iprot.readFieldEnd()
8603 
    iprot.readStructEnd()
8604 
 
8605 
  def write(self, oprot):
8606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8608 
      return
8609 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8610 
    if self.success is not None:
94 ashish 8611 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8612 
      self.success.write(oprot)
8613 
      oprot.writeFieldEnd()
3431 rajveer 8614 
    if self.ex is not None:
94 ashish 8615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8616 
      self.ex.write(oprot)
8617 
      oprot.writeFieldEnd()
8618 
    oprot.writeFieldStop()
8619 
    oprot.writeStructEnd()
8620 
 
3431 rajveer 8621 
  def validate(self):
8622 
    return
8623 
 
8624 
 
94 ashish 8625 
  def __repr__(self):
8626 
    L = ['%s=%r' % (key, value)
8627 
      for key, value in self.__dict__.iteritems()]
8628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8629 
 
8630 
  def __eq__(self, other):
8631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8632 
 
8633 
  def __ne__(self, other):
8634 
    return not (self == other)
8635 
 
8636 
class getTransactionsForCustomer_args:
8637 
  """
8638 
  Attributes:
8639 
   - customerId
8640 
   - from_date
8641 
   - to_date
8642 
   - status
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    None, # 0
8647 
    (1, TType.I64, 'customerId', None, None, ), # 1
8648 
    (2, TType.I64, 'from_date', None, None, ), # 2
8649 
    (3, TType.I64, 'to_date', None, None, ), # 3
8650 
    (4, TType.I32, 'status', None, None, ), # 4
8651 
  )
8652 
 
8653 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8654 
    self.customerId = customerId
8655 
    self.from_date = from_date
8656 
    self.to_date = to_date
8657 
    self.status = status
8658 
 
8659 
  def read(self, iprot):
8660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8662 
      return
8663 
    iprot.readStructBegin()
8664 
    while True:
8665 
      (fname, ftype, fid) = iprot.readFieldBegin()
8666 
      if ftype == TType.STOP:
8667 
        break
8668 
      if fid == 1:
8669 
        if ftype == TType.I64:
8670 
          self.customerId = iprot.readI64();
8671 
        else:
8672 
          iprot.skip(ftype)
8673 
      elif fid == 2:
8674 
        if ftype == TType.I64:
8675 
          self.from_date = iprot.readI64();
8676 
        else:
8677 
          iprot.skip(ftype)
8678 
      elif fid == 3:
8679 
        if ftype == TType.I64:
8680 
          self.to_date = iprot.readI64();
8681 
        else:
8682 
          iprot.skip(ftype)
8683 
      elif fid == 4:
8684 
        if ftype == TType.I32:
8685 
          self.status = iprot.readI32();
8686 
        else:
8687 
          iprot.skip(ftype)
8688 
      else:
8689 
        iprot.skip(ftype)
8690 
      iprot.readFieldEnd()
8691 
    iprot.readStructEnd()
8692 
 
8693 
  def write(self, oprot):
8694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8696 
      return
8697 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8698 
    if self.customerId is not None:
94 ashish 8699 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8700 
      oprot.writeI64(self.customerId)
8701 
      oprot.writeFieldEnd()
3431 rajveer 8702 
    if self.from_date is not None:
94 ashish 8703 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8704 
      oprot.writeI64(self.from_date)
8705 
      oprot.writeFieldEnd()
3431 rajveer 8706 
    if self.to_date is not None:
94 ashish 8707 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8708 
      oprot.writeI64(self.to_date)
8709 
      oprot.writeFieldEnd()
3431 rajveer 8710 
    if self.status is not None:
94 ashish 8711 
      oprot.writeFieldBegin('status', TType.I32, 4)
8712 
      oprot.writeI32(self.status)
8713 
      oprot.writeFieldEnd()
8714 
    oprot.writeFieldStop()
8715 
    oprot.writeStructEnd()
8716 
 
3431 rajveer 8717 
  def validate(self):
8718 
    return
8719 
 
8720 
 
94 ashish 8721 
  def __repr__(self):
8722 
    L = ['%s=%r' % (key, value)
8723 
      for key, value in self.__dict__.iteritems()]
8724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8725 
 
8726 
  def __eq__(self, other):
8727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8728 
 
8729 
  def __ne__(self, other):
8730 
    return not (self == other)
8731 
 
8732 
class getTransactionsForCustomer_result:
8733 
  """
8734 
  Attributes:
8735 
   - success
8736 
   - ex
8737 
  """
8738 
 
8739 
  thrift_spec = (
8740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8742 
  )
8743 
 
8744 
  def __init__(self, success=None, ex=None,):
8745 
    self.success = success
8746 
    self.ex = ex
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 0:
8758 
        if ftype == TType.LIST:
8759 
          self.success = []
6188 rajveer 8760 
          (_etype109, _size106) = iprot.readListBegin()
8761 
          for _i110 in xrange(_size106):
8762 
            _elem111 = Transaction()
8763 
            _elem111.read(iprot)
8764 
            self.success.append(_elem111)
94 ashish 8765 
          iprot.readListEnd()
8766 
        else:
8767 
          iprot.skip(ftype)
8768 
      elif fid == 1:
8769 
        if ftype == TType.STRUCT:
8770 
          self.ex = TransactionServiceException()
8771 
          self.ex.read(iprot)
8772 
        else:
8773 
          iprot.skip(ftype)
8774 
      else:
8775 
        iprot.skip(ftype)
8776 
      iprot.readFieldEnd()
8777 
    iprot.readStructEnd()
8778 
 
8779 
  def write(self, oprot):
8780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8782 
      return
8783 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8784 
    if self.success is not None:
94 ashish 8785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8787 
      for iter112 in self.success:
8788 
        iter112.write(oprot)
94 ashish 8789 
      oprot.writeListEnd()
8790 
      oprot.writeFieldEnd()
3431 rajveer 8791 
    if self.ex is not None:
94 ashish 8792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8793 
      self.ex.write(oprot)
8794 
      oprot.writeFieldEnd()
8795 
    oprot.writeFieldStop()
8796 
    oprot.writeStructEnd()
8797 
 
3431 rajveer 8798 
  def validate(self):
8799 
    return
8800 
 
8801 
 
94 ashish 8802 
  def __repr__(self):
8803 
    L = ['%s=%r' % (key, value)
8804 
      for key, value in self.__dict__.iteritems()]
8805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8806 
 
8807 
  def __eq__(self, other):
8808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8809 
 
8810 
  def __ne__(self, other):
8811 
    return not (self == other)
8812 
 
132 ashish 8813 
class getTransactionsForShoppingCartId_args:
8814 
  """
8815 
  Attributes:
8816 
   - shoppingCartId
8817 
  """
8818 
 
8819 
  thrift_spec = (
8820 
    None, # 0
8821 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8822 
  )
8823 
 
8824 
  def __init__(self, shoppingCartId=None,):
8825 
    self.shoppingCartId = shoppingCartId
8826 
 
8827 
  def read(self, iprot):
8828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8830 
      return
8831 
    iprot.readStructBegin()
8832 
    while True:
8833 
      (fname, ftype, fid) = iprot.readFieldBegin()
8834 
      if ftype == TType.STOP:
8835 
        break
8836 
      if fid == 1:
8837 
        if ftype == TType.I64:
8838 
          self.shoppingCartId = iprot.readI64();
8839 
        else:
8840 
          iprot.skip(ftype)
8841 
      else:
8842 
        iprot.skip(ftype)
8843 
      iprot.readFieldEnd()
8844 
    iprot.readStructEnd()
8845 
 
8846 
  def write(self, oprot):
8847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8849 
      return
8850 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8851 
    if self.shoppingCartId is not None:
132 ashish 8852 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8853 
      oprot.writeI64(self.shoppingCartId)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
3431 rajveer 8858 
  def validate(self):
8859 
    return
8860 
 
8861 
 
132 ashish 8862 
  def __repr__(self):
8863 
    L = ['%s=%r' % (key, value)
8864 
      for key, value in self.__dict__.iteritems()]
8865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8866 
 
8867 
  def __eq__(self, other):
8868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8869 
 
8870 
  def __ne__(self, other):
8871 
    return not (self == other)
8872 
 
8873 
class getTransactionsForShoppingCartId_result:
8874 
  """
8875 
  Attributes:
8876 
   - success
8877 
   - ex
8878 
  """
8879 
 
8880 
  thrift_spec = (
8881 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8883 
  )
8884 
 
8885 
  def __init__(self, success=None, ex=None,):
8886 
    self.success = success
8887 
    self.ex = ex
8888 
 
8889 
  def read(self, iprot):
8890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8892 
      return
8893 
    iprot.readStructBegin()
8894 
    while True:
8895 
      (fname, ftype, fid) = iprot.readFieldBegin()
8896 
      if ftype == TType.STOP:
8897 
        break
8898 
      if fid == 0:
8899 
        if ftype == TType.LIST:
8900 
          self.success = []
6188 rajveer 8901 
          (_etype116, _size113) = iprot.readListBegin()
8902 
          for _i117 in xrange(_size113):
8903 
            _elem118 = Transaction()
8904 
            _elem118.read(iprot)
8905 
            self.success.append(_elem118)
132 ashish 8906 
          iprot.readListEnd()
8907 
        else:
8908 
          iprot.skip(ftype)
8909 
      elif fid == 1:
8910 
        if ftype == TType.STRUCT:
8911 
          self.ex = TransactionServiceException()
8912 
          self.ex.read(iprot)
8913 
        else:
8914 
          iprot.skip(ftype)
8915 
      else:
8916 
        iprot.skip(ftype)
8917 
      iprot.readFieldEnd()
8918 
    iprot.readStructEnd()
8919 
 
8920 
  def write(self, oprot):
8921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8923 
      return
8924 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8925 
    if self.success is not None:
132 ashish 8926 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8927 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8928 
      for iter119 in self.success:
8929 
        iter119.write(oprot)
132 ashish 8930 
      oprot.writeListEnd()
8931 
      oprot.writeFieldEnd()
3431 rajveer 8932 
    if self.ex is not None:
132 ashish 8933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8934 
      self.ex.write(oprot)
8935 
      oprot.writeFieldEnd()
8936 
    oprot.writeFieldStop()
8937 
    oprot.writeStructEnd()
8938 
 
3431 rajveer 8939 
  def validate(self):
8940 
    return
8941 
 
8942 
 
132 ashish 8943 
  def __repr__(self):
8944 
    L = ['%s=%r' % (key, value)
8945 
      for key, value in self.__dict__.iteritems()]
8946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8947 
 
8948 
  def __eq__(self, other):
8949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8950 
 
8951 
  def __ne__(self, other):
8952 
    return not (self == other)
8953 
 
94 ashish 8954 
class getTransactionStatus_args:
8955 
  """
8956 
  Attributes:
8957 
   - transactionId
8958 
  """
8959 
 
8960 
  thrift_spec = (
8961 
    None, # 0
8962 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8963 
  )
8964 
 
8965 
  def __init__(self, transactionId=None,):
8966 
    self.transactionId = transactionId
8967 
 
8968 
  def read(self, iprot):
8969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8971 
      return
8972 
    iprot.readStructBegin()
8973 
    while True:
8974 
      (fname, ftype, fid) = iprot.readFieldBegin()
8975 
      if ftype == TType.STOP:
8976 
        break
8977 
      if fid == 1:
8978 
        if ftype == TType.I64:
8979 
          self.transactionId = iprot.readI64();
8980 
        else:
8981 
          iprot.skip(ftype)
8982 
      else:
8983 
        iprot.skip(ftype)
8984 
      iprot.readFieldEnd()
8985 
    iprot.readStructEnd()
8986 
 
8987 
  def write(self, oprot):
8988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8990 
      return
8991 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8992 
    if self.transactionId is not None:
94 ashish 8993 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8994 
      oprot.writeI64(self.transactionId)
8995 
      oprot.writeFieldEnd()
8996 
    oprot.writeFieldStop()
8997 
    oprot.writeStructEnd()
8998 
 
3431 rajveer 8999 
  def validate(self):
9000 
    return
9001 
 
9002 
 
94 ashish 9003 
  def __repr__(self):
9004 
    L = ['%s=%r' % (key, value)
9005 
      for key, value in self.__dict__.iteritems()]
9006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9007 
 
9008 
  def __eq__(self, other):
9009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9010 
 
9011 
  def __ne__(self, other):
9012 
    return not (self == other)
9013 
 
9014 
class getTransactionStatus_result:
9015 
  """
9016 
  Attributes:
9017 
   - success
9018 
   - ex
9019 
  """
9020 
 
9021 
  thrift_spec = (
9022 
    (0, TType.I32, 'success', None, None, ), # 0
9023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9024 
  )
9025 
 
9026 
  def __init__(self, success=None, ex=None,):
9027 
    self.success = success
9028 
    self.ex = ex
9029 
 
9030 
  def read(self, iprot):
9031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9033 
      return
9034 
    iprot.readStructBegin()
9035 
    while True:
9036 
      (fname, ftype, fid) = iprot.readFieldBegin()
9037 
      if ftype == TType.STOP:
9038 
        break
9039 
      if fid == 0:
9040 
        if ftype == TType.I32:
9041 
          self.success = iprot.readI32();
9042 
        else:
9043 
          iprot.skip(ftype)
9044 
      elif fid == 1:
9045 
        if ftype == TType.STRUCT:
9046 
          self.ex = TransactionServiceException()
9047 
          self.ex.read(iprot)
9048 
        else:
9049 
          iprot.skip(ftype)
9050 
      else:
9051 
        iprot.skip(ftype)
9052 
      iprot.readFieldEnd()
9053 
    iprot.readStructEnd()
9054 
 
9055 
  def write(self, oprot):
9056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9058 
      return
9059 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9060 
    if self.success is not None:
94 ashish 9061 
      oprot.writeFieldBegin('success', TType.I32, 0)
9062 
      oprot.writeI32(self.success)
9063 
      oprot.writeFieldEnd()
3431 rajveer 9064 
    if self.ex is not None:
94 ashish 9065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9066 
      self.ex.write(oprot)
9067 
      oprot.writeFieldEnd()
9068 
    oprot.writeFieldStop()
9069 
    oprot.writeStructEnd()
9070 
 
3431 rajveer 9071 
  def validate(self):
9072 
    return
9073 
 
9074 
 
94 ashish 9075 
  def __repr__(self):
9076 
    L = ['%s=%r' % (key, value)
9077 
      for key, value in self.__dict__.iteritems()]
9078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9079 
 
9080 
  def __eq__(self, other):
9081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9082 
 
9083 
  def __ne__(self, other):
9084 
    return not (self == other)
9085 
 
9086 
class changeTransactionStatus_args:
9087 
  """
9088 
  Attributes:
9089 
   - transactionId
9090 
   - status
9091 
   - description
5527 anupam.sin 9092 
   - pickUp
9093 
   - orderType
94 ashish 9094 
  """
9095 
 
9096 
  thrift_spec = (
9097 
    None, # 0
9098 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9099 
    (2, TType.I32, 'status', None, None, ), # 2
9100 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9101 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9102 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9103 
  )
9104 
 
5527 anupam.sin 9105 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9106 
    self.transactionId = transactionId
9107 
    self.status = status
9108 
    self.description = description
5527 anupam.sin 9109 
    self.pickUp = pickUp
9110 
    self.orderType = orderType
94 ashish 9111 
 
9112 
  def read(self, iprot):
9113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9115 
      return
9116 
    iprot.readStructBegin()
9117 
    while True:
9118 
      (fname, ftype, fid) = iprot.readFieldBegin()
9119 
      if ftype == TType.STOP:
9120 
        break
9121 
      if fid == 1:
9122 
        if ftype == TType.I64:
9123 
          self.transactionId = iprot.readI64();
9124 
        else:
9125 
          iprot.skip(ftype)
9126 
      elif fid == 2:
9127 
        if ftype == TType.I32:
9128 
          self.status = iprot.readI32();
9129 
        else:
9130 
          iprot.skip(ftype)
9131 
      elif fid == 3:
9132 
        if ftype == TType.STRING:
9133 
          self.description = iprot.readString();
9134 
        else:
9135 
          iprot.skip(ftype)
5387 rajveer 9136 
      elif fid == 4:
5527 anupam.sin 9137 
        if ftype == TType.I64:
9138 
          self.pickUp = iprot.readI64();
5387 rajveer 9139 
        else:
9140 
          iprot.skip(ftype)
5527 anupam.sin 9141 
      elif fid == 5:
9142 
        if ftype == TType.I32:
9143 
          self.orderType = iprot.readI32();
9144 
        else:
9145 
          iprot.skip(ftype)
94 ashish 9146 
      else:
9147 
        iprot.skip(ftype)
9148 
      iprot.readFieldEnd()
9149 
    iprot.readStructEnd()
9150 
 
9151 
  def write(self, oprot):
9152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9154 
      return
9155 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9156 
    if self.transactionId is not None:
94 ashish 9157 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9158 
      oprot.writeI64(self.transactionId)
9159 
      oprot.writeFieldEnd()
3431 rajveer 9160 
    if self.status is not None:
94 ashish 9161 
      oprot.writeFieldBegin('status', TType.I32, 2)
9162 
      oprot.writeI32(self.status)
9163 
      oprot.writeFieldEnd()
3431 rajveer 9164 
    if self.description is not None:
94 ashish 9165 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9166 
      oprot.writeString(self.description)
9167 
      oprot.writeFieldEnd()
5527 anupam.sin 9168 
    if self.pickUp is not None:
9169 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9170 
      oprot.writeI64(self.pickUp)
5387 rajveer 9171 
      oprot.writeFieldEnd()
5527 anupam.sin 9172 
    if self.orderType is not None:
9173 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9174 
      oprot.writeI32(self.orderType)
9175 
      oprot.writeFieldEnd()
94 ashish 9176 
    oprot.writeFieldStop()
9177 
    oprot.writeStructEnd()
9178 
 
3431 rajveer 9179 
  def validate(self):
9180 
    return
9181 
 
9182 
 
94 ashish 9183 
  def __repr__(self):
9184 
    L = ['%s=%r' % (key, value)
9185 
      for key, value in self.__dict__.iteritems()]
9186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9187 
 
9188 
  def __eq__(self, other):
9189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9190 
 
9191 
  def __ne__(self, other):
9192 
    return not (self == other)
9193 
 
9194 
class changeTransactionStatus_result:
9195 
  """
9196 
  Attributes:
9197 
   - success
9198 
   - ex
9199 
  """
9200 
 
9201 
  thrift_spec = (
9202 
    (0, TType.BOOL, 'success', None, None, ), # 0
9203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9204 
  )
9205 
 
9206 
  def __init__(self, success=None, ex=None,):
9207 
    self.success = success
9208 
    self.ex = ex
9209 
 
9210 
  def read(self, iprot):
9211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9213 
      return
9214 
    iprot.readStructBegin()
9215 
    while True:
9216 
      (fname, ftype, fid) = iprot.readFieldBegin()
9217 
      if ftype == TType.STOP:
9218 
        break
9219 
      if fid == 0:
9220 
        if ftype == TType.BOOL:
9221 
          self.success = iprot.readBool();
9222 
        else:
9223 
          iprot.skip(ftype)
9224 
      elif fid == 1:
9225 
        if ftype == TType.STRUCT:
9226 
          self.ex = TransactionServiceException()
9227 
          self.ex.read(iprot)
9228 
        else:
9229 
          iprot.skip(ftype)
9230 
      else:
9231 
        iprot.skip(ftype)
9232 
      iprot.readFieldEnd()
9233 
    iprot.readStructEnd()
9234 
 
9235 
  def write(self, oprot):
9236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9238 
      return
9239 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9240 
    if self.success is not None:
94 ashish 9241 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9242 
      oprot.writeBool(self.success)
9243 
      oprot.writeFieldEnd()
3431 rajveer 9244 
    if self.ex is not None:
94 ashish 9245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9246 
      self.ex.write(oprot)
9247 
      oprot.writeFieldEnd()
9248 
    oprot.writeFieldStop()
9249 
    oprot.writeStructEnd()
9250 
 
3431 rajveer 9251 
  def validate(self):
9252 
    return
9253 
 
9254 
 
94 ashish 9255 
  def __repr__(self):
9256 
    L = ['%s=%r' % (key, value)
9257 
      for key, value in self.__dict__.iteritems()]
9258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9259 
 
9260 
  def __eq__(self, other):
9261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9262 
 
9263 
  def __ne__(self, other):
9264 
    return not (self == other)
9265 
 
1398 varun.gupt 9266 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9267 
  """
9268 
  Attributes:
9269 
   - transactionId
9270 
  """
9271 
 
9272 
  thrift_spec = (
9273 
    None, # 0
9274 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9275 
  )
9276 
 
9277 
  def __init__(self, transactionId=None,):
9278 
    self.transactionId = transactionId
9279 
 
9280 
  def read(self, iprot):
9281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9283 
      return
9284 
    iprot.readStructBegin()
9285 
    while True:
9286 
      (fname, ftype, fid) = iprot.readFieldBegin()
9287 
      if ftype == TType.STOP:
9288 
        break
9289 
      if fid == 1:
9290 
        if ftype == TType.I64:
9291 
          self.transactionId = iprot.readI64();
9292 
        else:
9293 
          iprot.skip(ftype)
9294 
      else:
9295 
        iprot.skip(ftype)
9296 
      iprot.readFieldEnd()
9297 
    iprot.readStructEnd()
9298 
 
9299 
  def write(self, oprot):
9300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9302 
      return
1398 varun.gupt 9303 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9304 
    if self.transactionId is not None:
1382 varun.gupt 9305 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9306 
      oprot.writeI64(self.transactionId)
9307 
      oprot.writeFieldEnd()
9308 
    oprot.writeFieldStop()
9309 
    oprot.writeStructEnd()
9310 
 
3431 rajveer 9311 
  def validate(self):
9312 
    return
9313 
 
9314 
 
1382 varun.gupt 9315 
  def __repr__(self):
9316 
    L = ['%s=%r' % (key, value)
9317 
      for key, value in self.__dict__.iteritems()]
9318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9319 
 
9320 
  def __eq__(self, other):
9321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9322 
 
9323 
  def __ne__(self, other):
9324 
    return not (self == other)
9325 
 
1398 varun.gupt 9326 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9327 
  """
9328 
  Attributes:
9329 
   - success
9330 
   - ex
9331 
  """
9332 
 
9333 
  thrift_spec = (
9334 
    (0, TType.BOOL, 'success', None, None, ), # 0
9335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9336 
  )
9337 
 
9338 
  def __init__(self, success=None, ex=None,):
9339 
    self.success = success
9340 
    self.ex = ex
9341 
 
9342 
  def read(self, iprot):
9343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9345 
      return
9346 
    iprot.readStructBegin()
9347 
    while True:
9348 
      (fname, ftype, fid) = iprot.readFieldBegin()
9349 
      if ftype == TType.STOP:
9350 
        break
9351 
      if fid == 0:
9352 
        if ftype == TType.BOOL:
9353 
          self.success = iprot.readBool();
9354 
        else:
9355 
          iprot.skip(ftype)
9356 
      elif fid == 1:
9357 
        if ftype == TType.STRUCT:
9358 
          self.ex = TransactionServiceException()
9359 
          self.ex.read(iprot)
9360 
        else:
9361 
          iprot.skip(ftype)
9362 
      else:
9363 
        iprot.skip(ftype)
9364 
      iprot.readFieldEnd()
9365 
    iprot.readStructEnd()
9366 
 
9367 
  def write(self, oprot):
9368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9370 
      return
1398 varun.gupt 9371 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9372 
    if self.success is not None:
1382 varun.gupt 9373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9374 
      oprot.writeBool(self.success)
9375 
      oprot.writeFieldEnd()
3431 rajveer 9376 
    if self.ex is not None:
1382 varun.gupt 9377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9378 
      self.ex.write(oprot)
9379 
      oprot.writeFieldEnd()
9380 
    oprot.writeFieldStop()
9381 
    oprot.writeStructEnd()
9382 
 
3431 rajveer 9383 
  def validate(self):
9384 
    return
9385 
 
9386 
 
1382 varun.gupt 9387 
  def __repr__(self):
9388 
    L = ['%s=%r' % (key, value)
9389 
      for key, value in self.__dict__.iteritems()]
9390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9391 
 
9392 
  def __eq__(self, other):
9393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9394 
 
9395 
  def __ne__(self, other):
9396 
    return not (self == other)
9397 
 
483 rajveer 9398 
class getAllOrders_args:
94 ashish 9399 
  """
9400 
  Attributes:
4801 anupam.sin 9401 
   - statuses
483 rajveer 9402 
   - from_date
9403 
   - to_date
9404 
   - warehouse_id
94 ashish 9405 
  """
9406 
 
9407 
  thrift_spec = (
9408 
    None, # 0
4801 anupam.sin 9409 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9410 
    (2, TType.I64, 'from_date', None, None, ), # 2
9411 
    (3, TType.I64, 'to_date', None, None, ), # 3
9412 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9413 
  )
9414 
 
4801 anupam.sin 9415 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9416 
    self.statuses = statuses
483 rajveer 9417 
    self.from_date = from_date
9418 
    self.to_date = to_date
9419 
    self.warehouse_id = warehouse_id
94 ashish 9420 
 
9421 
  def read(self, iprot):
9422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9424 
      return
9425 
    iprot.readStructBegin()
9426 
    while True:
9427 
      (fname, ftype, fid) = iprot.readFieldBegin()
9428 
      if ftype == TType.STOP:
9429 
        break
9430 
      if fid == 1:
4801 anupam.sin 9431 
        if ftype == TType.LIST:
9432 
          self.statuses = []
6188 rajveer 9433 
          (_etype123, _size120) = iprot.readListBegin()
9434 
          for _i124 in xrange(_size120):
9435 
            _elem125 = iprot.readI32();
9436 
            self.statuses.append(_elem125)
4801 anupam.sin 9437 
          iprot.readListEnd()
94 ashish 9438 
        else:
9439 
          iprot.skip(ftype)
483 rajveer 9440 
      elif fid == 2:
9441 
        if ftype == TType.I64:
9442 
          self.from_date = iprot.readI64();
94 ashish 9443 
        else:
9444 
          iprot.skip(ftype)
483 rajveer 9445 
      elif fid == 3:
9446 
        if ftype == TType.I64:
9447 
          self.to_date = iprot.readI64();
94 ashish 9448 
        else:
9449 
          iprot.skip(ftype)
483 rajveer 9450 
      elif fid == 4:
94 ashish 9451 
        if ftype == TType.I64:
483 rajveer 9452 
          self.warehouse_id = iprot.readI64();
94 ashish 9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      else:
9456 
        iprot.skip(ftype)
9457 
      iprot.readFieldEnd()
9458 
    iprot.readStructEnd()
9459 
 
9460 
  def write(self, oprot):
9461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9463 
      return
483 rajveer 9464 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9465 
    if self.statuses is not None:
9466 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9467 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9468 
      for iter126 in self.statuses:
9469 
        oprot.writeI32(iter126)
4801 anupam.sin 9470 
      oprot.writeListEnd()
94 ashish 9471 
      oprot.writeFieldEnd()
3431 rajveer 9472 
    if self.from_date is not None:
483 rajveer 9473 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9474 
      oprot.writeI64(self.from_date)
94 ashish 9475 
      oprot.writeFieldEnd()
3431 rajveer 9476 
    if self.to_date is not None:
483 rajveer 9477 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9478 
      oprot.writeI64(self.to_date)
94 ashish 9479 
      oprot.writeFieldEnd()
3431 rajveer 9480 
    if self.warehouse_id is not None:
483 rajveer 9481 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9482 
      oprot.writeI64(self.warehouse_id)
94 ashish 9483 
      oprot.writeFieldEnd()
9484 
    oprot.writeFieldStop()
9485 
    oprot.writeStructEnd()
9486 
 
3431 rajveer 9487 
  def validate(self):
9488 
    return
9489 
 
9490 
 
94 ashish 9491 
  def __repr__(self):
9492 
    L = ['%s=%r' % (key, value)
9493 
      for key, value in self.__dict__.iteritems()]
9494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9495 
 
9496 
  def __eq__(self, other):
9497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9498 
 
9499 
  def __ne__(self, other):
9500 
    return not (self == other)
9501 
 
483 rajveer 9502 
class getAllOrders_result:
94 ashish 9503 
  """
9504 
  Attributes:
9505 
   - success
9506 
   - ex
9507 
  """
9508 
 
9509 
  thrift_spec = (
483 rajveer 9510 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9511 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9512 
  )
9513 
 
9514 
  def __init__(self, success=None, ex=None,):
9515 
    self.success = success
9516 
    self.ex = ex
9517 
 
9518 
  def read(self, iprot):
9519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9521 
      return
9522 
    iprot.readStructBegin()
9523 
    while True:
9524 
      (fname, ftype, fid) = iprot.readFieldBegin()
9525 
      if ftype == TType.STOP:
9526 
        break
9527 
      if fid == 0:
483 rajveer 9528 
        if ftype == TType.LIST:
9529 
          self.success = []
6188 rajveer 9530 
          (_etype130, _size127) = iprot.readListBegin()
9531 
          for _i131 in xrange(_size127):
9532 
            _elem132 = Order()
9533 
            _elem132.read(iprot)
9534 
            self.success.append(_elem132)
483 rajveer 9535 
          iprot.readListEnd()
94 ashish 9536 
        else:
9537 
          iprot.skip(ftype)
9538 
      elif fid == 1:
9539 
        if ftype == TType.STRUCT:
9540 
          self.ex = TransactionServiceException()
9541 
          self.ex.read(iprot)
9542 
        else:
9543 
          iprot.skip(ftype)
9544 
      else:
9545 
        iprot.skip(ftype)
9546 
      iprot.readFieldEnd()
9547 
    iprot.readStructEnd()
9548 
 
9549 
  def write(self, oprot):
9550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9552 
      return
483 rajveer 9553 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9554 
    if self.success is not None:
483 rajveer 9555 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9556 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9557 
      for iter133 in self.success:
9558 
        iter133.write(oprot)
483 rajveer 9559 
      oprot.writeListEnd()
94 ashish 9560 
      oprot.writeFieldEnd()
3431 rajveer 9561 
    if self.ex is not None:
94 ashish 9562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9563 
      self.ex.write(oprot)
9564 
      oprot.writeFieldEnd()
9565 
    oprot.writeFieldStop()
9566 
    oprot.writeStructEnd()
9567 
 
3431 rajveer 9568 
  def validate(self):
9569 
    return
9570 
 
9571 
 
94 ashish 9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
4133 chandransh 9583 
class getOrdersInBatch_args:
9584 
  """
9585 
  Attributes:
9586 
   - statuses
9587 
   - offset
9588 
   - limit
9589 
   - warehouse_id
9590 
  """
9591 
 
9592 
  thrift_spec = (
9593 
    None, # 0
9594 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9595 
    (2, TType.I64, 'offset', None, None, ), # 2
9596 
    (3, TType.I64, 'limit', None, None, ), # 3
9597 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9598 
  )
9599 
 
9600 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9601 
    self.statuses = statuses
9602 
    self.offset = offset
9603 
    self.limit = limit
9604 
    self.warehouse_id = warehouse_id
9605 
 
9606 
  def read(self, iprot):
9607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9609 
      return
9610 
    iprot.readStructBegin()
9611 
    while True:
9612 
      (fname, ftype, fid) = iprot.readFieldBegin()
9613 
      if ftype == TType.STOP:
9614 
        break
9615 
      if fid == 1:
9616 
        if ftype == TType.LIST:
9617 
          self.statuses = []
6188 rajveer 9618 
          (_etype137, _size134) = iprot.readListBegin()
9619 
          for _i138 in xrange(_size134):
9620 
            _elem139 = iprot.readI32();
9621 
            self.statuses.append(_elem139)
4133 chandransh 9622 
          iprot.readListEnd()
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      elif fid == 2:
9626 
        if ftype == TType.I64:
9627 
          self.offset = iprot.readI64();
9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      elif fid == 3:
9631 
        if ftype == TType.I64:
9632 
          self.limit = iprot.readI64();
9633 
        else:
9634 
          iprot.skip(ftype)
9635 
      elif fid == 4:
9636 
        if ftype == TType.I64:
9637 
          self.warehouse_id = iprot.readI64();
9638 
        else:
9639 
          iprot.skip(ftype)
9640 
      else:
9641 
        iprot.skip(ftype)
9642 
      iprot.readFieldEnd()
9643 
    iprot.readStructEnd()
9644 
 
9645 
  def write(self, oprot):
9646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9648 
      return
9649 
    oprot.writeStructBegin('getOrdersInBatch_args')
9650 
    if self.statuses is not None:
9651 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9652 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9653 
      for iter140 in self.statuses:
9654 
        oprot.writeI32(iter140)
4133 chandransh 9655 
      oprot.writeListEnd()
9656 
      oprot.writeFieldEnd()
9657 
    if self.offset is not None:
9658 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9659 
      oprot.writeI64(self.offset)
9660 
      oprot.writeFieldEnd()
9661 
    if self.limit is not None:
9662 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9663 
      oprot.writeI64(self.limit)
9664 
      oprot.writeFieldEnd()
9665 
    if self.warehouse_id is not None:
9666 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9667 
      oprot.writeI64(self.warehouse_id)
9668 
      oprot.writeFieldEnd()
9669 
    oprot.writeFieldStop()
9670 
    oprot.writeStructEnd()
9671 
 
9672 
  def validate(self):
9673 
    return
9674 
 
9675 
 
9676 
  def __repr__(self):
9677 
    L = ['%s=%r' % (key, value)
9678 
      for key, value in self.__dict__.iteritems()]
9679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9680 
 
9681 
  def __eq__(self, other):
9682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9683 
 
9684 
  def __ne__(self, other):
9685 
    return not (self == other)
9686 
 
9687 
class getOrdersInBatch_result:
9688 
  """
9689 
  Attributes:
9690 
   - success
9691 
   - ex
9692 
  """
9693 
 
9694 
  thrift_spec = (
9695 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9697 
  )
9698 
 
9699 
  def __init__(self, success=None, ex=None,):
9700 
    self.success = success
9701 
    self.ex = ex
9702 
 
9703 
  def read(self, iprot):
9704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9706 
      return
9707 
    iprot.readStructBegin()
9708 
    while True:
9709 
      (fname, ftype, fid) = iprot.readFieldBegin()
9710 
      if ftype == TType.STOP:
9711 
        break
9712 
      if fid == 0:
9713 
        if ftype == TType.LIST:
9714 
          self.success = []
6188 rajveer 9715 
          (_etype144, _size141) = iprot.readListBegin()
9716 
          for _i145 in xrange(_size141):
9717 
            _elem146 = Order()
9718 
            _elem146.read(iprot)
9719 
            self.success.append(_elem146)
4133 chandransh 9720 
          iprot.readListEnd()
9721 
        else:
9722 
          iprot.skip(ftype)
9723 
      elif fid == 1:
9724 
        if ftype == TType.STRUCT:
9725 
          self.ex = TransactionServiceException()
9726 
          self.ex.read(iprot)
9727 
        else:
9728 
          iprot.skip(ftype)
9729 
      else:
9730 
        iprot.skip(ftype)
9731 
      iprot.readFieldEnd()
9732 
    iprot.readStructEnd()
9733 
 
9734 
  def write(self, oprot):
9735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9737 
      return
9738 
    oprot.writeStructBegin('getOrdersInBatch_result')
9739 
    if self.success is not None:
9740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9742 
      for iter147 in self.success:
9743 
        iter147.write(oprot)
4133 chandransh 9744 
      oprot.writeListEnd()
9745 
      oprot.writeFieldEnd()
9746 
    if self.ex is not None:
9747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9748 
      self.ex.write(oprot)
9749 
      oprot.writeFieldEnd()
9750 
    oprot.writeFieldStop()
9751 
    oprot.writeStructEnd()
9752 
 
9753 
  def validate(self):
9754 
    return
9755 
 
9756 
 
9757 
  def __repr__(self):
9758 
    L = ['%s=%r' % (key, value)
9759 
      for key, value in self.__dict__.iteritems()]
9760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9761 
 
9762 
  def __eq__(self, other):
9763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9764 
 
9765 
  def __ne__(self, other):
9766 
    return not (self == other)
9767 
 
9768 
class getOrderCount_args:
9769 
  """
9770 
  Attributes:
9771 
   - statuses
9772 
   - warehouseId
9773 
  """
9774 
 
9775 
  thrift_spec = (
9776 
    None, # 0
9777 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9778 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9779 
  )
9780 
 
9781 
  def __init__(self, statuses=None, warehouseId=None,):
9782 
    self.statuses = statuses
9783 
    self.warehouseId = warehouseId
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 1:
9795 
        if ftype == TType.LIST:
9796 
          self.statuses = []
6188 rajveer 9797 
          (_etype151, _size148) = iprot.readListBegin()
9798 
          for _i152 in xrange(_size148):
9799 
            _elem153 = iprot.readI32();
9800 
            self.statuses.append(_elem153)
4133 chandransh 9801 
          iprot.readListEnd()
9802 
        else:
9803 
          iprot.skip(ftype)
9804 
      elif fid == 2:
9805 
        if ftype == TType.I64:
9806 
          self.warehouseId = iprot.readI64();
9807 
        else:
9808 
          iprot.skip(ftype)
9809 
      else:
9810 
        iprot.skip(ftype)
9811 
      iprot.readFieldEnd()
9812 
    iprot.readStructEnd()
9813 
 
9814 
  def write(self, oprot):
9815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9817 
      return
9818 
    oprot.writeStructBegin('getOrderCount_args')
9819 
    if self.statuses is not None:
9820 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9821 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9822 
      for iter154 in self.statuses:
9823 
        oprot.writeI32(iter154)
4133 chandransh 9824 
      oprot.writeListEnd()
9825 
      oprot.writeFieldEnd()
9826 
    if self.warehouseId is not None:
9827 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9828 
      oprot.writeI64(self.warehouseId)
9829 
      oprot.writeFieldEnd()
9830 
    oprot.writeFieldStop()
9831 
    oprot.writeStructEnd()
9832 
 
9833 
  def validate(self):
9834 
    return
9835 
 
9836 
 
9837 
  def __repr__(self):
9838 
    L = ['%s=%r' % (key, value)
9839 
      for key, value in self.__dict__.iteritems()]
9840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9841 
 
9842 
  def __eq__(self, other):
9843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9844 
 
9845 
  def __ne__(self, other):
9846 
    return not (self == other)
9847 
 
9848 
class getOrderCount_result:
9849 
  """
9850 
  Attributes:
9851 
   - success
9852 
   - ex
9853 
  """
9854 
 
9855 
  thrift_spec = (
9856 
    (0, TType.I32, 'success', None, None, ), # 0
9857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9858 
  )
9859 
 
9860 
  def __init__(self, success=None, ex=None,):
9861 
    self.success = success
9862 
    self.ex = ex
9863 
 
9864 
  def read(self, iprot):
9865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9867 
      return
9868 
    iprot.readStructBegin()
9869 
    while True:
9870 
      (fname, ftype, fid) = iprot.readFieldBegin()
9871 
      if ftype == TType.STOP:
9872 
        break
9873 
      if fid == 0:
9874 
        if ftype == TType.I32:
9875 
          self.success = iprot.readI32();
9876 
        else:
9877 
          iprot.skip(ftype)
9878 
      elif fid == 1:
9879 
        if ftype == TType.STRUCT:
9880 
          self.ex = TransactionServiceException()
9881 
          self.ex.read(iprot)
9882 
        else:
9883 
          iprot.skip(ftype)
9884 
      else:
9885 
        iprot.skip(ftype)
9886 
      iprot.readFieldEnd()
9887 
    iprot.readStructEnd()
9888 
 
9889 
  def write(self, oprot):
9890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9892 
      return
9893 
    oprot.writeStructBegin('getOrderCount_result')
9894 
    if self.success is not None:
9895 
      oprot.writeFieldBegin('success', TType.I32, 0)
9896 
      oprot.writeI32(self.success)
9897 
      oprot.writeFieldEnd()
9898 
    if self.ex is not None:
9899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9900 
      self.ex.write(oprot)
9901 
      oprot.writeFieldEnd()
9902 
    oprot.writeFieldStop()
9903 
    oprot.writeStructEnd()
9904 
 
9905 
  def validate(self):
9906 
    return
9907 
 
9908 
 
9909 
  def __repr__(self):
9910 
    L = ['%s=%r' % (key, value)
9911 
      for key, value in self.__dict__.iteritems()]
9912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9913 
 
9914 
  def __eq__(self, other):
9915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9916 
 
9917 
  def __ne__(self, other):
9918 
    return not (self == other)
9919 
 
999 varun.gupt 9920 
class getOrdersByBillingDate_args:
9921 
  """
9922 
  Attributes:
9923 
   - status
9924 
   - start_billing_date
9925 
   - end_billing_date
9926 
   - warehouse_id
9927 
  """
9928 
 
9929 
  thrift_spec = (
9930 
    None, # 0
9931 
    (1, TType.I32, 'status', None, None, ), # 1
9932 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9933 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9934 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9935 
  )
9936 
 
9937 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9938 
    self.status = status
9939 
    self.start_billing_date = start_billing_date
9940 
    self.end_billing_date = end_billing_date
9941 
    self.warehouse_id = warehouse_id
9942 
 
9943 
  def read(self, iprot):
9944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9946 
      return
9947 
    iprot.readStructBegin()
9948 
    while True:
9949 
      (fname, ftype, fid) = iprot.readFieldBegin()
9950 
      if ftype == TType.STOP:
9951 
        break
9952 
      if fid == 1:
9953 
        if ftype == TType.I32:
9954 
          self.status = iprot.readI32();
9955 
        else:
9956 
          iprot.skip(ftype)
9957 
      elif fid == 2:
9958 
        if ftype == TType.I64:
9959 
          self.start_billing_date = iprot.readI64();
9960 
        else:
9961 
          iprot.skip(ftype)
9962 
      elif fid == 3:
9963 
        if ftype == TType.I64:
9964 
          self.end_billing_date = iprot.readI64();
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      elif fid == 4:
9968 
        if ftype == TType.I64:
9969 
          self.warehouse_id = iprot.readI64();
9970 
        else:
9971 
          iprot.skip(ftype)
9972 
      else:
9973 
        iprot.skip(ftype)
9974 
      iprot.readFieldEnd()
9975 
    iprot.readStructEnd()
9976 
 
9977 
  def write(self, oprot):
9978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9980 
      return
9981 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9982 
    if self.status is not None:
999 varun.gupt 9983 
      oprot.writeFieldBegin('status', TType.I32, 1)
9984 
      oprot.writeI32(self.status)
9985 
      oprot.writeFieldEnd()
3431 rajveer 9986 
    if self.start_billing_date is not None:
999 varun.gupt 9987 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9988 
      oprot.writeI64(self.start_billing_date)
9989 
      oprot.writeFieldEnd()
3431 rajveer 9990 
    if self.end_billing_date is not None:
999 varun.gupt 9991 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9992 
      oprot.writeI64(self.end_billing_date)
9993 
      oprot.writeFieldEnd()
3431 rajveer 9994 
    if self.warehouse_id is not None:
999 varun.gupt 9995 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9996 
      oprot.writeI64(self.warehouse_id)
9997 
      oprot.writeFieldEnd()
9998 
    oprot.writeFieldStop()
9999 
    oprot.writeStructEnd()
10000 
 
3431 rajveer 10001 
  def validate(self):
10002 
    return
10003 
 
10004 
 
999 varun.gupt 10005 
  def __repr__(self):
10006 
    L = ['%s=%r' % (key, value)
10007 
      for key, value in self.__dict__.iteritems()]
10008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10009 
 
10010 
  def __eq__(self, other):
10011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10012 
 
10013 
  def __ne__(self, other):
10014 
    return not (self == other)
10015 
 
10016 
class getOrdersByBillingDate_result:
10017 
  """
10018 
  Attributes:
10019 
   - success
10020 
   - ex
10021 
  """
10022 
 
10023 
  thrift_spec = (
10024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10026 
  )
10027 
 
10028 
  def __init__(self, success=None, ex=None,):
10029 
    self.success = success
10030 
    self.ex = ex
10031 
 
10032 
  def read(self, iprot):
10033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10035 
      return
10036 
    iprot.readStructBegin()
10037 
    while True:
10038 
      (fname, ftype, fid) = iprot.readFieldBegin()
10039 
      if ftype == TType.STOP:
10040 
        break
10041 
      if fid == 0:
10042 
        if ftype == TType.LIST:
10043 
          self.success = []
6188 rajveer 10044 
          (_etype158, _size155) = iprot.readListBegin()
10045 
          for _i159 in xrange(_size155):
10046 
            _elem160 = Order()
10047 
            _elem160.read(iprot)
10048 
            self.success.append(_elem160)
999 varun.gupt 10049 
          iprot.readListEnd()
10050 
        else:
10051 
          iprot.skip(ftype)
10052 
      elif fid == 1:
10053 
        if ftype == TType.STRUCT:
10054 
          self.ex = TransactionServiceException()
10055 
          self.ex.read(iprot)
10056 
        else:
10057 
          iprot.skip(ftype)
10058 
      else:
10059 
        iprot.skip(ftype)
10060 
      iprot.readFieldEnd()
10061 
    iprot.readStructEnd()
10062 
 
10063 
  def write(self, oprot):
10064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10066 
      return
10067 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10068 
    if self.success is not None:
999 varun.gupt 10069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10070 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10071 
      for iter161 in self.success:
10072 
        iter161.write(oprot)
999 varun.gupt 10073 
      oprot.writeListEnd()
10074 
      oprot.writeFieldEnd()
3431 rajveer 10075 
    if self.ex is not None:
999 varun.gupt 10076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10077 
      self.ex.write(oprot)
10078 
      oprot.writeFieldEnd()
10079 
    oprot.writeFieldStop()
10080 
    oprot.writeStructEnd()
10081 
 
3431 rajveer 10082 
  def validate(self):
10083 
    return
10084 
 
10085 
 
999 varun.gupt 10086 
  def __repr__(self):
10087 
    L = ['%s=%r' % (key, value)
10088 
      for key, value in self.__dict__.iteritems()]
10089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10090 
 
10091 
  def __eq__(self, other):
10092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10093 
 
10094 
  def __ne__(self, other):
10095 
    return not (self == other)
10096 
 
3427 chandransh 10097 
class getOrdersByShippingDate_args:
10098 
  """
10099 
  Attributes:
10100 
   - fromShippingDate
10101 
   - toShippingDate
10102 
   - providerId
10103 
   - warehouseId
3451 chandransh 10104 
   - cod
3427 chandransh 10105 
  """
10106 
 
10107 
  thrift_spec = (
10108 
    None, # 0
10109 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10110 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10111 
    (3, TType.I64, 'providerId', None, None, ), # 3
10112 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10113 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10114 
  )
10115 
 
3451 chandransh 10116 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10117 
    self.fromShippingDate = fromShippingDate
10118 
    self.toShippingDate = toShippingDate
10119 
    self.providerId = providerId
10120 
    self.warehouseId = warehouseId
3451 chandransh 10121 
    self.cod = cod
3427 chandransh 10122 
 
10123 
  def read(self, iprot):
10124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10126 
      return
10127 
    iprot.readStructBegin()
10128 
    while True:
10129 
      (fname, ftype, fid) = iprot.readFieldBegin()
10130 
      if ftype == TType.STOP:
10131 
        break
10132 
      if fid == 1:
10133 
        if ftype == TType.I64:
10134 
          self.fromShippingDate = iprot.readI64();
10135 
        else:
10136 
          iprot.skip(ftype)
10137 
      elif fid == 2:
10138 
        if ftype == TType.I64:
10139 
          self.toShippingDate = iprot.readI64();
10140 
        else:
10141 
          iprot.skip(ftype)
10142 
      elif fid == 3:
10143 
        if ftype == TType.I64:
10144 
          self.providerId = iprot.readI64();
10145 
        else:
10146 
          iprot.skip(ftype)
10147 
      elif fid == 4:
10148 
        if ftype == TType.I64:
10149 
          self.warehouseId = iprot.readI64();
10150 
        else:
10151 
          iprot.skip(ftype)
3451 chandransh 10152 
      elif fid == 5:
10153 
        if ftype == TType.BOOL:
10154 
          self.cod = iprot.readBool();
10155 
        else:
10156 
          iprot.skip(ftype)
3427 chandransh 10157 
      else:
10158 
        iprot.skip(ftype)
10159 
      iprot.readFieldEnd()
10160 
    iprot.readStructEnd()
10161 
 
10162 
  def write(self, oprot):
10163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10165 
      return
10166 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10167 
    if self.fromShippingDate is not None:
3427 chandransh 10168 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10169 
      oprot.writeI64(self.fromShippingDate)
10170 
      oprot.writeFieldEnd()
3431 rajveer 10171 
    if self.toShippingDate is not None:
3427 chandransh 10172 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10173 
      oprot.writeI64(self.toShippingDate)
10174 
      oprot.writeFieldEnd()
3431 rajveer 10175 
    if self.providerId is not None:
3427 chandransh 10176 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10177 
      oprot.writeI64(self.providerId)
10178 
      oprot.writeFieldEnd()
3431 rajveer 10179 
    if self.warehouseId is not None:
3427 chandransh 10180 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10181 
      oprot.writeI64(self.warehouseId)
10182 
      oprot.writeFieldEnd()
3451 chandransh 10183 
    if self.cod is not None:
10184 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10185 
      oprot.writeBool(self.cod)
10186 
      oprot.writeFieldEnd()
3427 chandransh 10187 
    oprot.writeFieldStop()
10188 
    oprot.writeStructEnd()
10189 
 
3431 rajveer 10190 
  def validate(self):
10191 
    return
10192 
 
10193 
 
3427 chandransh 10194 
  def __repr__(self):
10195 
    L = ['%s=%r' % (key, value)
10196 
      for key, value in self.__dict__.iteritems()]
10197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10198 
 
10199 
  def __eq__(self, other):
10200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10201 
 
10202 
  def __ne__(self, other):
10203 
    return not (self == other)
10204 
 
10205 
class getOrdersByShippingDate_result:
10206 
  """
10207 
  Attributes:
10208 
   - success
10209 
   - ex
10210 
  """
10211 
 
10212 
  thrift_spec = (
10213 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10214 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10215 
  )
10216 
 
10217 
  def __init__(self, success=None, ex=None,):
10218 
    self.success = success
10219 
    self.ex = ex
10220 
 
10221 
  def read(self, iprot):
10222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10224 
      return
10225 
    iprot.readStructBegin()
10226 
    while True:
10227 
      (fname, ftype, fid) = iprot.readFieldBegin()
10228 
      if ftype == TType.STOP:
10229 
        break
10230 
      if fid == 0:
10231 
        if ftype == TType.LIST:
10232 
          self.success = []
6188 rajveer 10233 
          (_etype165, _size162) = iprot.readListBegin()
10234 
          for _i166 in xrange(_size162):
10235 
            _elem167 = Order()
10236 
            _elem167.read(iprot)
10237 
            self.success.append(_elem167)
3427 chandransh 10238 
          iprot.readListEnd()
10239 
        else:
10240 
          iprot.skip(ftype)
10241 
      elif fid == 1:
10242 
        if ftype == TType.STRUCT:
10243 
          self.ex = TransactionServiceException()
10244 
          self.ex.read(iprot)
10245 
        else:
10246 
          iprot.skip(ftype)
10247 
      else:
10248 
        iprot.skip(ftype)
10249 
      iprot.readFieldEnd()
10250 
    iprot.readStructEnd()
10251 
 
10252 
  def write(self, oprot):
10253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10255 
      return
10256 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10257 
    if self.success is not None:
3427 chandransh 10258 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10259 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10260 
      for iter168 in self.success:
10261 
        iter168.write(oprot)
3427 chandransh 10262 
      oprot.writeListEnd()
10263 
      oprot.writeFieldEnd()
3431 rajveer 10264 
    if self.ex is not None:
3427 chandransh 10265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10266 
      self.ex.write(oprot)
10267 
      oprot.writeFieldEnd()
10268 
    oprot.writeFieldStop()
10269 
    oprot.writeStructEnd()
10270 
 
3431 rajveer 10271 
  def validate(self):
10272 
    return
10273 
 
10274 
 
3427 chandransh 10275 
  def __repr__(self):
10276 
    L = ['%s=%r' % (key, value)
10277 
      for key, value in self.__dict__.iteritems()]
10278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10279 
 
10280 
  def __eq__(self, other):
10281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10282 
 
10283 
  def __ne__(self, other):
10284 
    return not (self == other)
10285 
 
1382 varun.gupt 10286 
class getReturnableOrdersForCustomer_args:
10287 
  """
10288 
  Attributes:
10289 
   - customer_id
10290 
   - limit
10291 
  """
10292 
 
10293 
  thrift_spec = (
10294 
    None, # 0
10295 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10296 
    (2, TType.I64, 'limit', None, None, ), # 2
10297 
  )
10298 
 
10299 
  def __init__(self, customer_id=None, limit=None,):
10300 
    self.customer_id = customer_id
10301 
    self.limit = limit
10302 
 
10303 
  def read(self, iprot):
10304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10306 
      return
10307 
    iprot.readStructBegin()
10308 
    while True:
10309 
      (fname, ftype, fid) = iprot.readFieldBegin()
10310 
      if ftype == TType.STOP:
10311 
        break
10312 
      if fid == 1:
10313 
        if ftype == TType.I64:
10314 
          self.customer_id = iprot.readI64();
10315 
        else:
10316 
          iprot.skip(ftype)
10317 
      elif fid == 2:
10318 
        if ftype == TType.I64:
10319 
          self.limit = iprot.readI64();
10320 
        else:
10321 
          iprot.skip(ftype)
10322 
      else:
10323 
        iprot.skip(ftype)
10324 
      iprot.readFieldEnd()
10325 
    iprot.readStructEnd()
10326 
 
10327 
  def write(self, oprot):
10328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10330 
      return
10331 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10332 
    if self.customer_id is not None:
1382 varun.gupt 10333 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10334 
      oprot.writeI64(self.customer_id)
10335 
      oprot.writeFieldEnd()
3431 rajveer 10336 
    if self.limit is not None:
1382 varun.gupt 10337 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10338 
      oprot.writeI64(self.limit)
10339 
      oprot.writeFieldEnd()
10340 
    oprot.writeFieldStop()
10341 
    oprot.writeStructEnd()
10342 
 
3431 rajveer 10343 
  def validate(self):
10344 
    return
10345 
 
10346 
 
1382 varun.gupt 10347 
  def __repr__(self):
10348 
    L = ['%s=%r' % (key, value)
10349 
      for key, value in self.__dict__.iteritems()]
10350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10351 
 
10352 
  def __eq__(self, other):
10353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10354 
 
10355 
  def __ne__(self, other):
10356 
    return not (self == other)
10357 
 
10358 
class getReturnableOrdersForCustomer_result:
10359 
  """
10360 
  Attributes:
10361 
   - success
10362 
   - ex
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10368 
  )
10369 
 
10370 
  def __init__(self, success=None, ex=None,):
10371 
    self.success = success
10372 
    self.ex = ex
10373 
 
10374 
  def read(self, iprot):
10375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10377 
      return
10378 
    iprot.readStructBegin()
10379 
    while True:
10380 
      (fname, ftype, fid) = iprot.readFieldBegin()
10381 
      if ftype == TType.STOP:
10382 
        break
10383 
      if fid == 0:
10384 
        if ftype == TType.LIST:
10385 
          self.success = []
6188 rajveer 10386 
          (_etype172, _size169) = iprot.readListBegin()
10387 
          for _i173 in xrange(_size169):
10388 
            _elem174 = iprot.readI64();
10389 
            self.success.append(_elem174)
1382 varun.gupt 10390 
          iprot.readListEnd()
10391 
        else:
10392 
          iprot.skip(ftype)
10393 
      elif fid == 1:
10394 
        if ftype == TType.STRUCT:
10395 
          self.ex = TransactionServiceException()
10396 
          self.ex.read(iprot)
10397 
        else:
10398 
          iprot.skip(ftype)
10399 
      else:
10400 
        iprot.skip(ftype)
10401 
      iprot.readFieldEnd()
10402 
    iprot.readStructEnd()
10403 
 
10404 
  def write(self, oprot):
10405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10407 
      return
10408 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10409 
    if self.success is not None:
1382 varun.gupt 10410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10411 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10412 
      for iter175 in self.success:
10413 
        oprot.writeI64(iter175)
1382 varun.gupt 10414 
      oprot.writeListEnd()
10415 
      oprot.writeFieldEnd()
3431 rajveer 10416 
    if self.ex is not None:
1382 varun.gupt 10417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10418 
      self.ex.write(oprot)
10419 
      oprot.writeFieldEnd()
10420 
    oprot.writeFieldStop()
10421 
    oprot.writeStructEnd()
10422 
 
3431 rajveer 10423 
  def validate(self):
10424 
    return
10425 
 
10426 
 
1382 varun.gupt 10427 
  def __repr__(self):
10428 
    L = ['%s=%r' % (key, value)
10429 
      for key, value in self.__dict__.iteritems()]
10430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10431 
 
10432 
  def __eq__(self, other):
10433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10434 
 
10435 
  def __ne__(self, other):
10436 
    return not (self == other)
10437 
 
10438 
class getCancellableOrdersForCustomer_args:
10439 
  """
10440 
  Attributes:
10441 
   - customer_id
10442 
   - limit
10443 
  """
10444 
 
10445 
  thrift_spec = (
10446 
    None, # 0
10447 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10448 
    (2, TType.I64, 'limit', None, None, ), # 2
10449 
  )
10450 
 
10451 
  def __init__(self, customer_id=None, limit=None,):
10452 
    self.customer_id = customer_id
10453 
    self.limit = limit
10454 
 
10455 
  def read(self, iprot):
10456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10458 
      return
10459 
    iprot.readStructBegin()
10460 
    while True:
10461 
      (fname, ftype, fid) = iprot.readFieldBegin()
10462 
      if ftype == TType.STOP:
10463 
        break
10464 
      if fid == 1:
10465 
        if ftype == TType.I64:
10466 
          self.customer_id = iprot.readI64();
10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      elif fid == 2:
10470 
        if ftype == TType.I64:
10471 
          self.limit = iprot.readI64();
10472 
        else:
10473 
          iprot.skip(ftype)
10474 
      else:
10475 
        iprot.skip(ftype)
10476 
      iprot.readFieldEnd()
10477 
    iprot.readStructEnd()
10478 
 
10479 
  def write(self, oprot):
10480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10482 
      return
10483 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10484 
    if self.customer_id is not None:
1382 varun.gupt 10485 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10486 
      oprot.writeI64(self.customer_id)
10487 
      oprot.writeFieldEnd()
3431 rajveer 10488 
    if self.limit is not None:
1382 varun.gupt 10489 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10490 
      oprot.writeI64(self.limit)
10491 
      oprot.writeFieldEnd()
10492 
    oprot.writeFieldStop()
10493 
    oprot.writeStructEnd()
10494 
 
3431 rajveer 10495 
  def validate(self):
10496 
    return
10497 
 
10498 
 
1382 varun.gupt 10499 
  def __repr__(self):
10500 
    L = ['%s=%r' % (key, value)
10501 
      for key, value in self.__dict__.iteritems()]
10502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10503 
 
10504 
  def __eq__(self, other):
10505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10506 
 
10507 
  def __ne__(self, other):
10508 
    return not (self == other)
10509 
 
10510 
class getCancellableOrdersForCustomer_result:
10511 
  """
10512 
  Attributes:
10513 
   - success
10514 
   - ex
10515 
  """
10516 
 
10517 
  thrift_spec = (
10518 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10520 
  )
10521 
 
10522 
  def __init__(self, success=None, ex=None,):
10523 
    self.success = success
10524 
    self.ex = ex
10525 
 
10526 
  def read(self, iprot):
10527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10529 
      return
10530 
    iprot.readStructBegin()
10531 
    while True:
10532 
      (fname, ftype, fid) = iprot.readFieldBegin()
10533 
      if ftype == TType.STOP:
10534 
        break
10535 
      if fid == 0:
10536 
        if ftype == TType.LIST:
10537 
          self.success = []
6188 rajveer 10538 
          (_etype179, _size176) = iprot.readListBegin()
10539 
          for _i180 in xrange(_size176):
10540 
            _elem181 = iprot.readI64();
10541 
            self.success.append(_elem181)
1382 varun.gupt 10542 
          iprot.readListEnd()
10543 
        else:
10544 
          iprot.skip(ftype)
10545 
      elif fid == 1:
10546 
        if ftype == TType.STRUCT:
10547 
          self.ex = TransactionServiceException()
10548 
          self.ex.read(iprot)
10549 
        else:
10550 
          iprot.skip(ftype)
10551 
      else:
10552 
        iprot.skip(ftype)
10553 
      iprot.readFieldEnd()
10554 
    iprot.readStructEnd()
10555 
 
10556 
  def write(self, oprot):
10557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10559 
      return
10560 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10561 
    if self.success is not None:
1382 varun.gupt 10562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10563 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10564 
      for iter182 in self.success:
10565 
        oprot.writeI64(iter182)
1382 varun.gupt 10566 
      oprot.writeListEnd()
10567 
      oprot.writeFieldEnd()
3431 rajveer 10568 
    if self.ex is not None:
1382 varun.gupt 10569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10570 
      self.ex.write(oprot)
10571 
      oprot.writeFieldEnd()
10572 
    oprot.writeFieldStop()
10573 
    oprot.writeStructEnd()
10574 
 
3431 rajveer 10575 
  def validate(self):
10576 
    return
10577 
 
10578 
 
1382 varun.gupt 10579 
  def __repr__(self):
10580 
    L = ['%s=%r' % (key, value)
10581 
      for key, value in self.__dict__.iteritems()]
10582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10583 
 
10584 
  def __eq__(self, other):
10585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10586 
 
10587 
  def __ne__(self, other):
10588 
    return not (self == other)
10589 
 
483 rajveer 10590 
class changeOrderStatus_args:
94 ashish 10591 
  """
10592 
  Attributes:
483 rajveer 10593 
   - orderId
10594 
   - status
10595 
   - description
94 ashish 10596 
  """
10597 
 
10598 
  thrift_spec = (
10599 
    None, # 0
483 rajveer 10600 
    (1, TType.I64, 'orderId', None, None, ), # 1
10601 
    (2, TType.I32, 'status', None, None, ), # 2
10602 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10603 
  )
10604 
 
483 rajveer 10605 
  def __init__(self, orderId=None, status=None, description=None,):
10606 
    self.orderId = orderId
10607 
    self.status = status
10608 
    self.description = description
94 ashish 10609 
 
10610 
  def read(self, iprot):
10611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10613 
      return
10614 
    iprot.readStructBegin()
10615 
    while True:
10616 
      (fname, ftype, fid) = iprot.readFieldBegin()
10617 
      if ftype == TType.STOP:
10618 
        break
10619 
      if fid == 1:
10620 
        if ftype == TType.I64:
483 rajveer 10621 
          self.orderId = iprot.readI64();
94 ashish 10622 
        else:
10623 
          iprot.skip(ftype)
10624 
      elif fid == 2:
483 rajveer 10625 
        if ftype == TType.I32:
10626 
          self.status = iprot.readI32();
94 ashish 10627 
        else:
10628 
          iprot.skip(ftype)
483 rajveer 10629 
      elif fid == 3:
10630 
        if ftype == TType.STRING:
10631 
          self.description = iprot.readString();
10632 
        else:
10633 
          iprot.skip(ftype)
94 ashish 10634 
      else:
10635 
        iprot.skip(ftype)
10636 
      iprot.readFieldEnd()
10637 
    iprot.readStructEnd()
10638 
 
10639 
  def write(self, oprot):
10640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10642 
      return
483 rajveer 10643 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10644 
    if self.orderId is not None:
483 rajveer 10645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10646 
      oprot.writeI64(self.orderId)
94 ashish 10647 
      oprot.writeFieldEnd()
3431 rajveer 10648 
    if self.status is not None:
483 rajveer 10649 
      oprot.writeFieldBegin('status', TType.I32, 2)
10650 
      oprot.writeI32(self.status)
94 ashish 10651 
      oprot.writeFieldEnd()
3431 rajveer 10652 
    if self.description is not None:
483 rajveer 10653 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10654 
      oprot.writeString(self.description)
10655 
      oprot.writeFieldEnd()
94 ashish 10656 
    oprot.writeFieldStop()
10657 
    oprot.writeStructEnd()
10658 
 
3431 rajveer 10659 
  def validate(self):
10660 
    return
10661 
 
10662 
 
94 ashish 10663 
  def __repr__(self):
10664 
    L = ['%s=%r' % (key, value)
10665 
      for key, value in self.__dict__.iteritems()]
10666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10667 
 
10668 
  def __eq__(self, other):
10669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10670 
 
10671 
  def __ne__(self, other):
10672 
    return not (self == other)
10673 
 
483 rajveer 10674 
class changeOrderStatus_result:
94 ashish 10675 
  """
10676 
  Attributes:
10677 
   - success
10678 
   - ex
10679 
  """
10680 
 
10681 
  thrift_spec = (
10682 
    (0, TType.BOOL, 'success', None, None, ), # 0
10683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10684 
  )
10685 
 
10686 
  def __init__(self, success=None, ex=None,):
10687 
    self.success = success
10688 
    self.ex = ex
10689 
 
10690 
  def read(self, iprot):
10691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10693 
      return
10694 
    iprot.readStructBegin()
10695 
    while True:
10696 
      (fname, ftype, fid) = iprot.readFieldBegin()
10697 
      if ftype == TType.STOP:
10698 
        break
10699 
      if fid == 0:
10700 
        if ftype == TType.BOOL:
10701 
          self.success = iprot.readBool();
10702 
        else:
10703 
          iprot.skip(ftype)
10704 
      elif fid == 1:
10705 
        if ftype == TType.STRUCT:
10706 
          self.ex = TransactionServiceException()
10707 
          self.ex.read(iprot)
10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      else:
10711 
        iprot.skip(ftype)
10712 
      iprot.readFieldEnd()
10713 
    iprot.readStructEnd()
10714 
 
10715 
  def write(self, oprot):
10716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10718 
      return
483 rajveer 10719 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10720 
    if self.success is not None:
94 ashish 10721 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10722 
      oprot.writeBool(self.success)
10723 
      oprot.writeFieldEnd()
3431 rajveer 10724 
    if self.ex is not None:
94 ashish 10725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10726 
      self.ex.write(oprot)
10727 
      oprot.writeFieldEnd()
10728 
    oprot.writeFieldStop()
10729 
    oprot.writeStructEnd()
10730 
 
3431 rajveer 10731 
  def validate(self):
10732 
    return
10733 
 
10734 
 
94 ashish 10735 
  def __repr__(self):
10736 
    L = ['%s=%r' % (key, value)
10737 
      for key, value in self.__dict__.iteritems()]
10738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10739 
 
10740 
  def __eq__(self, other):
10741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10742 
 
10743 
  def __ne__(self, other):
10744 
    return not (self == other)
10745 
 
3064 chandransh 10746 
class getOrdersForTransaction_args:
494 rajveer 10747 
  """
10748 
  Attributes:
3064 chandransh 10749 
   - transactionId
10750 
   - customerId
494 rajveer 10751 
  """
10752 
 
10753 
  thrift_spec = (
10754 
    None, # 0
3064 chandransh 10755 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10756 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10757 
  )
10758 
 
3064 chandransh 10759 
  def __init__(self, transactionId=None, customerId=None,):
10760 
    self.transactionId = transactionId
10761 
    self.customerId = customerId
494 rajveer 10762 
 
10763 
  def read(self, iprot):
10764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10766 
      return
10767 
    iprot.readStructBegin()
10768 
    while True:
10769 
      (fname, ftype, fid) = iprot.readFieldBegin()
10770 
      if ftype == TType.STOP:
10771 
        break
10772 
      if fid == 1:
10773 
        if ftype == TType.I64:
3064 chandransh 10774 
          self.transactionId = iprot.readI64();
494 rajveer 10775 
        else:
10776 
          iprot.skip(ftype)
10777 
      elif fid == 2:
3064 chandransh 10778 
        if ftype == TType.I64:
10779 
          self.customerId = iprot.readI64();
494 rajveer 10780 
        else:
10781 
          iprot.skip(ftype)
10782 
      else:
10783 
        iprot.skip(ftype)
10784 
      iprot.readFieldEnd()
10785 
    iprot.readStructEnd()
10786 
 
10787 
  def write(self, oprot):
10788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10790 
      return
3064 chandransh 10791 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10792 
    if self.transactionId is not None:
3064 chandransh 10793 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10794 
      oprot.writeI64(self.transactionId)
494 rajveer 10795 
      oprot.writeFieldEnd()
3431 rajveer 10796 
    if self.customerId is not None:
3064 chandransh 10797 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10798 
      oprot.writeI64(self.customerId)
494 rajveer 10799 
      oprot.writeFieldEnd()
10800 
    oprot.writeFieldStop()
10801 
    oprot.writeStructEnd()
10802 
 
3431 rajveer 10803 
  def validate(self):
10804 
    return
10805 
 
10806 
 
494 rajveer 10807 
  def __repr__(self):
10808 
    L = ['%s=%r' % (key, value)
10809 
      for key, value in self.__dict__.iteritems()]
10810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10811 
 
10812 
  def __eq__(self, other):
10813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10814 
 
10815 
  def __ne__(self, other):
10816 
    return not (self == other)
10817 
 
3064 chandransh 10818 
class getOrdersForTransaction_result:
494 rajveer 10819 
  """
10820 
  Attributes:
10821 
   - success
10822 
   - ex
10823 
  """
10824 
 
10825 
  thrift_spec = (
3064 chandransh 10826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10828 
  )
10829 
 
10830 
  def __init__(self, success=None, ex=None,):
10831 
    self.success = success
10832 
    self.ex = ex
10833 
 
10834 
  def read(self, iprot):
10835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10837 
      return
10838 
    iprot.readStructBegin()
10839 
    while True:
10840 
      (fname, ftype, fid) = iprot.readFieldBegin()
10841 
      if ftype == TType.STOP:
10842 
        break
10843 
      if fid == 0:
3064 chandransh 10844 
        if ftype == TType.LIST:
10845 
          self.success = []
6188 rajveer 10846 
          (_etype186, _size183) = iprot.readListBegin()
10847 
          for _i187 in xrange(_size183):
10848 
            _elem188 = Order()
10849 
            _elem188.read(iprot)
10850 
            self.success.append(_elem188)
3064 chandransh 10851 
          iprot.readListEnd()
494 rajveer 10852 
        else:
10853 
          iprot.skip(ftype)
10854 
      elif fid == 1:
10855 
        if ftype == TType.STRUCT:
10856 
          self.ex = TransactionServiceException()
10857 
          self.ex.read(iprot)
10858 
        else:
10859 
          iprot.skip(ftype)
10860 
      else:
10861 
        iprot.skip(ftype)
10862 
      iprot.readFieldEnd()
10863 
    iprot.readStructEnd()
10864 
 
10865 
  def write(self, oprot):
10866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10868 
      return
3064 chandransh 10869 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10870 
    if self.success is not None:
3064 chandransh 10871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10873 
      for iter189 in self.success:
10874 
        iter189.write(oprot)
3064 chandransh 10875 
      oprot.writeListEnd()
494 rajveer 10876 
      oprot.writeFieldEnd()
3431 rajveer 10877 
    if self.ex is not None:
494 rajveer 10878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10879 
      self.ex.write(oprot)
10880 
      oprot.writeFieldEnd()
10881 
    oprot.writeFieldStop()
10882 
    oprot.writeStructEnd()
10883 
 
3431 rajveer 10884 
  def validate(self):
10885 
    return
10886 
 
10887 
 
494 rajveer 10888 
  def __repr__(self):
10889 
    L = ['%s=%r' % (key, value)
10890 
      for key, value in self.__dict__.iteritems()]
10891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10892 
 
10893 
  def __eq__(self, other):
10894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10895 
 
10896 
  def __ne__(self, other):
10897 
    return not (self == other)
10898 
 
3064 chandransh 10899 
class getOrdersForCustomer_args:
1149 chandransh 10900 
  """
10901 
  Attributes:
3064 chandransh 10902 
   - customerId
10903 
   - from_date
10904 
   - to_date
10905 
   - statuses
1149 chandransh 10906 
  """
10907 
 
10908 
  thrift_spec = (
10909 
    None, # 0
3064 chandransh 10910 
    (1, TType.I64, 'customerId', None, None, ), # 1
10911 
    (2, TType.I64, 'from_date', None, None, ), # 2
10912 
    (3, TType.I64, 'to_date', None, None, ), # 3
10913 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10914 
  )
10915 
 
3064 chandransh 10916 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10917 
    self.customerId = customerId
10918 
    self.from_date = from_date
10919 
    self.to_date = to_date
10920 
    self.statuses = statuses
1149 chandransh 10921 
 
10922 
  def read(self, iprot):
10923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10925 
      return
10926 
    iprot.readStructBegin()
10927 
    while True:
10928 
      (fname, ftype, fid) = iprot.readFieldBegin()
10929 
      if ftype == TType.STOP:
10930 
        break
10931 
      if fid == 1:
10932 
        if ftype == TType.I64:
3064 chandransh 10933 
          self.customerId = iprot.readI64();
1149 chandransh 10934 
        else:
10935 
          iprot.skip(ftype)
10936 
      elif fid == 2:
10937 
        if ftype == TType.I64:
3064 chandransh 10938 
          self.from_date = iprot.readI64();
1149 chandransh 10939 
        else:
10940 
          iprot.skip(ftype)
2783 chandransh 10941 
      elif fid == 3:
10942 
        if ftype == TType.I64:
3064 chandransh 10943 
          self.to_date = iprot.readI64();
2783 chandransh 10944 
        else:
10945 
          iprot.skip(ftype)
10946 
      elif fid == 4:
3064 chandransh 10947 
        if ftype == TType.LIST:
10948 
          self.statuses = []
6188 rajveer 10949 
          (_etype193, _size190) = iprot.readListBegin()
10950 
          for _i194 in xrange(_size190):
10951 
            _elem195 = iprot.readI32();
10952 
            self.statuses.append(_elem195)
3064 chandransh 10953 
          iprot.readListEnd()
2783 chandransh 10954 
        else:
10955 
          iprot.skip(ftype)
1149 chandransh 10956 
      else:
10957 
        iprot.skip(ftype)
10958 
      iprot.readFieldEnd()
10959 
    iprot.readStructEnd()
10960 
 
10961 
  def write(self, oprot):
10962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10964 
      return
3064 chandransh 10965 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10966 
    if self.customerId is not None:
3064 chandransh 10967 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10968 
      oprot.writeI64(self.customerId)
1149 chandransh 10969 
      oprot.writeFieldEnd()
3431 rajveer 10970 
    if self.from_date is not None:
3064 chandransh 10971 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10972 
      oprot.writeI64(self.from_date)
1149 chandransh 10973 
      oprot.writeFieldEnd()
3431 rajveer 10974 
    if self.to_date is not None:
3064 chandransh 10975 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10976 
      oprot.writeI64(self.to_date)
2783 chandransh 10977 
      oprot.writeFieldEnd()
3431 rajveer 10978 
    if self.statuses is not None:
3064 chandransh 10979 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10980 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10981 
      for iter196 in self.statuses:
10982 
        oprot.writeI32(iter196)
3064 chandransh 10983 
      oprot.writeListEnd()
2783 chandransh 10984 
      oprot.writeFieldEnd()
1149 chandransh 10985 
    oprot.writeFieldStop()
10986 
    oprot.writeStructEnd()
10987 
 
3431 rajveer 10988 
  def validate(self):
10989 
    return
10990 
 
10991 
 
1149 chandransh 10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
3064 chandransh 11003 
class getOrdersForCustomer_result:
1149 chandransh 11004 
  """
11005 
  Attributes:
11006 
   - success
11007 
   - ex
11008 
  """
11009 
 
11010 
  thrift_spec = (
3064 chandransh 11011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11013 
  )
11014 
 
11015 
  def __init__(self, success=None, ex=None,):
11016 
    self.success = success
11017 
    self.ex = ex
11018 
 
11019 
  def read(self, iprot):
11020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11022 
      return
11023 
    iprot.readStructBegin()
11024 
    while True:
11025 
      (fname, ftype, fid) = iprot.readFieldBegin()
11026 
      if ftype == TType.STOP:
11027 
        break
11028 
      if fid == 0:
3064 chandransh 11029 
        if ftype == TType.LIST:
11030 
          self.success = []
6188 rajveer 11031 
          (_etype200, _size197) = iprot.readListBegin()
11032 
          for _i201 in xrange(_size197):
11033 
            _elem202 = Order()
11034 
            _elem202.read(iprot)
11035 
            self.success.append(_elem202)
3064 chandransh 11036 
          iprot.readListEnd()
1149 chandransh 11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      elif fid == 1:
11040 
        if ftype == TType.STRUCT:
11041 
          self.ex = TransactionServiceException()
11042 
          self.ex.read(iprot)
11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      else:
11046 
        iprot.skip(ftype)
11047 
      iprot.readFieldEnd()
11048 
    iprot.readStructEnd()
11049 
 
11050 
  def write(self, oprot):
11051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11053 
      return
3064 chandransh 11054 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11055 
    if self.success is not None:
3064 chandransh 11056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11057 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11058 
      for iter203 in self.success:
11059 
        iter203.write(oprot)
3064 chandransh 11060 
      oprot.writeListEnd()
1149 chandransh 11061 
      oprot.writeFieldEnd()
3431 rajveer 11062 
    if self.ex is not None:
1149 chandransh 11063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11064 
      self.ex.write(oprot)
11065 
      oprot.writeFieldEnd()
11066 
    oprot.writeFieldStop()
11067 
    oprot.writeStructEnd()
11068 
 
3431 rajveer 11069 
  def validate(self):
11070 
    return
11071 
 
11072 
 
1149 chandransh 11073 
  def __repr__(self):
11074 
    L = ['%s=%r' % (key, value)
11075 
      for key, value in self.__dict__.iteritems()]
11076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11077 
 
11078 
  def __eq__(self, other):
11079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11080 
 
11081 
  def __ne__(self, other):
11082 
    return not (self == other)
11083 
 
3064 chandransh 11084 
class createOrder_args:
921 rajveer 11085 
  """
11086 
  Attributes:
3064 chandransh 11087 
   - order
921 rajveer 11088 
  """
11089 
 
11090 
  thrift_spec = (
11091 
    None, # 0
3064 chandransh 11092 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11093 
  )
11094 
 
3064 chandransh 11095 
  def __init__(self, order=None,):
11096 
    self.order = order
921 rajveer 11097 
 
11098 
  def read(self, iprot):
11099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11101 
      return
11102 
    iprot.readStructBegin()
11103 
    while True:
11104 
      (fname, ftype, fid) = iprot.readFieldBegin()
11105 
      if ftype == TType.STOP:
11106 
        break
11107 
      if fid == 1:
3064 chandransh 11108 
        if ftype == TType.STRUCT:
11109 
          self.order = Order()
11110 
          self.order.read(iprot)
921 rajveer 11111 
        else:
11112 
          iprot.skip(ftype)
11113 
      else:
11114 
        iprot.skip(ftype)
11115 
      iprot.readFieldEnd()
11116 
    iprot.readStructEnd()
11117 
 
11118 
  def write(self, oprot):
11119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11121 
      return
3064 chandransh 11122 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11123 
    if self.order is not None:
3064 chandransh 11124 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11125 
      self.order.write(oprot)
921 rajveer 11126 
      oprot.writeFieldEnd()
11127 
    oprot.writeFieldStop()
11128 
    oprot.writeStructEnd()
11129 
 
3431 rajveer 11130 
  def validate(self):
11131 
    return
11132 
 
11133 
 
921 rajveer 11134 
  def __repr__(self):
11135 
    L = ['%s=%r' % (key, value)
11136 
      for key, value in self.__dict__.iteritems()]
11137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11138 
 
11139 
  def __eq__(self, other):
11140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11141 
 
11142 
  def __ne__(self, other):
11143 
    return not (self == other)
11144 
 
3064 chandransh 11145 
class createOrder_result:
921 rajveer 11146 
  """
11147 
  Attributes:
11148 
   - success
11149 
   - ex
11150 
  """
11151 
 
11152 
  thrift_spec = (
3064 chandransh 11153 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11155 
  )
11156 
 
11157 
  def __init__(self, success=None, ex=None,):
11158 
    self.success = success
11159 
    self.ex = ex
11160 
 
11161 
  def read(self, iprot):
11162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11164 
      return
11165 
    iprot.readStructBegin()
11166 
    while True:
11167 
      (fname, ftype, fid) = iprot.readFieldBegin()
11168 
      if ftype == TType.STOP:
11169 
        break
11170 
      if fid == 0:
3064 chandransh 11171 
        if ftype == TType.I64:
11172 
          self.success = iprot.readI64();
921 rajveer 11173 
        else:
11174 
          iprot.skip(ftype)
11175 
      elif fid == 1:
11176 
        if ftype == TType.STRUCT:
11177 
          self.ex = TransactionServiceException()
11178 
          self.ex.read(iprot)
11179 
        else:
11180 
          iprot.skip(ftype)
11181 
      else:
11182 
        iprot.skip(ftype)
11183 
      iprot.readFieldEnd()
11184 
    iprot.readStructEnd()
11185 
 
11186 
  def write(self, oprot):
11187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11189 
      return
3064 chandransh 11190 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11191 
    if self.success is not None:
3064 chandransh 11192 
      oprot.writeFieldBegin('success', TType.I64, 0)
11193 
      oprot.writeI64(self.success)
921 rajveer 11194 
      oprot.writeFieldEnd()
3431 rajveer 11195 
    if self.ex is not None:
921 rajveer 11196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11197 
      self.ex.write(oprot)
11198 
      oprot.writeFieldEnd()
11199 
    oprot.writeFieldStop()
11200 
    oprot.writeStructEnd()
11201 
 
3431 rajveer 11202 
  def validate(self):
11203 
    return
11204 
 
11205 
 
921 rajveer 11206 
  def __repr__(self):
11207 
    L = ['%s=%r' % (key, value)
11208 
      for key, value in self.__dict__.iteritems()]
11209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11210 
 
11211 
  def __eq__(self, other):
11212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11213 
 
11214 
  def __ne__(self, other):
11215 
    return not (self == other)
11216 
 
3064 chandransh 11217 
class getOrder_args:
921 rajveer 11218 
  """
11219 
  Attributes:
3064 chandransh 11220 
   - id
921 rajveer 11221 
  """
11222 
 
11223 
  thrift_spec = (
11224 
    None, # 0
3064 chandransh 11225 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11226 
  )
11227 
 
3064 chandransh 11228 
  def __init__(self, id=None,):
11229 
    self.id = id
921 rajveer 11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 1:
11241 
        if ftype == TType.I64:
3064 chandransh 11242 
          self.id = iprot.readI64();
921 rajveer 11243 
        else:
11244 
          iprot.skip(ftype)
11245 
      else:
11246 
        iprot.skip(ftype)
11247 
      iprot.readFieldEnd()
11248 
    iprot.readStructEnd()
11249 
 
11250 
  def write(self, oprot):
11251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11253 
      return
3064 chandransh 11254 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11255 
    if self.id is not None:
3064 chandransh 11256 
      oprot.writeFieldBegin('id', TType.I64, 1)
11257 
      oprot.writeI64(self.id)
921 rajveer 11258 
      oprot.writeFieldEnd()
11259 
    oprot.writeFieldStop()
11260 
    oprot.writeStructEnd()
11261 
 
3431 rajveer 11262 
  def validate(self):
11263 
    return
11264 
 
11265 
 
921 rajveer 11266 
  def __repr__(self):
11267 
    L = ['%s=%r' % (key, value)
11268 
      for key, value in self.__dict__.iteritems()]
11269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11270 
 
11271 
  def __eq__(self, other):
11272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11273 
 
11274 
  def __ne__(self, other):
11275 
    return not (self == other)
11276 
 
3064 chandransh 11277 
class getOrder_result:
921 rajveer 11278 
  """
11279 
  Attributes:
11280 
   - success
11281 
   - ex
11282 
  """
11283 
 
11284 
  thrift_spec = (
3064 chandransh 11285 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11287 
  )
11288 
 
11289 
  def __init__(self, success=None, ex=None,):
11290 
    self.success = success
11291 
    self.ex = ex
11292 
 
11293 
  def read(self, iprot):
11294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11296 
      return
11297 
    iprot.readStructBegin()
11298 
    while True:
11299 
      (fname, ftype, fid) = iprot.readFieldBegin()
11300 
      if ftype == TType.STOP:
11301 
        break
11302 
      if fid == 0:
3064 chandransh 11303 
        if ftype == TType.STRUCT:
11304 
          self.success = Order()
11305 
          self.success.read(iprot)
921 rajveer 11306 
        else:
11307 
          iprot.skip(ftype)
11308 
      elif fid == 1:
11309 
        if ftype == TType.STRUCT:
11310 
          self.ex = TransactionServiceException()
11311 
          self.ex.read(iprot)
11312 
        else:
11313 
          iprot.skip(ftype)
11314 
      else:
11315 
        iprot.skip(ftype)
11316 
      iprot.readFieldEnd()
11317 
    iprot.readStructEnd()
11318 
 
11319 
  def write(self, oprot):
11320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11322 
      return
3064 chandransh 11323 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11324 
    if self.success is not None:
3064 chandransh 11325 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11326 
      self.success.write(oprot)
921 rajveer 11327 
      oprot.writeFieldEnd()
3431 rajveer 11328 
    if self.ex is not None:
921 rajveer 11329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11330 
      self.ex.write(oprot)
11331 
      oprot.writeFieldEnd()
11332 
    oprot.writeFieldStop()
11333 
    oprot.writeStructEnd()
11334 
 
3431 rajveer 11335 
  def validate(self):
11336 
    return
11337 
 
11338 
 
921 rajveer 11339 
  def __repr__(self):
11340 
    L = ['%s=%r' % (key, value)
11341 
      for key, value in self.__dict__.iteritems()]
11342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11343 
 
11344 
  def __eq__(self, other):
11345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11346 
 
11347 
  def __ne__(self, other):
11348 
    return not (self == other)
11349 
 
3064 chandransh 11350 
class getLineItemsForOrder_args:
94 ashish 11351 
  """
11352 
  Attributes:
3064 chandransh 11353 
   - orderId
94 ashish 11354 
  """
11355 
 
11356 
  thrift_spec = (
11357 
    None, # 0
3064 chandransh 11358 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11359 
  )
11360 
 
3064 chandransh 11361 
  def __init__(self, orderId=None,):
11362 
    self.orderId = orderId
94 ashish 11363 
 
11364 
  def read(self, iprot):
11365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11367 
      return
11368 
    iprot.readStructBegin()
11369 
    while True:
11370 
      (fname, ftype, fid) = iprot.readFieldBegin()
11371 
      if ftype == TType.STOP:
11372 
        break
11373 
      if fid == 1:
11374 
        if ftype == TType.I64:
3064 chandransh 11375 
          self.orderId = iprot.readI64();
94 ashish 11376 
        else:
11377 
          iprot.skip(ftype)
11378 
      else:
11379 
        iprot.skip(ftype)
11380 
      iprot.readFieldEnd()
11381 
    iprot.readStructEnd()
11382 
 
11383 
  def write(self, oprot):
11384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11386 
      return
3064 chandransh 11387 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11388 
    if self.orderId is not None:
3064 chandransh 11389 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11390 
      oprot.writeI64(self.orderId)
94 ashish 11391 
      oprot.writeFieldEnd()
11392 
    oprot.writeFieldStop()
11393 
    oprot.writeStructEnd()
11394 
 
3431 rajveer 11395 
  def validate(self):
11396 
    return
11397 
 
11398 
 
94 ashish 11399 
  def __repr__(self):
11400 
    L = ['%s=%r' % (key, value)
11401 
      for key, value in self.__dict__.iteritems()]
11402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11403 
 
11404 
  def __eq__(self, other):
11405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11406 
 
11407 
  def __ne__(self, other):
11408 
    return not (self == other)
11409 
 
3064 chandransh 11410 
class getLineItemsForOrder_result:
94 ashish 11411 
  """
11412 
  Attributes:
11413 
   - success
11414 
   - ex
11415 
  """
11416 
 
11417 
  thrift_spec = (
3064 chandransh 11418 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11420 
  )
11421 
 
11422 
  def __init__(self, success=None, ex=None,):
11423 
    self.success = success
11424 
    self.ex = ex
11425 
 
11426 
  def read(self, iprot):
11427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11429 
      return
11430 
    iprot.readStructBegin()
11431 
    while True:
11432 
      (fname, ftype, fid) = iprot.readFieldBegin()
11433 
      if ftype == TType.STOP:
11434 
        break
11435 
      if fid == 0:
483 rajveer 11436 
        if ftype == TType.LIST:
11437 
          self.success = []
6188 rajveer 11438 
          (_etype207, _size204) = iprot.readListBegin()
11439 
          for _i208 in xrange(_size204):
11440 
            _elem209 = LineItem()
11441 
            _elem209.read(iprot)
11442 
            self.success.append(_elem209)
483 rajveer 11443 
          iprot.readListEnd()
94 ashish 11444 
        else:
11445 
          iprot.skip(ftype)
11446 
      elif fid == 1:
11447 
        if ftype == TType.STRUCT:
11448 
          self.ex = TransactionServiceException()
11449 
          self.ex.read(iprot)
11450 
        else:
11451 
          iprot.skip(ftype)
11452 
      else:
11453 
        iprot.skip(ftype)
11454 
      iprot.readFieldEnd()
11455 
    iprot.readStructEnd()
11456 
 
11457 
  def write(self, oprot):
11458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11460 
      return
3064 chandransh 11461 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11462 
    if self.success is not None:
483 rajveer 11463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11465 
      for iter210 in self.success:
11466 
        iter210.write(oprot)
483 rajveer 11467 
      oprot.writeListEnd()
94 ashish 11468 
      oprot.writeFieldEnd()
3431 rajveer 11469 
    if self.ex is not None:
94 ashish 11470 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11471 
      self.ex.write(oprot)
11472 
      oprot.writeFieldEnd()
11473 
    oprot.writeFieldStop()
11474 
    oprot.writeStructEnd()
11475 
 
3431 rajveer 11476 
  def validate(self):
11477 
    return
11478 
 
11479 
 
94 ashish 11480 
  def __repr__(self):
11481 
    L = ['%s=%r' % (key, value)
11482 
      for key, value in self.__dict__.iteritems()]
11483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11484 
 
11485 
  def __eq__(self, other):
11486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11487 
 
11488 
  def __ne__(self, other):
11489 
    return not (self == other)
11490 
 
4999 phani.kuma 11491 
class getOrderList_args:
11492 
  """
11493 
  Attributes:
11494 
   - order_ids
11495 
  """
11496 
 
11497 
  thrift_spec = (
11498 
    None, # 0
11499 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11500 
  )
11501 
 
11502 
  def __init__(self, order_ids=None,):
11503 
    self.order_ids = order_ids
11504 
 
11505 
  def read(self, iprot):
11506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11508 
      return
11509 
    iprot.readStructBegin()
11510 
    while True:
11511 
      (fname, ftype, fid) = iprot.readFieldBegin()
11512 
      if ftype == TType.STOP:
11513 
        break
11514 
      if fid == 1:
11515 
        if ftype == TType.LIST:
11516 
          self.order_ids = []
6188 rajveer 11517 
          (_etype214, _size211) = iprot.readListBegin()
11518 
          for _i215 in xrange(_size211):
11519 
            _elem216 = iprot.readI64();
11520 
            self.order_ids.append(_elem216)
4999 phani.kuma 11521 
          iprot.readListEnd()
11522 
        else:
11523 
          iprot.skip(ftype)
11524 
      else:
11525 
        iprot.skip(ftype)
11526 
      iprot.readFieldEnd()
11527 
    iprot.readStructEnd()
11528 
 
11529 
  def write(self, oprot):
11530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11532 
      return
11533 
    oprot.writeStructBegin('getOrderList_args')
11534 
    if self.order_ids is not None:
11535 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11536 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11537 
      for iter217 in self.order_ids:
11538 
        oprot.writeI64(iter217)
4999 phani.kuma 11539 
      oprot.writeListEnd()
11540 
      oprot.writeFieldEnd()
11541 
    oprot.writeFieldStop()
11542 
    oprot.writeStructEnd()
11543 
 
11544 
  def validate(self):
11545 
    return
11546 
 
11547 
 
11548 
  def __repr__(self):
11549 
    L = ['%s=%r' % (key, value)
11550 
      for key, value in self.__dict__.iteritems()]
11551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11552 
 
11553 
  def __eq__(self, other):
11554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11555 
 
11556 
  def __ne__(self, other):
11557 
    return not (self == other)
11558 
 
11559 
class getOrderList_result:
11560 
  """
11561 
  Attributes:
11562 
   - success
11563 
  """
11564 
 
11565 
  thrift_spec = (
11566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11567 
  )
11568 
 
11569 
  def __init__(self, success=None,):
11570 
    self.success = success
11571 
 
11572 
  def read(self, iprot):
11573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11575 
      return
11576 
    iprot.readStructBegin()
11577 
    while True:
11578 
      (fname, ftype, fid) = iprot.readFieldBegin()
11579 
      if ftype == TType.STOP:
11580 
        break
11581 
      if fid == 0:
11582 
        if ftype == TType.LIST:
11583 
          self.success = []
6188 rajveer 11584 
          (_etype221, _size218) = iprot.readListBegin()
11585 
          for _i222 in xrange(_size218):
11586 
            _elem223 = Order()
11587 
            _elem223.read(iprot)
11588 
            self.success.append(_elem223)
4999 phani.kuma 11589 
          iprot.readListEnd()
11590 
        else:
11591 
          iprot.skip(ftype)
11592 
      else:
11593 
        iprot.skip(ftype)
11594 
      iprot.readFieldEnd()
11595 
    iprot.readStructEnd()
11596 
 
11597 
  def write(self, oprot):
11598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11600 
      return
11601 
    oprot.writeStructBegin('getOrderList_result')
11602 
    if self.success is not None:
11603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11605 
      for iter224 in self.success:
11606 
        iter224.write(oprot)
4999 phani.kuma 11607 
      oprot.writeListEnd()
11608 
      oprot.writeFieldEnd()
11609 
    oprot.writeFieldStop()
11610 
    oprot.writeStructEnd()
11611 
 
11612 
  def validate(self):
11613 
    return
11614 
 
11615 
 
11616 
  def __repr__(self):
11617 
    L = ['%s=%r' % (key, value)
11618 
      for key, value in self.__dict__.iteritems()]
11619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11620 
 
11621 
  def __eq__(self, other):
11622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11623 
 
11624 
  def __ne__(self, other):
11625 
    return not (self == other)
11626 
 
5386 phani.kuma 11627 
class getOrderListForVendor_args:
11628 
  """
11629 
  Attributes:
11630 
   - order_ids
11631 
   - vendorId
11632 
  """
11633 
 
11634 
  thrift_spec = (
11635 
    None, # 0
11636 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11637 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11638 
  )
11639 
 
11640 
  def __init__(self, order_ids=None, vendorId=None,):
11641 
    self.order_ids = order_ids
11642 
    self.vendorId = vendorId
11643 
 
11644 
  def read(self, iprot):
11645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11647 
      return
11648 
    iprot.readStructBegin()
11649 
    while True:
11650 
      (fname, ftype, fid) = iprot.readFieldBegin()
11651 
      if ftype == TType.STOP:
11652 
        break
11653 
      if fid == 1:
11654 
        if ftype == TType.LIST:
11655 
          self.order_ids = []
6188 rajveer 11656 
          (_etype228, _size225) = iprot.readListBegin()
11657 
          for _i229 in xrange(_size225):
11658 
            _elem230 = iprot.readI64();
11659 
            self.order_ids.append(_elem230)
5386 phani.kuma 11660 
          iprot.readListEnd()
11661 
        else:
11662 
          iprot.skip(ftype)
11663 
      elif fid == 2:
11664 
        if ftype == TType.I64:
11665 
          self.vendorId = iprot.readI64();
11666 
        else:
11667 
          iprot.skip(ftype)
11668 
      else:
11669 
        iprot.skip(ftype)
11670 
      iprot.readFieldEnd()
11671 
    iprot.readStructEnd()
11672 
 
11673 
  def write(self, oprot):
11674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11676 
      return
11677 
    oprot.writeStructBegin('getOrderListForVendor_args')
11678 
    if self.order_ids is not None:
11679 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11680 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11681 
      for iter231 in self.order_ids:
11682 
        oprot.writeI64(iter231)
5386 phani.kuma 11683 
      oprot.writeListEnd()
11684 
      oprot.writeFieldEnd()
11685 
    if self.vendorId is not None:
11686 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11687 
      oprot.writeI64(self.vendorId)
11688 
      oprot.writeFieldEnd()
11689 
    oprot.writeFieldStop()
11690 
    oprot.writeStructEnd()
11691 
 
11692 
  def validate(self):
11693 
    return
11694 
 
11695 
 
11696 
  def __repr__(self):
11697 
    L = ['%s=%r' % (key, value)
11698 
      for key, value in self.__dict__.iteritems()]
11699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11700 
 
11701 
  def __eq__(self, other):
11702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11703 
 
11704 
  def __ne__(self, other):
11705 
    return not (self == other)
11706 
 
11707 
class getOrderListForVendor_result:
11708 
  """
11709 
  Attributes:
11710 
   - success
11711 
  """
11712 
 
11713 
  thrift_spec = (
11714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11715 
  )
11716 
 
11717 
  def __init__(self, success=None,):
11718 
    self.success = success
11719 
 
11720 
  def read(self, iprot):
11721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11723 
      return
11724 
    iprot.readStructBegin()
11725 
    while True:
11726 
      (fname, ftype, fid) = iprot.readFieldBegin()
11727 
      if ftype == TType.STOP:
11728 
        break
11729 
      if fid == 0:
11730 
        if ftype == TType.LIST:
11731 
          self.success = []
6188 rajveer 11732 
          (_etype235, _size232) = iprot.readListBegin()
11733 
          for _i236 in xrange(_size232):
11734 
            _elem237 = Order()
11735 
            _elem237.read(iprot)
11736 
            self.success.append(_elem237)
5386 phani.kuma 11737 
          iprot.readListEnd()
11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
11749 
    oprot.writeStructBegin('getOrderListForVendor_result')
11750 
    if self.success is not None:
11751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11753 
      for iter238 in self.success:
11754 
        iter238.write(oprot)
5386 phani.kuma 11755 
      oprot.writeListEnd()
11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
3064 chandransh 11775 
class getOrderForCustomer_args:
94 ashish 11776 
  """
11777 
  Attributes:
3064 chandransh 11778 
   - orderId
483 rajveer 11779 
   - customerId
94 ashish 11780 
  """
11781 
 
11782 
  thrift_spec = (
11783 
    None, # 0
3064 chandransh 11784 
    (1, TType.I64, 'orderId', None, None, ), # 1
11785 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11786 
  )
11787 
 
3064 chandransh 11788 
  def __init__(self, orderId=None, customerId=None,):
11789 
    self.orderId = orderId
483 rajveer 11790 
    self.customerId = customerId
94 ashish 11791 
 
11792 
  def read(self, iprot):
11793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11795 
      return
11796 
    iprot.readStructBegin()
11797 
    while True:
11798 
      (fname, ftype, fid) = iprot.readFieldBegin()
11799 
      if ftype == TType.STOP:
11800 
        break
11801 
      if fid == 1:
11802 
        if ftype == TType.I64:
3064 chandransh 11803 
          self.orderId = iprot.readI64();
94 ashish 11804 
        else:
11805 
          iprot.skip(ftype)
11806 
      elif fid == 2:
11807 
        if ftype == TType.I64:
3064 chandransh 11808 
          self.customerId = iprot.readI64();
94 ashish 11809 
        else:
11810 
          iprot.skip(ftype)
11811 
      else:
11812 
        iprot.skip(ftype)
11813 
      iprot.readFieldEnd()
11814 
    iprot.readStructEnd()
11815 
 
11816 
  def write(self, oprot):
11817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11819 
      return
3064 chandransh 11820 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11821 
    if self.orderId is not None:
3064 chandransh 11822 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11823 
      oprot.writeI64(self.orderId)
11824 
      oprot.writeFieldEnd()
3431 rajveer 11825 
    if self.customerId is not None:
3064 chandransh 11826 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11827 
      oprot.writeI64(self.customerId)
94 ashish 11828 
      oprot.writeFieldEnd()
11829 
    oprot.writeFieldStop()
11830 
    oprot.writeStructEnd()
11831 
 
3431 rajveer 11832 
  def validate(self):
11833 
    return
11834 
 
11835 
 
94 ashish 11836 
  def __repr__(self):
11837 
    L = ['%s=%r' % (key, value)
11838 
      for key, value in self.__dict__.iteritems()]
11839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11840 
 
11841 
  def __eq__(self, other):
11842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11843 
 
11844 
  def __ne__(self, other):
11845 
    return not (self == other)
11846 
 
3064 chandransh 11847 
class getOrderForCustomer_result:
94 ashish 11848 
  """
11849 
  Attributes:
11850 
   - success
11851 
   - ex
11852 
  """
11853 
 
11854 
  thrift_spec = (
3064 chandransh 11855 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11857 
  )
11858 
 
11859 
  def __init__(self, success=None, ex=None,):
11860 
    self.success = success
11861 
    self.ex = ex
11862 
 
11863 
  def read(self, iprot):
11864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11866 
      return
11867 
    iprot.readStructBegin()
11868 
    while True:
11869 
      (fname, ftype, fid) = iprot.readFieldBegin()
11870 
      if ftype == TType.STOP:
11871 
        break
11872 
      if fid == 0:
3064 chandransh 11873 
        if ftype == TType.STRUCT:
11874 
          self.success = Order()
11875 
          self.success.read(iprot)
94 ashish 11876 
        else:
11877 
          iprot.skip(ftype)
11878 
      elif fid == 1:
11879 
        if ftype == TType.STRUCT:
11880 
          self.ex = TransactionServiceException()
11881 
          self.ex.read(iprot)
11882 
        else:
11883 
          iprot.skip(ftype)
11884 
      else:
11885 
        iprot.skip(ftype)
11886 
      iprot.readFieldEnd()
11887 
    iprot.readStructEnd()
11888 
 
11889 
  def write(self, oprot):
11890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11892 
      return
3064 chandransh 11893 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11894 
    if self.success is not None:
3064 chandransh 11895 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11896 
      self.success.write(oprot)
94 ashish 11897 
      oprot.writeFieldEnd()
3431 rajveer 11898 
    if self.ex is not None:
94 ashish 11899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11900 
      self.ex.write(oprot)
11901 
      oprot.writeFieldEnd()
11902 
    oprot.writeFieldStop()
11903 
    oprot.writeStructEnd()
11904 
 
3431 rajveer 11905 
  def validate(self):
11906 
    return
11907 
 
11908 
 
94 ashish 11909 
  def __repr__(self):
11910 
    L = ['%s=%r' % (key, value)
11911 
      for key, value in self.__dict__.iteritems()]
11912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11913 
 
11914 
  def __eq__(self, other):
11915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11916 
 
11917 
  def __ne__(self, other):
11918 
    return not (self == other)
11919 
 
3064 chandransh 11920 
class getAlerts_args:
94 ashish 11921 
  """
11922 
  Attributes:
4394 rajveer 11923 
   - type
4444 rajveer 11924 
   - warehouseId
4394 rajveer 11925 
   - status
11926 
   - timestamp
94 ashish 11927 
  """
11928 
 
11929 
  thrift_spec = (
11930 
    None, # 0
4394 rajveer 11931 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11932 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11933 
    (3, TType.I64, 'status', None, None, ), # 3
11934 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11935 
  )
11936 
 
4444 rajveer 11937 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11938 
    self.type = type
4444 rajveer 11939 
    self.warehouseId = warehouseId
4394 rajveer 11940 
    self.status = status
11941 
    self.timestamp = timestamp
94 ashish 11942 
 
11943 
  def read(self, iprot):
11944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11946 
      return
11947 
    iprot.readStructBegin()
11948 
    while True:
11949 
      (fname, ftype, fid) = iprot.readFieldBegin()
11950 
      if ftype == TType.STOP:
11951 
        break
11952 
      if fid == 1:
3064 chandransh 11953 
        if ftype == TType.I64:
4394 rajveer 11954 
          self.type = iprot.readI64();
94 ashish 11955 
        else:
11956 
          iprot.skip(ftype)
3064 chandransh 11957 
      elif fid == 2:
4394 rajveer 11958 
        if ftype == TType.I64:
4444 rajveer 11959 
          self.warehouseId = iprot.readI64();
3064 chandransh 11960 
        else:
11961 
          iprot.skip(ftype)
4394 rajveer 11962 
      elif fid == 3:
11963 
        if ftype == TType.I64:
4444 rajveer 11964 
          self.status = iprot.readI64();
11965 
        else:
11966 
          iprot.skip(ftype)
11967 
      elif fid == 4:
11968 
        if ftype == TType.I64:
4394 rajveer 11969 
          self.timestamp = iprot.readI64();
11970 
        else:
11971 
          iprot.skip(ftype)
94 ashish 11972 
      else:
11973 
        iprot.skip(ftype)
11974 
      iprot.readFieldEnd()
11975 
    iprot.readStructEnd()
11976 
 
11977 
  def write(self, oprot):
11978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11980 
      return
3064 chandransh 11981 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11982 
    if self.type is not None:
11983 
      oprot.writeFieldBegin('type', TType.I64, 1)
11984 
      oprot.writeI64(self.type)
94 ashish 11985 
      oprot.writeFieldEnd()
4444 rajveer 11986 
    if self.warehouseId is not None:
11987 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11988 
      oprot.writeI64(self.warehouseId)
11989 
      oprot.writeFieldEnd()
4394 rajveer 11990 
    if self.status is not None:
4444 rajveer 11991 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11992 
      oprot.writeI64(self.status)
3064 chandransh 11993 
      oprot.writeFieldEnd()
4394 rajveer 11994 
    if self.timestamp is not None:
4444 rajveer 11995 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11996 
      oprot.writeI64(self.timestamp)
11997 
      oprot.writeFieldEnd()
94 ashish 11998 
    oprot.writeFieldStop()
11999 
    oprot.writeStructEnd()
12000 
 
3431 rajveer 12001 
  def validate(self):
12002 
    return
12003 
 
12004 
 
94 ashish 12005 
  def __repr__(self):
12006 
    L = ['%s=%r' % (key, value)
12007 
      for key, value in self.__dict__.iteritems()]
12008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12009 
 
12010 
  def __eq__(self, other):
12011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12012 
 
12013 
  def __ne__(self, other):
12014 
    return not (self == other)
12015 
 
3064 chandransh 12016 
class getAlerts_result:
94 ashish 12017 
  """
12018 
  Attributes:
12019 
   - success
12020 
  """
12021 
 
12022 
  thrift_spec = (
3064 chandransh 12023 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12024 
  )
12025 
 
3064 chandransh 12026 
  def __init__(self, success=None,):
94 ashish 12027 
    self.success = success
12028 
 
12029 
  def read(self, iprot):
12030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12032 
      return
12033 
    iprot.readStructBegin()
12034 
    while True:
12035 
      (fname, ftype, fid) = iprot.readFieldBegin()
12036 
      if ftype == TType.STOP:
12037 
        break
12038 
      if fid == 0:
3064 chandransh 12039 
        if ftype == TType.LIST:
12040 
          self.success = []
6188 rajveer 12041 
          (_etype242, _size239) = iprot.readListBegin()
12042 
          for _i243 in xrange(_size239):
12043 
            _elem244 = Alert()
12044 
            _elem244.read(iprot)
12045 
            self.success.append(_elem244)
3064 chandransh 12046 
          iprot.readListEnd()
94 ashish 12047 
        else:
12048 
          iprot.skip(ftype)
12049 
      else:
12050 
        iprot.skip(ftype)
12051 
      iprot.readFieldEnd()
12052 
    iprot.readStructEnd()
12053 
 
12054 
  def write(self, oprot):
12055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12057 
      return
3064 chandransh 12058 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12059 
    if self.success is not None:
3064 chandransh 12060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12062 
      for iter245 in self.success:
12063 
        iter245.write(oprot)
3064 chandransh 12064 
      oprot.writeListEnd()
94 ashish 12065 
      oprot.writeFieldEnd()
12066 
    oprot.writeFieldStop()
12067 
    oprot.writeStructEnd()
12068 
 
3431 rajveer 12069 
  def validate(self):
12070 
    return
12071 
 
12072 
 
94 ashish 12073 
  def __repr__(self):
12074 
    L = ['%s=%r' % (key, value)
12075 
      for key, value in self.__dict__.iteritems()]
12076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12077 
 
12078 
  def __eq__(self, other):
12079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12080 
 
12081 
  def __ne__(self, other):
12082 
    return not (self == other)
12083 
 
4394 rajveer 12084 
class addAlert_args:
94 ashish 12085 
  """
12086 
  Attributes:
3064 chandransh 12087 
   - type
4444 rajveer 12088 
   - warehouseId
4394 rajveer 12089 
   - description
94 ashish 12090 
  """
12091 
 
12092 
  thrift_spec = (
12093 
    None, # 0
4394 rajveer 12094 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12095 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12096 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12097 
  )
12098 
 
4444 rajveer 12099 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12100 
    self.type = type
4444 rajveer 12101 
    self.warehouseId = warehouseId
4394 rajveer 12102 
    self.description = description
94 ashish 12103 
 
12104 
  def read(self, iprot):
12105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12107 
      return
12108 
    iprot.readStructBegin()
12109 
    while True:
12110 
      (fname, ftype, fid) = iprot.readFieldBegin()
12111 
      if ftype == TType.STOP:
12112 
        break
12113 
      if fid == 1:
12114 
        if ftype == TType.I64:
4394 rajveer 12115 
          self.type = iprot.readI64();
94 ashish 12116 
        else:
12117 
          iprot.skip(ftype)
3064 chandransh 12118 
      elif fid == 2:
4444 rajveer 12119 
        if ftype == TType.I64:
12120 
          self.warehouseId = iprot.readI64();
12121 
        else:
12122 
          iprot.skip(ftype)
12123 
      elif fid == 3:
3064 chandransh 12124 
        if ftype == TType.STRING:
4394 rajveer 12125 
          self.description = iprot.readString();
3064 chandransh 12126 
        else:
12127 
          iprot.skip(ftype)
94 ashish 12128 
      else:
12129 
        iprot.skip(ftype)
12130 
      iprot.readFieldEnd()
12131 
    iprot.readStructEnd()
12132 
 
12133 
  def write(self, oprot):
12134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12136 
      return
4394 rajveer 12137 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12138 
    if self.type is not None:
4394 rajveer 12139 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12140 
      oprot.writeI64(self.type)
12141 
      oprot.writeFieldEnd()
4444 rajveer 12142 
    if self.warehouseId is not None:
12143 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12144 
      oprot.writeI64(self.warehouseId)
12145 
      oprot.writeFieldEnd()
4394 rajveer 12146 
    if self.description is not None:
4444 rajveer 12147 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12148 
      oprot.writeString(self.description)
3064 chandransh 12149 
      oprot.writeFieldEnd()
94 ashish 12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
3431 rajveer 12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
94 ashish 12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
4394 rajveer 12168 
class addAlert_result:
3064 chandransh 12169 
 
12170 
  thrift_spec = (
12171 
  )
12172 
 
12173 
  def read(self, iprot):
12174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12176 
      return
12177 
    iprot.readStructBegin()
12178 
    while True:
12179 
      (fname, ftype, fid) = iprot.readFieldBegin()
12180 
      if ftype == TType.STOP:
12181 
        break
12182 
      else:
12183 
        iprot.skip(ftype)
12184 
      iprot.readFieldEnd()
12185 
    iprot.readStructEnd()
12186 
 
12187 
  def write(self, oprot):
12188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12190 
      return
4394 rajveer 12191 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12192 
    oprot.writeFieldStop()
12193 
    oprot.writeStructEnd()
12194 
 
3431 rajveer 12195 
  def validate(self):
12196 
    return
12197 
 
12198 
 
3064 chandransh 12199 
  def __repr__(self):
12200 
    L = ['%s=%r' % (key, value)
12201 
      for key, value in self.__dict__.iteritems()]
12202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12203 
 
12204 
  def __eq__(self, other):
12205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12206 
 
12207 
  def __ne__(self, other):
12208 
    return not (self == other)
12209 
 
4444 rajveer 12210 
class markAlertsAsSeen_args:
12211 
  """
12212 
  Attributes:
12213 
   - warehouseId
12214 
  """
12215 
 
12216 
  thrift_spec = (
12217 
    None, # 0
12218 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12219 
  )
12220 
 
12221 
  def __init__(self, warehouseId=None,):
12222 
    self.warehouseId = warehouseId
12223 
 
12224 
  def read(self, iprot):
12225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12227 
      return
12228 
    iprot.readStructBegin()
12229 
    while True:
12230 
      (fname, ftype, fid) = iprot.readFieldBegin()
12231 
      if ftype == TType.STOP:
12232 
        break
12233 
      if fid == 1:
12234 
        if ftype == TType.I64:
12235 
          self.warehouseId = iprot.readI64();
12236 
        else:
12237 
          iprot.skip(ftype)
12238 
      else:
12239 
        iprot.skip(ftype)
12240 
      iprot.readFieldEnd()
12241 
    iprot.readStructEnd()
12242 
 
12243 
  def write(self, oprot):
12244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12246 
      return
12247 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12248 
    if self.warehouseId is not None:
12249 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12250 
      oprot.writeI64(self.warehouseId)
12251 
      oprot.writeFieldEnd()
12252 
    oprot.writeFieldStop()
12253 
    oprot.writeStructEnd()
12254 
 
12255 
  def validate(self):
12256 
    return
12257 
 
12258 
 
12259 
  def __repr__(self):
12260 
    L = ['%s=%r' % (key, value)
12261 
      for key, value in self.__dict__.iteritems()]
12262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12263 
 
12264 
  def __eq__(self, other):
12265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12266 
 
12267 
  def __ne__(self, other):
12268 
    return not (self == other)
12269 
 
12270 
class markAlertsAsSeen_result:
12271 
 
12272 
  thrift_spec = (
12273 
  )
12274 
 
12275 
  def read(self, iprot):
12276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12278 
      return
12279 
    iprot.readStructBegin()
12280 
    while True:
12281 
      (fname, ftype, fid) = iprot.readFieldBegin()
12282 
      if ftype == TType.STOP:
12283 
        break
12284 
      else:
12285 
        iprot.skip(ftype)
12286 
      iprot.readFieldEnd()
12287 
    iprot.readStructEnd()
12288 
 
12289 
  def write(self, oprot):
12290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12292 
      return
12293 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
3064 chandransh 12312 
class getValidOrderCount_args:
12313 
 
12314 
  thrift_spec = (
12315 
  )
12316 
 
12317 
  def read(self, iprot):
12318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12320 
      return
12321 
    iprot.readStructBegin()
12322 
    while True:
12323 
      (fname, ftype, fid) = iprot.readFieldBegin()
12324 
      if ftype == TType.STOP:
12325 
        break
12326 
      else:
12327 
        iprot.skip(ftype)
12328 
      iprot.readFieldEnd()
12329 
    iprot.readStructEnd()
12330 
 
12331 
  def write(self, oprot):
12332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12334 
      return
12335 
    oprot.writeStructBegin('getValidOrderCount_args')
12336 
    oprot.writeFieldStop()
12337 
    oprot.writeStructEnd()
12338 
 
3431 rajveer 12339 
  def validate(self):
12340 
    return
12341 
 
12342 
 
3064 chandransh 12343 
  def __repr__(self):
12344 
    L = ['%s=%r' % (key, value)
12345 
      for key, value in self.__dict__.iteritems()]
12346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12347 
 
12348 
  def __eq__(self, other):
12349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12350 
 
12351 
  def __ne__(self, other):
12352 
    return not (self == other)
12353 
 
12354 
class getValidOrderCount_result:
94 ashish 12355 
  """
12356 
  Attributes:
12357 
   - success
12358 
  """
12359 
 
12360 
  thrift_spec = (
3064 chandransh 12361 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12362 
  )
12363 
 
3064 chandransh 12364 
  def __init__(self, success=None,):
94 ashish 12365 
    self.success = success
12366 
 
12367 
  def read(self, iprot):
12368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12370 
      return
12371 
    iprot.readStructBegin()
12372 
    while True:
12373 
      (fname, ftype, fid) = iprot.readFieldBegin()
12374 
      if ftype == TType.STOP:
12375 
        break
12376 
      if fid == 0:
3064 chandransh 12377 
        if ftype == TType.I64:
12378 
          self.success = iprot.readI64();
94 ashish 12379 
        else:
12380 
          iprot.skip(ftype)
12381 
      else:
12382 
        iprot.skip(ftype)
12383 
      iprot.readFieldEnd()
12384 
    iprot.readStructEnd()
12385 
 
12386 
  def write(self, oprot):
12387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12389 
      return
3064 chandransh 12390 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12391 
    if self.success is not None:
3064 chandransh 12392 
      oprot.writeFieldBegin('success', TType.I64, 0)
12393 
      oprot.writeI64(self.success)
94 ashish 12394 
      oprot.writeFieldEnd()
12395 
    oprot.writeFieldStop()
12396 
    oprot.writeStructEnd()
12397 
 
3431 rajveer 12398 
  def validate(self):
12399 
    return
12400 
 
12401 
 
94 ashish 12402 
  def __repr__(self):
12403 
    L = ['%s=%r' % (key, value)
12404 
      for key, value in self.__dict__.iteritems()]
12405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12406 
 
12407 
  def __eq__(self, other):
12408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12409 
 
12410 
  def __ne__(self, other):
12411 
    return not (self == other)
12412 
 
3064 chandransh 12413 
class getNoOfCustomersWithSuccessfulTransaction_args:
12414 
 
12415 
  thrift_spec = (
12416 
  )
12417 
 
12418 
  def read(self, iprot):
12419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12421 
      return
12422 
    iprot.readStructBegin()
12423 
    while True:
12424 
      (fname, ftype, fid) = iprot.readFieldBegin()
12425 
      if ftype == TType.STOP:
12426 
        break
12427 
      else:
12428 
        iprot.skip(ftype)
12429 
      iprot.readFieldEnd()
12430 
    iprot.readStructEnd()
12431 
 
12432 
  def write(self, oprot):
12433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12435 
      return
12436 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12437 
    oprot.writeFieldStop()
12438 
    oprot.writeStructEnd()
12439 
 
3431 rajveer 12440 
  def validate(self):
12441 
    return
12442 
 
12443 
 
3064 chandransh 12444 
  def __repr__(self):
12445 
    L = ['%s=%r' % (key, value)
12446 
      for key, value in self.__dict__.iteritems()]
12447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12448 
 
12449 
  def __eq__(self, other):
12450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12451 
 
12452 
  def __ne__(self, other):
12453 
    return not (self == other)
12454 
 
12455 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12456 
  """
12457 
  Attributes:
3064 chandransh 12458 
   - success
94 ashish 12459 
  """
12460 
 
12461 
  thrift_spec = (
3064 chandransh 12462 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12463 
  )
12464 
 
3064 chandransh 12465 
  def __init__(self, success=None,):
12466 
    self.success = success
94 ashish 12467 
 
12468 
  def read(self, iprot):
12469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12471 
      return
12472 
    iprot.readStructBegin()
12473 
    while True:
12474 
      (fname, ftype, fid) = iprot.readFieldBegin()
12475 
      if ftype == TType.STOP:
12476 
        break
3064 chandransh 12477 
      if fid == 0:
94 ashish 12478 
        if ftype == TType.I64:
3064 chandransh 12479 
          self.success = iprot.readI64();
94 ashish 12480 
        else:
12481 
          iprot.skip(ftype)
12482 
      else:
12483 
        iprot.skip(ftype)
12484 
      iprot.readFieldEnd()
12485 
    iprot.readStructEnd()
12486 
 
12487 
  def write(self, oprot):
12488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12490 
      return
3064 chandransh 12491 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12492 
    if self.success is not None:
3064 chandransh 12493 
      oprot.writeFieldBegin('success', TType.I64, 0)
12494 
      oprot.writeI64(self.success)
94 ashish 12495 
      oprot.writeFieldEnd()
12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
3431 rajveer 12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
94 ashish 12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
3064 chandransh 12514 
class getValidOrdersAmountRange_args:
12515 
 
12516 
  thrift_spec = (
12517 
  )
12518 
 
12519 
  def read(self, iprot):
12520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12522 
      return
12523 
    iprot.readStructBegin()
12524 
    while True:
12525 
      (fname, ftype, fid) = iprot.readFieldBegin()
12526 
      if ftype == TType.STOP:
12527 
        break
12528 
      else:
12529 
        iprot.skip(ftype)
12530 
      iprot.readFieldEnd()
12531 
    iprot.readStructEnd()
12532 
 
12533 
  def write(self, oprot):
12534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12536 
      return
12537 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12538 
    oprot.writeFieldStop()
12539 
    oprot.writeStructEnd()
12540 
 
3431 rajveer 12541 
  def validate(self):
12542 
    return
12543 
 
12544 
 
3064 chandransh 12545 
  def __repr__(self):
12546 
    L = ['%s=%r' % (key, value)
12547 
      for key, value in self.__dict__.iteritems()]
12548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12549 
 
12550 
  def __eq__(self, other):
12551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12552 
 
12553 
  def __ne__(self, other):
12554 
    return not (self == other)
12555 
 
12556 
class getValidOrdersAmountRange_result:
94 ashish 12557 
  """
12558 
  Attributes:
12559 
   - success
12560 
  """
12561 
 
12562 
  thrift_spec = (
3064 chandransh 12563 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12564 
  )
12565 
 
3064 chandransh 12566 
  def __init__(self, success=None,):
94 ashish 12567 
    self.success = success
12568 
 
12569 
  def read(self, iprot):
12570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12572 
      return
12573 
    iprot.readStructBegin()
12574 
    while True:
12575 
      (fname, ftype, fid) = iprot.readFieldBegin()
12576 
      if ftype == TType.STOP:
12577 
        break
12578 
      if fid == 0:
483 rajveer 12579 
        if ftype == TType.LIST:
12580 
          self.success = []
6188 rajveer 12581 
          (_etype249, _size246) = iprot.readListBegin()
12582 
          for _i250 in xrange(_size246):
12583 
            _elem251 = iprot.readDouble();
12584 
            self.success.append(_elem251)
483 rajveer 12585 
          iprot.readListEnd()
94 ashish 12586 
        else:
12587 
          iprot.skip(ftype)
12588 
      else:
12589 
        iprot.skip(ftype)
12590 
      iprot.readFieldEnd()
12591 
    iprot.readStructEnd()
12592 
 
12593 
  def write(self, oprot):
12594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12596 
      return
3064 chandransh 12597 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12598 
    if self.success is not None:
483 rajveer 12599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12600 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12601 
      for iter252 in self.success:
12602 
        oprot.writeDouble(iter252)
483 rajveer 12603 
      oprot.writeListEnd()
94 ashish 12604 
      oprot.writeFieldEnd()
12605 
    oprot.writeFieldStop()
12606 
    oprot.writeStructEnd()
12607 
 
3431 rajveer 12608 
  def validate(self):
12609 
    return
12610 
 
12611 
 
94 ashish 12612 
  def __repr__(self):
12613 
    L = ['%s=%r' % (key, value)
12614 
      for key, value in self.__dict__.iteritems()]
12615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12616 
 
12617 
  def __eq__(self, other):
12618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12619 
 
12620 
  def __ne__(self, other):
12621 
    return not (self == other)
12622 
 
3064 chandransh 12623 
class getValidOrders_args:
1528 ankur.sing 12624 
  """
12625 
  Attributes:
3064 chandransh 12626 
   - limit
5874 rajveer 12627 
   - onlyStore
1528 ankur.sing 12628 
  """
12629 
 
12630 
  thrift_spec = (
12631 
    None, # 0
3064 chandransh 12632 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12633 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12634 
  )
12635 
 
5874 rajveer 12636 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12637 
    self.limit = limit
5874 rajveer 12638 
    self.onlyStore = onlyStore
1528 ankur.sing 12639 
 
12640 
  def read(self, iprot):
12641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12643 
      return
12644 
    iprot.readStructBegin()
12645 
    while True:
12646 
      (fname, ftype, fid) = iprot.readFieldBegin()
12647 
      if ftype == TType.STOP:
12648 
        break
12649 
      if fid == 1:
12650 
        if ftype == TType.I64:
3064 chandransh 12651 
          self.limit = iprot.readI64();
1528 ankur.sing 12652 
        else:
12653 
          iprot.skip(ftype)
5874 rajveer 12654 
      elif fid == 2:
12655 
        if ftype == TType.BOOL:
12656 
          self.onlyStore = iprot.readBool();
12657 
        else:
12658 
          iprot.skip(ftype)
1528 ankur.sing 12659 
      else:
12660 
        iprot.skip(ftype)
12661 
      iprot.readFieldEnd()
12662 
    iprot.readStructEnd()
12663 
 
12664 
  def write(self, oprot):
12665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12667 
      return
3064 chandransh 12668 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12669 
    if self.limit is not None:
3064 chandransh 12670 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12671 
      oprot.writeI64(self.limit)
1528 ankur.sing 12672 
      oprot.writeFieldEnd()
5874 rajveer 12673 
    if self.onlyStore is not None:
12674 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12675 
      oprot.writeBool(self.onlyStore)
12676 
      oprot.writeFieldEnd()
1528 ankur.sing 12677 
    oprot.writeFieldStop()
12678 
    oprot.writeStructEnd()
12679 
 
3431 rajveer 12680 
  def validate(self):
12681 
    return
12682 
 
12683 
 
1528 ankur.sing 12684 
  def __repr__(self):
12685 
    L = ['%s=%r' % (key, value)
12686 
      for key, value in self.__dict__.iteritems()]
12687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12688 
 
12689 
  def __eq__(self, other):
12690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12691 
 
12692 
  def __ne__(self, other):
12693 
    return not (self == other)
12694 
 
3064 chandransh 12695 
class getValidOrders_result:
1528 ankur.sing 12696 
  """
12697 
  Attributes:
12698 
   - success
12699 
  """
12700 
 
12701 
  thrift_spec = (
3064 chandransh 12702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12703 
  )
12704 
 
3064 chandransh 12705 
  def __init__(self, success=None,):
1528 ankur.sing 12706 
    self.success = success
12707 
 
12708 
  def read(self, iprot):
12709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12711 
      return
12712 
    iprot.readStructBegin()
12713 
    while True:
12714 
      (fname, ftype, fid) = iprot.readFieldBegin()
12715 
      if ftype == TType.STOP:
12716 
        break
12717 
      if fid == 0:
3064 chandransh 12718 
        if ftype == TType.LIST:
12719 
          self.success = []
6188 rajveer 12720 
          (_etype256, _size253) = iprot.readListBegin()
12721 
          for _i257 in xrange(_size253):
12722 
            _elem258 = Order()
12723 
            _elem258.read(iprot)
12724 
            self.success.append(_elem258)
3064 chandransh 12725 
          iprot.readListEnd()
1528 ankur.sing 12726 
        else:
12727 
          iprot.skip(ftype)
12728 
      else:
12729 
        iprot.skip(ftype)
12730 
      iprot.readFieldEnd()
12731 
    iprot.readStructEnd()
12732 
 
12733 
  def write(self, oprot):
12734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12736 
      return
3064 chandransh 12737 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12738 
    if self.success is not None:
3064 chandransh 12739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12741 
      for iter259 in self.success:
12742 
        iter259.write(oprot)
3064 chandransh 12743 
      oprot.writeListEnd()
1528 ankur.sing 12744 
      oprot.writeFieldEnd()
12745 
    oprot.writeFieldStop()
12746 
    oprot.writeStructEnd()
12747 
 
3431 rajveer 12748 
  def validate(self):
12749 
    return
12750 
 
12751 
 
1528 ankur.sing 12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
1220 chandransh 12763 
class batchOrders_args:
12764 
  """
12765 
  Attributes:
12766 
   - warehouseId
12767 
  """
12768 
 
12769 
  thrift_spec = (
12770 
    None, # 0
12771 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12772 
  )
12773 
 
12774 
  def __init__(self, warehouseId=None,):
12775 
    self.warehouseId = warehouseId
12776 
 
12777 
  def read(self, iprot):
12778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12780 
      return
12781 
    iprot.readStructBegin()
12782 
    while True:
12783 
      (fname, ftype, fid) = iprot.readFieldBegin()
12784 
      if ftype == TType.STOP:
12785 
        break
12786 
      if fid == 1:
12787 
        if ftype == TType.I64:
12788 
          self.warehouseId = iprot.readI64();
12789 
        else:
12790 
          iprot.skip(ftype)
12791 
      else:
12792 
        iprot.skip(ftype)
12793 
      iprot.readFieldEnd()
12794 
    iprot.readStructEnd()
12795 
 
12796 
  def write(self, oprot):
12797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12799 
      return
12800 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12801 
    if self.warehouseId is not None:
1220 chandransh 12802 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12803 
      oprot.writeI64(self.warehouseId)
12804 
      oprot.writeFieldEnd()
12805 
    oprot.writeFieldStop()
12806 
    oprot.writeStructEnd()
12807 
 
3431 rajveer 12808 
  def validate(self):
12809 
    return
12810 
 
12811 
 
1220 chandransh 12812 
  def __repr__(self):
12813 
    L = ['%s=%r' % (key, value)
12814 
      for key, value in self.__dict__.iteritems()]
12815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12816 
 
12817 
  def __eq__(self, other):
12818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12819 
 
12820 
  def __ne__(self, other):
12821 
    return not (self == other)
12822 
 
12823 
class batchOrders_result:
12824 
  """
12825 
  Attributes:
12826 
   - success
12827 
   - ex
12828 
  """
12829 
 
12830 
  thrift_spec = (
12831 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12833 
  )
12834 
 
12835 
  def __init__(self, success=None, ex=None,):
12836 
    self.success = success
12837 
    self.ex = ex
12838 
 
12839 
  def read(self, iprot):
12840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12842 
      return
12843 
    iprot.readStructBegin()
12844 
    while True:
12845 
      (fname, ftype, fid) = iprot.readFieldBegin()
12846 
      if ftype == TType.STOP:
12847 
        break
12848 
      if fid == 0:
12849 
        if ftype == TType.LIST:
12850 
          self.success = []
6188 rajveer 12851 
          (_etype263, _size260) = iprot.readListBegin()
12852 
          for _i264 in xrange(_size260):
12853 
            _elem265 = Order()
12854 
            _elem265.read(iprot)
12855 
            self.success.append(_elem265)
1220 chandransh 12856 
          iprot.readListEnd()
12857 
        else:
12858 
          iprot.skip(ftype)
12859 
      elif fid == 1:
12860 
        if ftype == TType.STRUCT:
12861 
          self.ex = TransactionServiceException()
12862 
          self.ex.read(iprot)
12863 
        else:
12864 
          iprot.skip(ftype)
12865 
      else:
12866 
        iprot.skip(ftype)
12867 
      iprot.readFieldEnd()
12868 
    iprot.readStructEnd()
12869 
 
12870 
  def write(self, oprot):
12871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12873 
      return
12874 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12875 
    if self.success is not None:
1220 chandransh 12876 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12877 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12878 
      for iter266 in self.success:
12879 
        iter266.write(oprot)
1220 chandransh 12880 
      oprot.writeListEnd()
12881 
      oprot.writeFieldEnd()
3431 rajveer 12882 
    if self.ex is not None:
1220 chandransh 12883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12884 
      self.ex.write(oprot)
12885 
      oprot.writeFieldEnd()
12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
3431 rajveer 12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
1220 chandransh 12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
12903 
 
1208 chandransh 12904 
class markOrderAsOutOfStock_args:
12905 
  """
12906 
  Attributes:
12907 
   - orderId
12908 
  """
12909 
 
12910 
  thrift_spec = (
12911 
    None, # 0
12912 
    (1, TType.I64, 'orderId', None, None, ), # 1
12913 
  )
12914 
 
12915 
  def __init__(self, orderId=None,):
12916 
    self.orderId = orderId
12917 
 
12918 
  def read(self, iprot):
12919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12921 
      return
12922 
    iprot.readStructBegin()
12923 
    while True:
12924 
      (fname, ftype, fid) = iprot.readFieldBegin()
12925 
      if ftype == TType.STOP:
12926 
        break
12927 
      if fid == 1:
12928 
        if ftype == TType.I64:
12929 
          self.orderId = iprot.readI64();
12930 
        else:
12931 
          iprot.skip(ftype)
12932 
      else:
12933 
        iprot.skip(ftype)
12934 
      iprot.readFieldEnd()
12935 
    iprot.readStructEnd()
12936 
 
12937 
  def write(self, oprot):
12938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12940 
      return
12941 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12942 
    if self.orderId is not None:
1208 chandransh 12943 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12944 
      oprot.writeI64(self.orderId)
12945 
      oprot.writeFieldEnd()
12946 
    oprot.writeFieldStop()
12947 
    oprot.writeStructEnd()
12948 
 
3431 rajveer 12949 
  def validate(self):
12950 
    return
12951 
 
12952 
 
1208 chandransh 12953 
  def __repr__(self):
12954 
    L = ['%s=%r' % (key, value)
12955 
      for key, value in self.__dict__.iteritems()]
12956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12957 
 
12958 
  def __eq__(self, other):
12959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12960 
 
12961 
  def __ne__(self, other):
12962 
    return not (self == other)
12963 
 
12964 
class markOrderAsOutOfStock_result:
12965 
  """
12966 
  Attributes:
12967 
   - success
12968 
   - ex
12969 
  """
12970 
 
12971 
  thrift_spec = (
12972 
    (0, TType.BOOL, 'success', None, None, ), # 0
12973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12974 
  )
12975 
 
12976 
  def __init__(self, success=None, ex=None,):
12977 
    self.success = success
12978 
    self.ex = ex
12979 
 
12980 
  def read(self, iprot):
12981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12983 
      return
12984 
    iprot.readStructBegin()
12985 
    while True:
12986 
      (fname, ftype, fid) = iprot.readFieldBegin()
12987 
      if ftype == TType.STOP:
12988 
        break
12989 
      if fid == 0:
12990 
        if ftype == TType.BOOL:
12991 
          self.success = iprot.readBool();
12992 
        else:
12993 
          iprot.skip(ftype)
12994 
      elif fid == 1:
12995 
        if ftype == TType.STRUCT:
12996 
          self.ex = TransactionServiceException()
12997 
          self.ex.read(iprot)
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13010 
    if self.success is not None:
1208 chandransh 13011 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13012 
      oprot.writeBool(self.success)
13013 
      oprot.writeFieldEnd()
3431 rajveer 13014 
    if self.ex is not None:
1208 chandransh 13015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13016 
      self.ex.write(oprot)
13017 
      oprot.writeFieldEnd()
13018 
    oprot.writeFieldStop()
13019 
    oprot.writeStructEnd()
13020 
 
3431 rajveer 13021 
  def validate(self):
13022 
    return
13023 
 
13024 
 
1208 chandransh 13025 
  def __repr__(self):
13026 
    L = ['%s=%r' % (key, value)
13027 
      for key, value in self.__dict__.iteritems()]
13028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13029 
 
13030 
  def __eq__(self, other):
13031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13032 
 
13033 
  def __ne__(self, other):
13034 
    return not (self == other)
13035 
 
3064 chandransh 13036 
class verifyOrder_args:
759 chandransh 13037 
  """
13038 
  Attributes:
3064 chandransh 13039 
   - orderId
759 chandransh 13040 
  """
13041 
 
13042 
  thrift_spec = (
13043 
    None, # 0
3064 chandransh 13044 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13045 
  )
13046 
 
3064 chandransh 13047 
  def __init__(self, orderId=None,):
13048 
    self.orderId = orderId
759 chandransh 13049 
 
13050 
  def read(self, iprot):
13051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13053 
      return
13054 
    iprot.readStructBegin()
13055 
    while True:
13056 
      (fname, ftype, fid) = iprot.readFieldBegin()
13057 
      if ftype == TType.STOP:
13058 
        break
13059 
      if fid == 1:
13060 
        if ftype == TType.I64:
3064 chandransh 13061 
          self.orderId = iprot.readI64();
759 chandransh 13062 
        else:
13063 
          iprot.skip(ftype)
13064 
      else:
13065 
        iprot.skip(ftype)
13066 
      iprot.readFieldEnd()
13067 
    iprot.readStructEnd()
13068 
 
13069 
  def write(self, oprot):
13070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13072 
      return
3064 chandransh 13073 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13074 
    if self.orderId is not None:
3064 chandransh 13075 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13076 
      oprot.writeI64(self.orderId)
759 chandransh 13077 
      oprot.writeFieldEnd()
13078 
    oprot.writeFieldStop()
13079 
    oprot.writeStructEnd()
13080 
 
3431 rajveer 13081 
  def validate(self):
13082 
    return
13083 
 
13084 
 
759 chandransh 13085 
  def __repr__(self):
13086 
    L = ['%s=%r' % (key, value)
13087 
      for key, value in self.__dict__.iteritems()]
13088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13089 
 
13090 
  def __eq__(self, other):
13091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13092 
 
13093 
  def __ne__(self, other):
13094 
    return not (self == other)
13095 
 
3064 chandransh 13096 
class verifyOrder_result:
759 chandransh 13097 
  """
13098 
  Attributes:
13099 
   - success
13100 
   - ex
13101 
  """
13102 
 
13103 
  thrift_spec = (
13104 
    (0, TType.BOOL, 'success', None, None, ), # 0
13105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13106 
  )
13107 
 
13108 
  def __init__(self, success=None, ex=None,):
13109 
    self.success = success
13110 
    self.ex = ex
13111 
 
13112 
  def read(self, iprot):
13113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13115 
      return
13116 
    iprot.readStructBegin()
13117 
    while True:
13118 
      (fname, ftype, fid) = iprot.readFieldBegin()
13119 
      if ftype == TType.STOP:
13120 
        break
13121 
      if fid == 0:
13122 
        if ftype == TType.BOOL:
13123 
          self.success = iprot.readBool();
13124 
        else:
13125 
          iprot.skip(ftype)
13126 
      elif fid == 1:
13127 
        if ftype == TType.STRUCT:
13128 
          self.ex = TransactionServiceException()
13129 
          self.ex.read(iprot)
13130 
        else:
13131 
          iprot.skip(ftype)
13132 
      else:
13133 
        iprot.skip(ftype)
13134 
      iprot.readFieldEnd()
13135 
    iprot.readStructEnd()
13136 
 
13137 
  def write(self, oprot):
13138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13140 
      return
3064 chandransh 13141 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13142 
    if self.success is not None:
759 chandransh 13143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13144 
      oprot.writeBool(self.success)
13145 
      oprot.writeFieldEnd()
3431 rajveer 13146 
    if self.ex is not None:
759 chandransh 13147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13148 
      self.ex.write(oprot)
13149 
      oprot.writeFieldEnd()
13150 
    oprot.writeFieldStop()
13151 
    oprot.writeStructEnd()
13152 
 
3431 rajveer 13153 
  def validate(self):
13154 
    return
13155 
 
13156 
 
759 chandransh 13157 
  def __repr__(self):
13158 
    L = ['%s=%r' % (key, value)
13159 
      for key, value in self.__dict__.iteritems()]
13160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13161 
 
13162 
  def __eq__(self, other):
13163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13164 
 
13165 
  def __ne__(self, other):
13166 
    return not (self == other)
13167 
 
3064 chandransh 13168 
class acceptOrder_args:
1113 chandransh 13169 
  """
13170 
  Attributes:
3064 chandransh 13171 
   - orderId
1113 chandransh 13172 
  """
13173 
 
13174 
  thrift_spec = (
13175 
    None, # 0
3064 chandransh 13176 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13177 
  )
13178 
 
3064 chandransh 13179 
  def __init__(self, orderId=None,):
13180 
    self.orderId = orderId
1113 chandransh 13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 1:
13192 
        if ftype == TType.I64:
3064 chandransh 13193 
          self.orderId = iprot.readI64();
1113 chandransh 13194 
        else:
13195 
          iprot.skip(ftype)
13196 
      else:
13197 
        iprot.skip(ftype)
13198 
      iprot.readFieldEnd()
13199 
    iprot.readStructEnd()
13200 
 
13201 
  def write(self, oprot):
13202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13204 
      return
3064 chandransh 13205 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13206 
    if self.orderId is not None:
3064 chandransh 13207 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13208 
      oprot.writeI64(self.orderId)
1113 chandransh 13209 
      oprot.writeFieldEnd()
13210 
    oprot.writeFieldStop()
13211 
    oprot.writeStructEnd()
13212 
 
3431 rajveer 13213 
  def validate(self):
13214 
    return
13215 
 
13216 
 
1113 chandransh 13217 
  def __repr__(self):
13218 
    L = ['%s=%r' % (key, value)
13219 
      for key, value in self.__dict__.iteritems()]
13220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13221 
 
13222 
  def __eq__(self, other):
13223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13224 
 
13225 
  def __ne__(self, other):
13226 
    return not (self == other)
13227 
 
3064 chandransh 13228 
class acceptOrder_result:
1113 chandransh 13229 
  """
13230 
  Attributes:
13231 
   - success
13232 
   - ex
13233 
  """
13234 
 
13235 
  thrift_spec = (
3064 chandransh 13236 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13238 
  )
13239 
 
13240 
  def __init__(self, success=None, ex=None,):
13241 
    self.success = success
13242 
    self.ex = ex
13243 
 
13244 
  def read(self, iprot):
13245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13247 
      return
13248 
    iprot.readStructBegin()
13249 
    while True:
13250 
      (fname, ftype, fid) = iprot.readFieldBegin()
13251 
      if ftype == TType.STOP:
13252 
        break
13253 
      if fid == 0:
3064 chandransh 13254 
        if ftype == TType.BOOL:
13255 
          self.success = iprot.readBool();
1113 chandransh 13256 
        else:
13257 
          iprot.skip(ftype)
13258 
      elif fid == 1:
13259 
        if ftype == TType.STRUCT:
13260 
          self.ex = TransactionServiceException()
13261 
          self.ex.read(iprot)
13262 
        else:
13263 
          iprot.skip(ftype)
13264 
      else:
13265 
        iprot.skip(ftype)
13266 
      iprot.readFieldEnd()
13267 
    iprot.readStructEnd()
13268 
 
13269 
  def write(self, oprot):
13270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13272 
      return
3064 chandransh 13273 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13274 
    if self.success is not None:
3064 chandransh 13275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13276 
      oprot.writeBool(self.success)
1113 chandransh 13277 
      oprot.writeFieldEnd()
3431 rajveer 13278 
    if self.ex is not None:
1113 chandransh 13279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13280 
      self.ex.write(oprot)
13281 
      oprot.writeFieldEnd()
13282 
    oprot.writeFieldStop()
13283 
    oprot.writeStructEnd()
13284 
 
3431 rajveer 13285 
  def validate(self):
13286 
    return
13287 
 
13288 
 
1113 chandransh 13289 
  def __repr__(self):
13290 
    L = ['%s=%r' % (key, value)
13291 
      for key, value in self.__dict__.iteritems()]
13292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13293 
 
13294 
  def __eq__(self, other):
13295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13296 
 
13297 
  def __ne__(self, other):
13298 
    return not (self == other)
13299 
 
3064 chandransh 13300 
class addBillingDetails_args:
1135 chandransh 13301 
  """
13302 
  Attributes:
3064 chandransh 13303 
   - orderId
13304 
   - invoice_number
4658 mandeep.dh 13305 
   - serialNumber
4283 anupam.sin 13306 
   - itemNumber
3064 chandransh 13307 
   - billed_by
4264 rajveer 13308 
   - jacketNumber
4283 anupam.sin 13309 
   - billingType
5110 mandeep.dh 13310 
   - fulfilmentWarehouseId
4763 rajveer 13311 
   - authorize
1135 chandransh 13312 
  """
13313 
 
13314 
  thrift_spec = (
13315 
    None, # 0
3064 chandransh 13316 
    (1, TType.I64, 'orderId', None, None, ), # 1
13317 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13318 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13319 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13320 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13321 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13322 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13323 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13324 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13325 
  )
13326 
 
5110 mandeep.dh 13327 
  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 13328 
    self.orderId = orderId
13329 
    self.invoice_number = invoice_number
4658 mandeep.dh 13330 
    self.serialNumber = serialNumber
4283 anupam.sin 13331 
    self.itemNumber = itemNumber
3064 chandransh 13332 
    self.billed_by = billed_by
4264 rajveer 13333 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13334 
    self.billingType = billingType
5110 mandeep.dh 13335 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13336 
    self.authorize = authorize
1135 chandransh 13337 
 
13338 
  def read(self, iprot):
13339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13341 
      return
13342 
    iprot.readStructBegin()
13343 
    while True:
13344 
      (fname, ftype, fid) = iprot.readFieldBegin()
13345 
      if ftype == TType.STOP:
13346 
        break
13347 
      if fid == 1:
13348 
        if ftype == TType.I64:
3064 chandransh 13349 
          self.orderId = iprot.readI64();
1135 chandransh 13350 
        else:
13351 
          iprot.skip(ftype)
13352 
      elif fid == 2:
3064 chandransh 13353 
        if ftype == TType.STRING:
13354 
          self.invoice_number = iprot.readString();
1135 chandransh 13355 
        else:
13356 
          iprot.skip(ftype)
3064 chandransh 13357 
      elif fid == 3:
5411 rajveer 13358 
        if ftype == TType.LIST:
13359 
          self.serialNumber = []
6188 rajveer 13360 
          (_etype270, _size267) = iprot.readListBegin()
13361 
          for _i271 in xrange(_size267):
13362 
            _elem272 = iprot.readString();
13363 
            self.serialNumber.append(_elem272)
5411 rajveer 13364 
          iprot.readListEnd()
3064 chandransh 13365 
        else:
13366 
          iprot.skip(ftype)
13367 
      elif fid == 4:
5411 rajveer 13368 
        if ftype == TType.LIST:
13369 
          self.itemNumber = []
6188 rajveer 13370 
          (_etype276, _size273) = iprot.readListBegin()
13371 
          for _i277 in xrange(_size273):
13372 
            _elem278 = iprot.readString();
13373 
            self.itemNumber.append(_elem278)
5411 rajveer 13374 
          iprot.readListEnd()
3064 chandransh 13375 
        else:
13376 
          iprot.skip(ftype)
13377 
      elif fid == 5:
13378 
        if ftype == TType.STRING:
4283 anupam.sin 13379 
          self.billed_by = iprot.readString();
3064 chandransh 13380 
        else:
13381 
          iprot.skip(ftype)
13382 
      elif fid == 6:
13383 
        if ftype == TType.I64:
4283 anupam.sin 13384 
          self.jacketNumber = iprot.readI64();
13385 
        else:
13386 
          iprot.skip(ftype)
13387 
      elif fid == 7:
13388 
        if ftype == TType.I64:
3064 chandransh 13389 
          self.billingType = iprot.readI64();
13390 
        else:
13391 
          iprot.skip(ftype)
4283 anupam.sin 13392 
      elif fid == 8:
13393 
        if ftype == TType.I64:
5110 mandeep.dh 13394 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13395 
        else:
13396 
          iprot.skip(ftype)
4763 rajveer 13397 
      elif fid == 9:
13398 
        if ftype == TType.BOOL:
13399 
          self.authorize = iprot.readBool();
13400 
        else:
13401 
          iprot.skip(ftype)
1246 chandransh 13402 
      else:
13403 
        iprot.skip(ftype)
13404 
      iprot.readFieldEnd()
13405 
    iprot.readStructEnd()
13406 
 
13407 
  def write(self, oprot):
13408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13410 
      return
4283 anupam.sin 13411 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13412 
    if self.orderId is not None:
3064 chandransh 13413 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13414 
      oprot.writeI64(self.orderId)
1246 chandransh 13415 
      oprot.writeFieldEnd()
4283 anupam.sin 13416 
    if self.invoice_number is not None:
13417 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13418 
      oprot.writeString(self.invoice_number)
1246 chandransh 13419 
      oprot.writeFieldEnd()
4658 mandeep.dh 13420 
    if self.serialNumber is not None:
5411 rajveer 13421 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13422 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13423 
      for iter279 in self.serialNumber:
13424 
        oprot.writeString(iter279)
5411 rajveer 13425 
      oprot.writeListEnd()
3064 chandransh 13426 
      oprot.writeFieldEnd()
3431 rajveer 13427 
    if self.itemNumber is not None:
5411 rajveer 13428 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13429 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13430 
      for iter280 in self.itemNumber:
13431 
        oprot.writeString(iter280)
5411 rajveer 13432 
      oprot.writeListEnd()
3064 chandransh 13433 
      oprot.writeFieldEnd()
4283 anupam.sin 13434 
    if self.billed_by is not None:
13435 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13436 
      oprot.writeString(self.billed_by)
3064 chandransh 13437 
      oprot.writeFieldEnd()
4283 anupam.sin 13438 
    if self.jacketNumber is not None:
13439 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13440 
      oprot.writeI64(self.jacketNumber)
13441 
      oprot.writeFieldEnd()
3431 rajveer 13442 
    if self.billingType is not None:
4283 anupam.sin 13443 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13444 
      oprot.writeI64(self.billingType)
13445 
      oprot.writeFieldEnd()
5110 mandeep.dh 13446 
    if self.fulfilmentWarehouseId is not None:
13447 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13448 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13449 
      oprot.writeFieldEnd()
4763 rajveer 13450 
    if self.authorize is not None:
13451 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13452 
      oprot.writeBool(self.authorize)
13453 
      oprot.writeFieldEnd()
1246 chandransh 13454 
    oprot.writeFieldStop()
13455 
    oprot.writeStructEnd()
13456 
 
3431 rajveer 13457 
  def validate(self):
13458 
    return
13459 
 
13460 
 
1246 chandransh 13461 
  def __repr__(self):
13462 
    L = ['%s=%r' % (key, value)
13463 
      for key, value in self.__dict__.iteritems()]
13464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13465 
 
13466 
  def __eq__(self, other):
13467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13468 
 
13469 
  def __ne__(self, other):
13470 
    return not (self == other)
13471 
 
4283 anupam.sin 13472 
class addBillingDetails_result:
1246 chandransh 13473 
  """
13474 
  Attributes:
3064 chandransh 13475 
   - success
1246 chandransh 13476 
   - ex
13477 
  """
13478 
 
13479 
  thrift_spec = (
3064 chandransh 13480 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13482 
  )
13483 
 
3064 chandransh 13484 
  def __init__(self, success=None, ex=None,):
13485 
    self.success = success
1246 chandransh 13486 
    self.ex = ex
13487 
 
13488 
  def read(self, iprot):
13489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13491 
      return
13492 
    iprot.readStructBegin()
13493 
    while True:
13494 
      (fname, ftype, fid) = iprot.readFieldBegin()
13495 
      if ftype == TType.STOP:
13496 
        break
3064 chandransh 13497 
      if fid == 0:
13498 
        if ftype == TType.BOOL:
13499 
          self.success = iprot.readBool();
13500 
        else:
13501 
          iprot.skip(ftype)
13502 
      elif fid == 1:
1246 chandransh 13503 
        if ftype == TType.STRUCT:
13504 
          self.ex = TransactionServiceException()
13505 
          self.ex.read(iprot)
13506 
        else:
13507 
          iprot.skip(ftype)
13508 
      else:
13509 
        iprot.skip(ftype)
13510 
      iprot.readFieldEnd()
13511 
    iprot.readStructEnd()
13512 
 
13513 
  def write(self, oprot):
13514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13516 
      return
4283 anupam.sin 13517 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13518 
    if self.success is not None:
3064 chandransh 13519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13520 
      oprot.writeBool(self.success)
13521 
      oprot.writeFieldEnd()
3431 rajveer 13522 
    if self.ex is not None:
1246 chandransh 13523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13524 
      self.ex.write(oprot)
13525 
      oprot.writeFieldEnd()
13526 
    oprot.writeFieldStop()
13527 
    oprot.writeStructEnd()
13528 
 
3431 rajveer 13529 
  def validate(self):
13530 
    return
13531 
 
13532 
 
1246 chandransh 13533 
  def __repr__(self):
13534 
    L = ['%s=%r' % (key, value)
13535 
      for key, value in self.__dict__.iteritems()]
13536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13537 
 
13538 
  def __eq__(self, other):
13539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13540 
 
13541 
  def __ne__(self, other):
13542 
    return not (self == other)
13543 
 
4579 rajveer 13544 
class addInvoiceNumber_args:
13545 
  """
13546 
  Attributes:
13547 
   - orderId
13548 
   - invoiceNumber
4763 rajveer 13549 
   - color
4579 rajveer 13550 
  """
13551 
 
13552 
  thrift_spec = (
13553 
    None, # 0
13554 
    (1, TType.I64, 'orderId', None, None, ), # 1
13555 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13556 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13557 
  )
13558 
 
4763 rajveer 13559 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13560 
    self.orderId = orderId
13561 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13562 
    self.color = color
4579 rajveer 13563 
 
13564 
  def read(self, iprot):
13565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13567 
      return
13568 
    iprot.readStructBegin()
13569 
    while True:
13570 
      (fname, ftype, fid) = iprot.readFieldBegin()
13571 
      if ftype == TType.STOP:
13572 
        break
13573 
      if fid == 1:
13574 
        if ftype == TType.I64:
13575 
          self.orderId = iprot.readI64();
13576 
        else:
13577 
          iprot.skip(ftype)
13578 
      elif fid == 2:
13579 
        if ftype == TType.STRING:
13580 
          self.invoiceNumber = iprot.readString();
13581 
        else:
13582 
          iprot.skip(ftype)
4763 rajveer 13583 
      elif fid == 3:
13584 
        if ftype == TType.STRING:
13585 
          self.color = iprot.readString();
13586 
        else:
13587 
          iprot.skip(ftype)
4579 rajveer 13588 
      else:
13589 
        iprot.skip(ftype)
13590 
      iprot.readFieldEnd()
13591 
    iprot.readStructEnd()
13592 
 
13593 
  def write(self, oprot):
13594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13596 
      return
13597 
    oprot.writeStructBegin('addInvoiceNumber_args')
13598 
    if self.orderId is not None:
13599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13600 
      oprot.writeI64(self.orderId)
13601 
      oprot.writeFieldEnd()
13602 
    if self.invoiceNumber is not None:
13603 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13604 
      oprot.writeString(self.invoiceNumber)
13605 
      oprot.writeFieldEnd()
4763 rajveer 13606 
    if self.color is not None:
13607 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13608 
      oprot.writeString(self.color)
13609 
      oprot.writeFieldEnd()
4579 rajveer 13610 
    oprot.writeFieldStop()
13611 
    oprot.writeStructEnd()
13612 
 
13613 
  def validate(self):
13614 
    return
13615 
 
13616 
 
13617 
  def __repr__(self):
13618 
    L = ['%s=%r' % (key, value)
13619 
      for key, value in self.__dict__.iteritems()]
13620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13621 
 
13622 
  def __eq__(self, other):
13623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13624 
 
13625 
  def __ne__(self, other):
13626 
    return not (self == other)
13627 
 
13628 
class addInvoiceNumber_result:
13629 
  """
13630 
  Attributes:
13631 
   - ex
13632 
  """
13633 
 
13634 
  thrift_spec = (
13635 
    None, # 0
13636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13637 
  )
13638 
 
13639 
  def __init__(self, ex=None,):
13640 
    self.ex = ex
13641 
 
13642 
  def read(self, iprot):
13643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13645 
      return
13646 
    iprot.readStructBegin()
13647 
    while True:
13648 
      (fname, ftype, fid) = iprot.readFieldBegin()
13649 
      if ftype == TType.STOP:
13650 
        break
13651 
      if fid == 1:
13652 
        if ftype == TType.STRUCT:
13653 
          self.ex = TransactionServiceException()
13654 
          self.ex.read(iprot)
13655 
        else:
13656 
          iprot.skip(ftype)
13657 
      else:
13658 
        iprot.skip(ftype)
13659 
      iprot.readFieldEnd()
13660 
    iprot.readStructEnd()
13661 
 
13662 
  def write(self, oprot):
13663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13665 
      return
13666 
    oprot.writeStructBegin('addInvoiceNumber_result')
13667 
    if self.ex is not None:
13668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13669 
      self.ex.write(oprot)
13670 
      oprot.writeFieldEnd()
13671 
    oprot.writeFieldStop()
13672 
    oprot.writeStructEnd()
13673 
 
13674 
  def validate(self):
13675 
    return
13676 
 
13677 
 
13678 
  def __repr__(self):
13679 
    L = ['%s=%r' % (key, value)
13680 
      for key, value in self.__dict__.iteritems()]
13681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13682 
 
13683 
  def __eq__(self, other):
13684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13685 
 
13686 
  def __ne__(self, other):
13687 
    return not (self == other)
13688 
 
4910 phani.kuma 13689 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13690 
  """
13691 
  Attributes:
3064 chandransh 13692 
   - warehouseId
1408 ankur.sing 13693 
   - providerId
3064 chandransh 13694 
   - cod
4910 phani.kuma 13695 
   - orderIds
1408 ankur.sing 13696 
  """
13697 
 
13698 
  thrift_spec = (
13699 
    None, # 0
3064 chandransh 13700 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13701 
    (2, TType.I64, 'providerId', None, None, ), # 2
13702 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13703 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13704 
  )
13705 
 
4910 phani.kuma 13706 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13707 
    self.warehouseId = warehouseId
1408 ankur.sing 13708 
    self.providerId = providerId
3064 chandransh 13709 
    self.cod = cod
4910 phani.kuma 13710 
    self.orderIds = orderIds
1408 ankur.sing 13711 
 
13712 
  def read(self, iprot):
13713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13715 
      return
13716 
    iprot.readStructBegin()
13717 
    while True:
13718 
      (fname, ftype, fid) = iprot.readFieldBegin()
13719 
      if ftype == TType.STOP:
13720 
        break
13721 
      if fid == 1:
13722 
        if ftype == TType.I64:
3064 chandransh 13723 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13724 
        else:
13725 
          iprot.skip(ftype)
13726 
      elif fid == 2:
13727 
        if ftype == TType.I64:
3064 chandransh 13728 
          self.providerId = iprot.readI64();
1408 ankur.sing 13729 
        else:
13730 
          iprot.skip(ftype)
3064 chandransh 13731 
      elif fid == 3:
13732 
        if ftype == TType.BOOL:
13733 
          self.cod = iprot.readBool();
13734 
        else:
13735 
          iprot.skip(ftype)
4910 phani.kuma 13736 
      elif fid == 4:
13737 
        if ftype == TType.LIST:
13738 
          self.orderIds = []
6188 rajveer 13739 
          (_etype284, _size281) = iprot.readListBegin()
13740 
          for _i285 in xrange(_size281):
13741 
            _elem286 = iprot.readI64();
13742 
            self.orderIds.append(_elem286)
4910 phani.kuma 13743 
          iprot.readListEnd()
13744 
        else:
13745 
          iprot.skip(ftype)
1408 ankur.sing 13746 
      else:
13747 
        iprot.skip(ftype)
13748 
      iprot.readFieldEnd()
13749 
    iprot.readStructEnd()
13750 
 
13751 
  def write(self, oprot):
13752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13754 
      return
4910 phani.kuma 13755 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13756 
    if self.warehouseId is not None:
3064 chandransh 13757 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13758 
      oprot.writeI64(self.warehouseId)
13759 
      oprot.writeFieldEnd()
3431 rajveer 13760 
    if self.providerId is not None:
3064 chandransh 13761 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13762 
      oprot.writeI64(self.providerId)
13763 
      oprot.writeFieldEnd()
3431 rajveer 13764 
    if self.cod is not None:
3064 chandransh 13765 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13766 
      oprot.writeBool(self.cod)
1408 ankur.sing 13767 
      oprot.writeFieldEnd()
4910 phani.kuma 13768 
    if self.orderIds is not None:
13769 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13770 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13771 
      for iter287 in self.orderIds:
13772 
        oprot.writeI64(iter287)
4910 phani.kuma 13773 
      oprot.writeListEnd()
13774 
      oprot.writeFieldEnd()
1408 ankur.sing 13775 
    oprot.writeFieldStop()
13776 
    oprot.writeStructEnd()
13777 
 
3431 rajveer 13778 
  def validate(self):
13779 
    return
13780 
 
13781 
 
1408 ankur.sing 13782 
  def __repr__(self):
13783 
    L = ['%s=%r' % (key, value)
13784 
      for key, value in self.__dict__.iteritems()]
13785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13786 
 
13787 
  def __eq__(self, other):
13788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13789 
 
13790 
  def __ne__(self, other):
13791 
    return not (self == other)
13792 
 
4910 phani.kuma 13793 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13794 
  """
13795 
  Attributes:
13796 
   - success
3064 chandransh 13797 
   - ex
1408 ankur.sing 13798 
  """
13799 
 
13800 
  thrift_spec = (
3064 chandransh 13801 
    (0, TType.BOOL, 'success', None, None, ), # 0
13802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13803 
  )
13804 
 
3064 chandransh 13805 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13806 
    self.success = success
3064 chandransh 13807 
    self.ex = ex
1408 ankur.sing 13808 
 
13809 
  def read(self, iprot):
13810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13812 
      return
13813 
    iprot.readStructBegin()
13814 
    while True:
13815 
      (fname, ftype, fid) = iprot.readFieldBegin()
13816 
      if ftype == TType.STOP:
13817 
        break
13818 
      if fid == 0:
3064 chandransh 13819 
        if ftype == TType.BOOL:
13820 
          self.success = iprot.readBool();
1408 ankur.sing 13821 
        else:
13822 
          iprot.skip(ftype)
3064 chandransh 13823 
      elif fid == 1:
13824 
        if ftype == TType.STRUCT:
13825 
          self.ex = TransactionServiceException()
13826 
          self.ex.read(iprot)
13827 
        else:
13828 
          iprot.skip(ftype)
1408 ankur.sing 13829 
      else:
13830 
        iprot.skip(ftype)
13831 
      iprot.readFieldEnd()
13832 
    iprot.readStructEnd()
13833 
 
13834 
  def write(self, oprot):
13835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13837 
      return
4910 phani.kuma 13838 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13839 
    if self.success is not None:
3064 chandransh 13840 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13841 
      oprot.writeBool(self.success)
1408 ankur.sing 13842 
      oprot.writeFieldEnd()
3431 rajveer 13843 
    if self.ex is not None:
3064 chandransh 13844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13845 
      self.ex.write(oprot)
13846 
      oprot.writeFieldEnd()
1408 ankur.sing 13847 
    oprot.writeFieldStop()
13848 
    oprot.writeStructEnd()
13849 
 
3431 rajveer 13850 
  def validate(self):
13851 
    return
13852 
 
13853 
 
1408 ankur.sing 13854 
  def __repr__(self):
13855 
    L = ['%s=%r' % (key, value)
13856 
      for key, value in self.__dict__.iteritems()]
13857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13858 
 
13859 
  def __eq__(self, other):
13860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13861 
 
13862 
  def __ne__(self, other):
13863 
    return not (self == other)
13864 
 
5676 rajveer 13865 
class markOrdersAsReturnedFromStore_args:
13866 
  """
13867 
  Attributes:
13868 
   - providerId
13869 
   - orderIds
5713 rajveer 13870 
   - awbs
5676 rajveer 13871 
  """
13872 
 
13873 
  thrift_spec = (
13874 
    None, # 0
13875 
    (1, TType.I64, 'providerId', None, None, ), # 1
13876 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13877 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13878 
  )
13879 
 
5713 rajveer 13880 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13881 
    self.providerId = providerId
13882 
    self.orderIds = orderIds
5713 rajveer 13883 
    self.awbs = awbs
5676 rajveer 13884 
 
13885 
  def read(self, iprot):
13886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13888 
      return
13889 
    iprot.readStructBegin()
13890 
    while True:
13891 
      (fname, ftype, fid) = iprot.readFieldBegin()
13892 
      if ftype == TType.STOP:
13893 
        break
13894 
      if fid == 1:
13895 
        if ftype == TType.I64:
13896 
          self.providerId = iprot.readI64();
13897 
        else:
13898 
          iprot.skip(ftype)
13899 
      elif fid == 2:
13900 
        if ftype == TType.LIST:
13901 
          self.orderIds = []
6188 rajveer 13902 
          (_etype291, _size288) = iprot.readListBegin()
13903 
          for _i292 in xrange(_size288):
13904 
            _elem293 = iprot.readI64();
13905 
            self.orderIds.append(_elem293)
5676 rajveer 13906 
          iprot.readListEnd()
13907 
        else:
13908 
          iprot.skip(ftype)
5713 rajveer 13909 
      elif fid == 3:
13910 
        if ftype == TType.LIST:
13911 
          self.awbs = []
6188 rajveer 13912 
          (_etype297, _size294) = iprot.readListBegin()
13913 
          for _i298 in xrange(_size294):
13914 
            _elem299 = iprot.readString();
13915 
            self.awbs.append(_elem299)
5713 rajveer 13916 
          iprot.readListEnd()
13917 
        else:
13918 
          iprot.skip(ftype)
5676 rajveer 13919 
      else:
13920 
        iprot.skip(ftype)
13921 
      iprot.readFieldEnd()
13922 
    iprot.readStructEnd()
13923 
 
13924 
  def write(self, oprot):
13925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13927 
      return
13928 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13929 
    if self.providerId is not None:
13930 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13931 
      oprot.writeI64(self.providerId)
13932 
      oprot.writeFieldEnd()
13933 
    if self.orderIds is not None:
13934 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13935 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13936 
      for iter300 in self.orderIds:
13937 
        oprot.writeI64(iter300)
5676 rajveer 13938 
      oprot.writeListEnd()
13939 
      oprot.writeFieldEnd()
5713 rajveer 13940 
    if self.awbs is not None:
13941 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13942 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 13943 
      for iter301 in self.awbs:
13944 
        oprot.writeString(iter301)
5713 rajveer 13945 
      oprot.writeListEnd()
13946 
      oprot.writeFieldEnd()
5676 rajveer 13947 
    oprot.writeFieldStop()
13948 
    oprot.writeStructEnd()
13949 
 
13950 
  def validate(self):
13951 
    return
13952 
 
13953 
 
13954 
  def __repr__(self):
13955 
    L = ['%s=%r' % (key, value)
13956 
      for key, value in self.__dict__.iteritems()]
13957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13958 
 
13959 
  def __eq__(self, other):
13960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13961 
 
13962 
  def __ne__(self, other):
13963 
    return not (self == other)
13964 
 
13965 
class markOrdersAsReturnedFromStore_result:
13966 
  """
13967 
  Attributes:
13968 
   - success
13969 
   - ex
13970 
  """
13971 
 
13972 
  thrift_spec = (
13973 
    (0, TType.BOOL, 'success', None, None, ), # 0
13974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13975 
  )
13976 
 
13977 
  def __init__(self, success=None, ex=None,):
13978 
    self.success = success
13979 
    self.ex = ex
13980 
 
13981 
  def read(self, iprot):
13982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13984 
      return
13985 
    iprot.readStructBegin()
13986 
    while True:
13987 
      (fname, ftype, fid) = iprot.readFieldBegin()
13988 
      if ftype == TType.STOP:
13989 
        break
13990 
      if fid == 0:
13991 
        if ftype == TType.BOOL:
13992 
          self.success = iprot.readBool();
13993 
        else:
13994 
          iprot.skip(ftype)
13995 
      elif fid == 1:
13996 
        if ftype == TType.STRUCT:
13997 
          self.ex = TransactionServiceException()
13998 
          self.ex.read(iprot)
13999 
        else:
14000 
          iprot.skip(ftype)
14001 
      else:
14002 
        iprot.skip(ftype)
14003 
      iprot.readFieldEnd()
14004 
    iprot.readStructEnd()
14005 
 
14006 
  def write(self, oprot):
14007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14009 
      return
14010 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14011 
    if self.success is not None:
14012 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14013 
      oprot.writeBool(self.success)
14014 
      oprot.writeFieldEnd()
14015 
    if self.ex is not None:
14016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14017 
      self.ex.write(oprot)
14018 
      oprot.writeFieldEnd()
14019 
    oprot.writeFieldStop()
14020 
    oprot.writeStructEnd()
14021 
 
14022 
  def validate(self):
14023 
    return
14024 
 
14025 
 
14026 
  def __repr__(self):
14027 
    L = ['%s=%r' % (key, value)
14028 
      for key, value in self.__dict__.iteritems()]
14029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14030 
 
14031 
  def __eq__(self, other):
14032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14033 
 
14034 
  def __ne__(self, other):
14035 
    return not (self == other)
14036 
 
4910 phani.kuma 14037 
class markOrdersAsPickedUp_args:
4410 rajveer 14038 
  """
14039 
  Attributes:
14040 
   - providerId
4910 phani.kuma 14041 
   - pickupDetails
4410 rajveer 14042 
  """
14043 
 
14044 
  thrift_spec = (
14045 
    None, # 0
4910 phani.kuma 14046 
    (1, TType.I64, 'providerId', None, None, ), # 1
14047 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14048 
  )
14049 
 
4910 phani.kuma 14050 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14051 
    self.providerId = providerId
4910 phani.kuma 14052 
    self.pickupDetails = pickupDetails
4410 rajveer 14053 
 
14054 
  def read(self, iprot):
14055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14057 
      return
14058 
    iprot.readStructBegin()
14059 
    while True:
14060 
      (fname, ftype, fid) = iprot.readFieldBegin()
14061 
      if ftype == TType.STOP:
14062 
        break
14063 
      if fid == 1:
14064 
        if ftype == TType.I64:
4910 phani.kuma 14065 
          self.providerId = iprot.readI64();
4410 rajveer 14066 
        else:
14067 
          iprot.skip(ftype)
14068 
      elif fid == 2:
4910 phani.kuma 14069 
        if ftype == TType.MAP:
14070 
          self.pickupDetails = {}
6188 rajveer 14071 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14072 
          for _i306 in xrange(_size302):
14073 
            _key307 = iprot.readString();
14074 
            _val308 = iprot.readString();
14075 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14076 
          iprot.readMapEnd()
4410 rajveer 14077 
        else:
14078 
          iprot.skip(ftype)
14079 
      else:
14080 
        iprot.skip(ftype)
14081 
      iprot.readFieldEnd()
14082 
    iprot.readStructEnd()
14083 
 
14084 
  def write(self, oprot):
14085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14087 
      return
4910 phani.kuma 14088 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14089 
    if self.providerId is not None:
4910 phani.kuma 14090 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14091 
      oprot.writeI64(self.providerId)
14092 
      oprot.writeFieldEnd()
4910 phani.kuma 14093 
    if self.pickupDetails is not None:
14094 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14095 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14096 
      for kiter309,viter310 in self.pickupDetails.items():
14097 
        oprot.writeString(kiter309)
14098 
        oprot.writeString(viter310)
4910 phani.kuma 14099 
      oprot.writeMapEnd()
4410 rajveer 14100 
      oprot.writeFieldEnd()
14101 
    oprot.writeFieldStop()
14102 
    oprot.writeStructEnd()
14103 
 
14104 
  def validate(self):
14105 
    return
14106 
 
14107 
 
14108 
  def __repr__(self):
14109 
    L = ['%s=%r' % (key, value)
14110 
      for key, value in self.__dict__.iteritems()]
14111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14112 
 
14113 
  def __eq__(self, other):
14114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14115 
 
14116 
  def __ne__(self, other):
14117 
    return not (self == other)
14118 
 
4910 phani.kuma 14119 
class markOrdersAsPickedUp_result:
4410 rajveer 14120 
  """
14121 
  Attributes:
14122 
   - ex
14123 
  """
14124 
 
14125 
  thrift_spec = (
4910 phani.kuma 14126 
    None, # 0
4410 rajveer 14127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14128 
  )
14129 
 
4910 phani.kuma 14130 
  def __init__(self, ex=None,):
4410 rajveer 14131 
    self.ex = ex
14132 
 
14133 
  def read(self, iprot):
14134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14136 
      return
14137 
    iprot.readStructBegin()
14138 
    while True:
14139 
      (fname, ftype, fid) = iprot.readFieldBegin()
14140 
      if ftype == TType.STOP:
14141 
        break
4910 phani.kuma 14142 
      if fid == 1:
4410 rajveer 14143 
        if ftype == TType.STRUCT:
14144 
          self.ex = TransactionServiceException()
14145 
          self.ex.read(iprot)
14146 
        else:
14147 
          iprot.skip(ftype)
14148 
      else:
14149 
        iprot.skip(ftype)
14150 
      iprot.readFieldEnd()
14151 
    iprot.readStructEnd()
14152 
 
14153 
  def write(self, oprot):
14154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14156 
      return
4910 phani.kuma 14157 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14158 
    if self.ex is not None:
14159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14160 
      self.ex.write(oprot)
14161 
      oprot.writeFieldEnd()
14162 
    oprot.writeFieldStop()
14163 
    oprot.writeStructEnd()
14164 
 
14165 
  def validate(self):
14166 
    return
14167 
 
14168 
 
14169 
  def __repr__(self):
14170 
    L = ['%s=%r' % (key, value)
14171 
      for key, value in self.__dict__.iteritems()]
14172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14173 
 
14174 
  def __eq__(self, other):
14175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14176 
 
14177 
  def __ne__(self, other):
14178 
    return not (self == other)
14179 
 
4910 phani.kuma 14180 
class getOrdersNotPickedUp_args:
304 ashish 14181 
  """
14182 
  Attributes:
3064 chandransh 14183 
   - providerId
304 ashish 14184 
  """
94 ashish 14185 
 
304 ashish 14186 
  thrift_spec = (
14187 
    None, # 0
3064 chandransh 14188 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14189 
  )
14190 
 
4910 phani.kuma 14191 
  def __init__(self, providerId=None,):
3064 chandransh 14192 
    self.providerId = providerId
304 ashish 14193 
 
14194 
  def read(self, iprot):
14195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14197 
      return
14198 
    iprot.readStructBegin()
14199 
    while True:
14200 
      (fname, ftype, fid) = iprot.readFieldBegin()
14201 
      if ftype == TType.STOP:
14202 
        break
14203 
      if fid == 1:
14204 
        if ftype == TType.I64:
3064 chandransh 14205 
          self.providerId = iprot.readI64();
304 ashish 14206 
        else:
14207 
          iprot.skip(ftype)
14208 
      else:
14209 
        iprot.skip(ftype)
14210 
      iprot.readFieldEnd()
14211 
    iprot.readStructEnd()
14212 
 
14213 
  def write(self, oprot):
14214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14216 
      return
4910 phani.kuma 14217 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14218 
    if self.providerId is not None:
3064 chandransh 14219 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14220 
      oprot.writeI64(self.providerId)
304 ashish 14221 
      oprot.writeFieldEnd()
14222 
    oprot.writeFieldStop()
14223 
    oprot.writeStructEnd()
14224 
 
3431 rajveer 14225 
  def validate(self):
14226 
    return
14227 
 
14228 
 
304 ashish 14229 
  def __repr__(self):
14230 
    L = ['%s=%r' % (key, value)
14231 
      for key, value in self.__dict__.iteritems()]
14232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14233 
 
14234 
  def __eq__(self, other):
14235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14236 
 
14237 
  def __ne__(self, other):
14238 
    return not (self == other)
14239 
 
4910 phani.kuma 14240 
class getOrdersNotPickedUp_result:
304 ashish 14241 
  """
14242 
  Attributes:
14243 
   - success
14244 
  """
14245 
 
14246 
  thrift_spec = (
3064 chandransh 14247 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14248 
  )
14249 
 
4910 phani.kuma 14250 
  def __init__(self, success=None,):
304 ashish 14251 
    self.success = success
14252 
 
14253 
  def read(self, iprot):
14254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14256 
      return
14257 
    iprot.readStructBegin()
14258 
    while True:
14259 
      (fname, ftype, fid) = iprot.readFieldBegin()
14260 
      if ftype == TType.STOP:
14261 
        break
14262 
      if fid == 0:
14263 
        if ftype == TType.LIST:
14264 
          self.success = []
6188 rajveer 14265 
          (_etype314, _size311) = iprot.readListBegin()
14266 
          for _i315 in xrange(_size311):
14267 
            _elem316 = Order()
14268 
            _elem316.read(iprot)
14269 
            self.success.append(_elem316)
304 ashish 14270 
          iprot.readListEnd()
14271 
        else:
14272 
          iprot.skip(ftype)
14273 
      else:
14274 
        iprot.skip(ftype)
14275 
      iprot.readFieldEnd()
14276 
    iprot.readStructEnd()
14277 
 
14278 
  def write(self, oprot):
14279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14281 
      return
4910 phani.kuma 14282 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14283 
    if self.success is not None:
304 ashish 14284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14286 
      for iter317 in self.success:
14287 
        iter317.write(oprot)
304 ashish 14288 
      oprot.writeListEnd()
14289 
      oprot.writeFieldEnd()
14290 
    oprot.writeFieldStop()
14291 
    oprot.writeStructEnd()
14292 
 
3431 rajveer 14293 
  def validate(self):
14294 
    return
14295 
 
14296 
 
304 ashish 14297 
  def __repr__(self):
14298 
    L = ['%s=%r' % (key, value)
14299 
      for key, value in self.__dict__.iteritems()]
14300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14301 
 
14302 
  def __eq__(self, other):
14303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14304 
 
14305 
  def __ne__(self, other):
14306 
    return not (self == other)
14307 
 
3064 chandransh 14308 
class markOrdersAsDelivered_args:
304 ashish 14309 
  """
14310 
  Attributes:
3064 chandransh 14311 
   - providerId
14312 
   - deliveredOrders
304 ashish 14313 
  """
14314 
 
14315 
  thrift_spec = (
14316 
    None, # 0
3064 chandransh 14317 
    (1, TType.I64, 'providerId', None, None, ), # 1
14318 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14319 
  )
14320 
 
3064 chandransh 14321 
  def __init__(self, providerId=None, deliveredOrders=None,):
14322 
    self.providerId = providerId
14323 
    self.deliveredOrders = deliveredOrders
304 ashish 14324 
 
14325 
  def read(self, iprot):
14326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14328 
      return
14329 
    iprot.readStructBegin()
14330 
    while True:
14331 
      (fname, ftype, fid) = iprot.readFieldBegin()
14332 
      if ftype == TType.STOP:
14333 
        break
14334 
      if fid == 1:
14335 
        if ftype == TType.I64:
3064 chandransh 14336 
          self.providerId = iprot.readI64();
304 ashish 14337 
        else:
14338 
          iprot.skip(ftype)
14339 
      elif fid == 2:
3064 chandransh 14340 
        if ftype == TType.MAP:
14341 
          self.deliveredOrders = {}
6188 rajveer 14342 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14343 
          for _i322 in xrange(_size318):
14344 
            _key323 = iprot.readString();
14345 
            _val324 = iprot.readString();
14346 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14347 
          iprot.readMapEnd()
304 ashish 14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      else:
14351 
        iprot.skip(ftype)
14352 
      iprot.readFieldEnd()
14353 
    iprot.readStructEnd()
14354 
 
14355 
  def write(self, oprot):
14356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14358 
      return
3064 chandransh 14359 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14360 
    if self.providerId is not None:
3064 chandransh 14361 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14362 
      oprot.writeI64(self.providerId)
304 ashish 14363 
      oprot.writeFieldEnd()
3431 rajveer 14364 
    if self.deliveredOrders is not None:
3064 chandransh 14365 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14366 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14367 
      for kiter325,viter326 in self.deliveredOrders.items():
14368 
        oprot.writeString(kiter325)
14369 
        oprot.writeString(viter326)
3064 chandransh 14370 
      oprot.writeMapEnd()
304 ashish 14371 
      oprot.writeFieldEnd()
14372 
    oprot.writeFieldStop()
14373 
    oprot.writeStructEnd()
14374 
 
3431 rajveer 14375 
  def validate(self):
14376 
    return
14377 
 
14378 
 
304 ashish 14379 
  def __repr__(self):
14380 
    L = ['%s=%r' % (key, value)
14381 
      for key, value in self.__dict__.iteritems()]
14382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14383 
 
14384 
  def __eq__(self, other):
14385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14386 
 
14387 
  def __ne__(self, other):
14388 
    return not (self == other)
14389 
 
3064 chandransh 14390 
class markOrdersAsDelivered_result:
14391 
  """
14392 
  Attributes:
14393 
   - ex
14394 
  """
304 ashish 14395 
 
14396 
  thrift_spec = (
3064 chandransh 14397 
    None, # 0
14398 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14399 
  )
14400 
 
3064 chandransh 14401 
  def __init__(self, ex=None,):
14402 
    self.ex = ex
304 ashish 14403 
 
1596 ankur.sing 14404 
  def read(self, iprot):
14405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14407 
      return
14408 
    iprot.readStructBegin()
14409 
    while True:
14410 
      (fname, ftype, fid) = iprot.readFieldBegin()
14411 
      if ftype == TType.STOP:
14412 
        break
3064 chandransh 14413 
      if fid == 1:
14414 
        if ftype == TType.STRUCT:
14415 
          self.ex = TransactionServiceException()
14416 
          self.ex.read(iprot)
14417 
        else:
14418 
          iprot.skip(ftype)
1596 ankur.sing 14419 
      else:
14420 
        iprot.skip(ftype)
14421 
      iprot.readFieldEnd()
14422 
    iprot.readStructEnd()
14423 
 
14424 
  def write(self, oprot):
14425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14427 
      return
3064 chandransh 14428 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14429 
    if self.ex is not None:
3064 chandransh 14430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14431 
      self.ex.write(oprot)
14432 
      oprot.writeFieldEnd()
1596 ankur.sing 14433 
    oprot.writeFieldStop()
14434 
    oprot.writeStructEnd()
14435 
 
3431 rajveer 14436 
  def validate(self):
14437 
    return
14438 
 
14439 
 
1596 ankur.sing 14440 
  def __repr__(self):
14441 
    L = ['%s=%r' % (key, value)
14442 
      for key, value in self.__dict__.iteritems()]
14443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14444 
 
14445 
  def __eq__(self, other):
14446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14447 
 
14448 
  def __ne__(self, other):
14449 
    return not (self == other)
14450 
 
4910 phani.kuma 14451 
class markAsRTOrders_args:
1596 ankur.sing 14452 
  """
14453 
  Attributes:
3064 chandransh 14454 
   - providerId
14455 
   - returnedOrders
1596 ankur.sing 14456 
  """
14457 
 
14458 
  thrift_spec = (
3064 chandransh 14459 
    None, # 0
14460 
    (1, TType.I64, 'providerId', None, None, ), # 1
14461 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14462 
  )
14463 
 
3064 chandransh 14464 
  def __init__(self, providerId=None, returnedOrders=None,):
14465 
    self.providerId = providerId
14466 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14467 
 
14468 
  def read(self, iprot):
14469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14471 
      return
14472 
    iprot.readStructBegin()
14473 
    while True:
14474 
      (fname, ftype, fid) = iprot.readFieldBegin()
14475 
      if ftype == TType.STOP:
14476 
        break
3064 chandransh 14477 
      if fid == 1:
1596 ankur.sing 14478 
        if ftype == TType.I64:
3064 chandransh 14479 
          self.providerId = iprot.readI64();
1596 ankur.sing 14480 
        else:
14481 
          iprot.skip(ftype)
3064 chandransh 14482 
      elif fid == 2:
14483 
        if ftype == TType.MAP:
14484 
          self.returnedOrders = {}
6188 rajveer 14485 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14486 
          for _i331 in xrange(_size327):
14487 
            _key332 = iprot.readString();
14488 
            _val333 = iprot.readString();
14489 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14490 
          iprot.readMapEnd()
14491 
        else:
14492 
          iprot.skip(ftype)
1596 ankur.sing 14493 
      else:
14494 
        iprot.skip(ftype)
14495 
      iprot.readFieldEnd()
14496 
    iprot.readStructEnd()
14497 
 
14498 
  def write(self, oprot):
14499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14501 
      return
4910 phani.kuma 14502 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14503 
    if self.providerId is not None:
3064 chandransh 14504 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14505 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14506 
      oprot.writeFieldEnd()
3431 rajveer 14507 
    if self.returnedOrders is not None:
3064 chandransh 14508 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14509 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14510 
      for kiter334,viter335 in self.returnedOrders.items():
14511 
        oprot.writeString(kiter334)
14512 
        oprot.writeString(viter335)
3064 chandransh 14513 
      oprot.writeMapEnd()
14514 
      oprot.writeFieldEnd()
1596 ankur.sing 14515 
    oprot.writeFieldStop()
14516 
    oprot.writeStructEnd()
14517 
 
3431 rajveer 14518 
  def validate(self):
14519 
    return
14520 
 
14521 
 
1596 ankur.sing 14522 
  def __repr__(self):
14523 
    L = ['%s=%r' % (key, value)
14524 
      for key, value in self.__dict__.iteritems()]
14525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14526 
 
14527 
  def __eq__(self, other):
14528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14529 
 
14530 
  def __ne__(self, other):
14531 
    return not (self == other)
14532 
 
4910 phani.kuma 14533 
class markAsRTOrders_result:
3064 chandransh 14534 
  """
14535 
  Attributes:
14536 
   - ex
14537 
  """
1596 ankur.sing 14538 
 
1627 ankur.sing 14539 
  thrift_spec = (
3064 chandransh 14540 
    None, # 0
14541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14542 
  )
14543 
 
3064 chandransh 14544 
  def __init__(self, ex=None,):
14545 
    self.ex = ex
14546 
 
1627 ankur.sing 14547 
  def read(self, iprot):
14548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14550 
      return
14551 
    iprot.readStructBegin()
14552 
    while True:
14553 
      (fname, ftype, fid) = iprot.readFieldBegin()
14554 
      if ftype == TType.STOP:
14555 
        break
3064 chandransh 14556 
      if fid == 1:
14557 
        if ftype == TType.STRUCT:
14558 
          self.ex = TransactionServiceException()
14559 
          self.ex.read(iprot)
14560 
        else:
14561 
          iprot.skip(ftype)
1627 ankur.sing 14562 
      else:
14563 
        iprot.skip(ftype)
14564 
      iprot.readFieldEnd()
14565 
    iprot.readStructEnd()
14566 
 
14567 
  def write(self, oprot):
14568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14570 
      return
4910 phani.kuma 14571 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14572 
    if self.ex is not None:
3064 chandransh 14573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14574 
      self.ex.write(oprot)
14575 
      oprot.writeFieldEnd()
1627 ankur.sing 14576 
    oprot.writeFieldStop()
14577 
    oprot.writeStructEnd()
14578 
 
3431 rajveer 14579 
  def validate(self):
14580 
    return
14581 
 
14582 
 
1627 ankur.sing 14583 
  def __repr__(self):
14584 
    L = ['%s=%r' % (key, value)
14585 
      for key, value in self.__dict__.iteritems()]
14586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14587 
 
14588 
  def __eq__(self, other):
14589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14590 
 
14591 
  def __ne__(self, other):
14592 
    return not (self == other)
14593 
 
4910 phani.kuma 14594 
class getRTOrders_args:
14595 
  """
14596 
  Attributes:
14597 
   - providerId
14598 
  """
14599 
 
14600 
  thrift_spec = (
14601 
    None, # 0
14602 
    (1, TType.I64, 'providerId', None, None, ), # 1
14603 
  )
14604 
 
14605 
  def __init__(self, providerId=None,):
14606 
    self.providerId = providerId
14607 
 
14608 
  def read(self, iprot):
14609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14611 
      return
14612 
    iprot.readStructBegin()
14613 
    while True:
14614 
      (fname, ftype, fid) = iprot.readFieldBegin()
14615 
      if ftype == TType.STOP:
14616 
        break
14617 
      if fid == 1:
14618 
        if ftype == TType.I64:
14619 
          self.providerId = iprot.readI64();
14620 
        else:
14621 
          iprot.skip(ftype)
14622 
      else:
14623 
        iprot.skip(ftype)
14624 
      iprot.readFieldEnd()
14625 
    iprot.readStructEnd()
14626 
 
14627 
  def write(self, oprot):
14628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14630 
      return
14631 
    oprot.writeStructBegin('getRTOrders_args')
14632 
    if self.providerId is not None:
14633 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14634 
      oprot.writeI64(self.providerId)
14635 
      oprot.writeFieldEnd()
14636 
    oprot.writeFieldStop()
14637 
    oprot.writeStructEnd()
14638 
 
14639 
  def validate(self):
14640 
    return
14641 
 
14642 
 
14643 
  def __repr__(self):
14644 
    L = ['%s=%r' % (key, value)
14645 
      for key, value in self.__dict__.iteritems()]
14646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14647 
 
14648 
  def __eq__(self, other):
14649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14650 
 
14651 
  def __ne__(self, other):
14652 
    return not (self == other)
14653 
 
14654 
class getRTOrders_result:
14655 
  """
14656 
  Attributes:
14657 
   - success
14658 
  """
14659 
 
14660 
  thrift_spec = (
14661 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14662 
  )
14663 
 
14664 
  def __init__(self, success=None,):
14665 
    self.success = success
14666 
 
14667 
  def read(self, iprot):
14668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14670 
      return
14671 
    iprot.readStructBegin()
14672 
    while True:
14673 
      (fname, ftype, fid) = iprot.readFieldBegin()
14674 
      if ftype == TType.STOP:
14675 
        break
14676 
      if fid == 0:
14677 
        if ftype == TType.LIST:
14678 
          self.success = []
6188 rajveer 14679 
          (_etype339, _size336) = iprot.readListBegin()
14680 
          for _i340 in xrange(_size336):
14681 
            _elem341 = Order()
14682 
            _elem341.read(iprot)
14683 
            self.success.append(_elem341)
4910 phani.kuma 14684 
          iprot.readListEnd()
14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      else:
14688 
        iprot.skip(ftype)
14689 
      iprot.readFieldEnd()
14690 
    iprot.readStructEnd()
14691 
 
14692 
  def write(self, oprot):
14693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14695 
      return
14696 
    oprot.writeStructBegin('getRTOrders_result')
14697 
    if self.success is not None:
14698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14700 
      for iter342 in self.success:
14701 
        iter342.write(oprot)
4910 phani.kuma 14702 
      oprot.writeListEnd()
14703 
      oprot.writeFieldEnd()
14704 
    oprot.writeFieldStop()
14705 
    oprot.writeStructEnd()
14706 
 
14707 
  def validate(self):
14708 
    return
14709 
 
14710 
 
14711 
  def __repr__(self):
14712 
    L = ['%s=%r' % (key, value)
14713 
      for key, value in self.__dict__.iteritems()]
14714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14715 
 
14716 
  def __eq__(self, other):
14717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14718 
 
14719 
  def __ne__(self, other):
14720 
    return not (self == other)
14721 
 
3064 chandransh 14722 
class updateNonDeliveryReason_args:
1627 ankur.sing 14723 
  """
14724 
  Attributes:
3064 chandransh 14725 
   - providerId
14726 
   - undeliveredOrders
1627 ankur.sing 14727 
  """
14728 
 
14729 
  thrift_spec = (
3064 chandransh 14730 
    None, # 0
14731 
    (1, TType.I64, 'providerId', None, None, ), # 1
14732 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14733 
  )
14734 
 
3064 chandransh 14735 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14736 
    self.providerId = providerId
14737 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14738 
 
14739 
  def read(self, iprot):
14740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14742 
      return
14743 
    iprot.readStructBegin()
14744 
    while True:
14745 
      (fname, ftype, fid) = iprot.readFieldBegin()
14746 
      if ftype == TType.STOP:
14747 
        break
3064 chandransh 14748 
      if fid == 1:
1627 ankur.sing 14749 
        if ftype == TType.I64:
3064 chandransh 14750 
          self.providerId = iprot.readI64();
1627 ankur.sing 14751 
        else:
14752 
          iprot.skip(ftype)
3064 chandransh 14753 
      elif fid == 2:
14754 
        if ftype == TType.MAP:
14755 
          self.undeliveredOrders = {}
6188 rajveer 14756 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14757 
          for _i347 in xrange(_size343):
14758 
            _key348 = iprot.readString();
14759 
            _val349 = iprot.readString();
14760 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14761 
          iprot.readMapEnd()
14762 
        else:
14763 
          iprot.skip(ftype)
1627 ankur.sing 14764 
      else:
14765 
        iprot.skip(ftype)
14766 
      iprot.readFieldEnd()
14767 
    iprot.readStructEnd()
14768 
 
14769 
  def write(self, oprot):
14770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14772 
      return
3064 chandransh 14773 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14774 
    if self.providerId is not None:
3064 chandransh 14775 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14776 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14777 
      oprot.writeFieldEnd()
3431 rajveer 14778 
    if self.undeliveredOrders is not None:
3064 chandransh 14779 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14780 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14781 
      for kiter350,viter351 in self.undeliveredOrders.items():
14782 
        oprot.writeString(kiter350)
14783 
        oprot.writeString(viter351)
3064 chandransh 14784 
      oprot.writeMapEnd()
14785 
      oprot.writeFieldEnd()
1627 ankur.sing 14786 
    oprot.writeFieldStop()
14787 
    oprot.writeStructEnd()
14788 
 
3431 rajveer 14789 
  def validate(self):
14790 
    return
14791 
 
14792 
 
1627 ankur.sing 14793 
  def __repr__(self):
14794 
    L = ['%s=%r' % (key, value)
14795 
      for key, value in self.__dict__.iteritems()]
14796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14797 
 
14798 
  def __eq__(self, other):
14799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14800 
 
14801 
  def __ne__(self, other):
14802 
    return not (self == other)
14803 
 
3064 chandransh 14804 
class updateNonDeliveryReason_result:
1627 ankur.sing 14805 
  """
14806 
  Attributes:
3064 chandransh 14807 
   - ex
1627 ankur.sing 14808 
  """
14809 
 
14810 
  thrift_spec = (
4910 phani.kuma 14811 
    None, # 0
3064 chandransh 14812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14813 
  )
14814 
 
4910 phani.kuma 14815 
  def __init__(self, ex=None,):
3064 chandransh 14816 
    self.ex = ex
1627 ankur.sing 14817 
 
14818 
  def read(self, iprot):
14819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14821 
      return
14822 
    iprot.readStructBegin()
14823 
    while True:
14824 
      (fname, ftype, fid) = iprot.readFieldBegin()
14825 
      if ftype == TType.STOP:
14826 
        break
4910 phani.kuma 14827 
      if fid == 1:
14828 
        if ftype == TType.STRUCT:
14829 
          self.ex = TransactionServiceException()
14830 
          self.ex.read(iprot)
14831 
        else:
14832 
          iprot.skip(ftype)
14833 
      else:
14834 
        iprot.skip(ftype)
14835 
      iprot.readFieldEnd()
14836 
    iprot.readStructEnd()
14837 
 
14838 
  def write(self, oprot):
14839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14841 
      return
14842 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14843 
    if self.ex is not None:
14844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14845 
      self.ex.write(oprot)
14846 
      oprot.writeFieldEnd()
14847 
    oprot.writeFieldStop()
14848 
    oprot.writeStructEnd()
14849 
 
14850 
  def validate(self):
14851 
    return
14852 
 
14853 
 
14854 
  def __repr__(self):
14855 
    L = ['%s=%r' % (key, value)
14856 
      for key, value in self.__dict__.iteritems()]
14857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14858 
 
14859 
  def __eq__(self, other):
14860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14861 
 
14862 
  def __ne__(self, other):
14863 
    return not (self == other)
14864 
 
14865 
class getNonDeliveredOrdersbyCourier_args:
14866 
  """
14867 
  Attributes:
14868 
   - providerId
14869 
  """
14870 
 
14871 
  thrift_spec = (
14872 
    None, # 0
14873 
    (1, TType.I64, 'providerId', None, None, ), # 1
14874 
  )
14875 
 
14876 
  def __init__(self, providerId=None,):
14877 
    self.providerId = providerId
14878 
 
14879 
  def read(self, iprot):
14880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14882 
      return
14883 
    iprot.readStructBegin()
14884 
    while True:
14885 
      (fname, ftype, fid) = iprot.readFieldBegin()
14886 
      if ftype == TType.STOP:
14887 
        break
14888 
      if fid == 1:
14889 
        if ftype == TType.I64:
14890 
          self.providerId = iprot.readI64();
14891 
        else:
14892 
          iprot.skip(ftype)
14893 
      else:
14894 
        iprot.skip(ftype)
14895 
      iprot.readFieldEnd()
14896 
    iprot.readStructEnd()
14897 
 
14898 
  def write(self, oprot):
14899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14901 
      return
14902 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14903 
    if self.providerId is not None:
14904 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14905 
      oprot.writeI64(self.providerId)
14906 
      oprot.writeFieldEnd()
14907 
    oprot.writeFieldStop()
14908 
    oprot.writeStructEnd()
14909 
 
14910 
  def validate(self):
14911 
    return
14912 
 
14913 
 
14914 
  def __repr__(self):
14915 
    L = ['%s=%r' % (key, value)
14916 
      for key, value in self.__dict__.iteritems()]
14917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14918 
 
14919 
  def __eq__(self, other):
14920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14921 
 
14922 
  def __ne__(self, other):
14923 
    return not (self == other)
14924 
 
14925 
class getNonDeliveredOrdersbyCourier_result:
14926 
  """
14927 
  Attributes:
14928 
   - success
14929 
  """
14930 
 
14931 
  thrift_spec = (
14932 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14933 
  )
14934 
 
14935 
  def __init__(self, success=None,):
14936 
    self.success = success
14937 
 
14938 
  def read(self, iprot):
14939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14941 
      return
14942 
    iprot.readStructBegin()
14943 
    while True:
14944 
      (fname, ftype, fid) = iprot.readFieldBegin()
14945 
      if ftype == TType.STOP:
14946 
        break
4581 phani.kuma 14947 
      if fid == 0:
14948 
        if ftype == TType.LIST:
14949 
          self.success = []
6188 rajveer 14950 
          (_etype355, _size352) = iprot.readListBegin()
14951 
          for _i356 in xrange(_size352):
14952 
            _elem357 = Order()
14953 
            _elem357.read(iprot)
14954 
            self.success.append(_elem357)
4581 phani.kuma 14955 
          iprot.readListEnd()
14956 
        else:
14957 
          iprot.skip(ftype)
4910 phani.kuma 14958 
      else:
14959 
        iprot.skip(ftype)
14960 
      iprot.readFieldEnd()
14961 
    iprot.readStructEnd()
14962 
 
14963 
  def write(self, oprot):
14964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14966 
      return
14967 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14968 
    if self.success is not None:
14969 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14970 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14971 
      for iter358 in self.success:
14972 
        iter358.write(oprot)
4910 phani.kuma 14973 
      oprot.writeListEnd()
14974 
      oprot.writeFieldEnd()
14975 
    oprot.writeFieldStop()
14976 
    oprot.writeStructEnd()
14977 
 
14978 
  def validate(self):
14979 
    return
14980 
 
14981 
 
14982 
  def __repr__(self):
14983 
    L = ['%s=%r' % (key, value)
14984 
      for key, value in self.__dict__.iteritems()]
14985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14986 
 
14987 
  def __eq__(self, other):
14988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14989 
 
14990 
  def __ne__(self, other):
14991 
    return not (self == other)
14992 
 
14993 
class markOrdersAsLocalConnected_args:
14994 
  """
14995 
  Attributes:
14996 
   - providerId
14997 
   - local_connected_orders
14998 
  """
14999 
 
15000 
  thrift_spec = (
15001 
    None, # 0
15002 
    (1, TType.I64, 'providerId', None, None, ), # 1
15003 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15004 
  )
15005 
 
15006 
  def __init__(self, providerId=None, local_connected_orders=None,):
15007 
    self.providerId = providerId
15008 
    self.local_connected_orders = local_connected_orders
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 1:
15020 
        if ftype == TType.I64:
15021 
          self.providerId = iprot.readI64();
15022 
        else:
15023 
          iprot.skip(ftype)
15024 
      elif fid == 2:
15025 
        if ftype == TType.MAP:
15026 
          self.local_connected_orders = {}
6188 rajveer 15027 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15028 
          for _i363 in xrange(_size359):
15029 
            _key364 = iprot.readString();
15030 
            _val365 = iprot.readString();
15031 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15032 
          iprot.readMapEnd()
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      else:
15036 
        iprot.skip(ftype)
15037 
      iprot.readFieldEnd()
15038 
    iprot.readStructEnd()
15039 
 
15040 
  def write(self, oprot):
15041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15043 
      return
15044 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15045 
    if self.providerId is not None:
15046 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15047 
      oprot.writeI64(self.providerId)
15048 
      oprot.writeFieldEnd()
15049 
    if self.local_connected_orders is not None:
15050 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15051 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15052 
      for kiter366,viter367 in self.local_connected_orders.items():
15053 
        oprot.writeString(kiter366)
15054 
        oprot.writeString(viter367)
4910 phani.kuma 15055 
      oprot.writeMapEnd()
15056 
      oprot.writeFieldEnd()
15057 
    oprot.writeFieldStop()
15058 
    oprot.writeStructEnd()
15059 
 
15060 
  def validate(self):
15061 
    return
15062 
 
15063 
 
15064 
  def __repr__(self):
15065 
    L = ['%s=%r' % (key, value)
15066 
      for key, value in self.__dict__.iteritems()]
15067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15068 
 
15069 
  def __eq__(self, other):
15070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15071 
 
15072 
  def __ne__(self, other):
15073 
    return not (self == other)
15074 
 
15075 
class markOrdersAsLocalConnected_result:
15076 
  """
15077 
  Attributes:
15078 
   - ex
15079 
  """
15080 
 
15081 
  thrift_spec = (
15082 
    None, # 0
15083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15084 
  )
15085 
 
15086 
  def __init__(self, ex=None,):
15087 
    self.ex = ex
15088 
 
15089 
  def read(self, iprot):
15090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15092 
      return
15093 
    iprot.readStructBegin()
15094 
    while True:
15095 
      (fname, ftype, fid) = iprot.readFieldBegin()
15096 
      if ftype == TType.STOP:
15097 
        break
15098 
      if fid == 1:
3064 chandransh 15099 
        if ftype == TType.STRUCT:
15100 
          self.ex = TransactionServiceException()
15101 
          self.ex.read(iprot)
1627 ankur.sing 15102 
        else:
15103 
          iprot.skip(ftype)
15104 
      else:
15105 
        iprot.skip(ftype)
15106 
      iprot.readFieldEnd()
15107 
    iprot.readStructEnd()
15108 
 
15109 
  def write(self, oprot):
15110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15112 
      return
4910 phani.kuma 15113 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15114 
    if self.ex is not None:
15115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15116 
      self.ex.write(oprot)
15117 
      oprot.writeFieldEnd()
15118 
    oprot.writeFieldStop()
15119 
    oprot.writeStructEnd()
15120 
 
15121 
  def validate(self):
15122 
    return
15123 
 
15124 
 
15125 
  def __repr__(self):
15126 
    L = ['%s=%r' % (key, value)
15127 
      for key, value in self.__dict__.iteritems()]
15128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15129 
 
15130 
  def __eq__(self, other):
15131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15132 
 
15133 
  def __ne__(self, other):
15134 
    return not (self == other)
15135 
 
15136 
class getOrdersNotLocalConnected_args:
15137 
  """
15138 
  Attributes:
15139 
   - providerId
15140 
  """
15141 
 
15142 
  thrift_spec = (
15143 
    None, # 0
15144 
    (1, TType.I64, 'providerId', None, None, ), # 1
15145 
  )
15146 
 
15147 
  def __init__(self, providerId=None,):
15148 
    self.providerId = providerId
15149 
 
15150 
  def read(self, iprot):
15151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15153 
      return
15154 
    iprot.readStructBegin()
15155 
    while True:
15156 
      (fname, ftype, fid) = iprot.readFieldBegin()
15157 
      if ftype == TType.STOP:
15158 
        break
15159 
      if fid == 1:
15160 
        if ftype == TType.I64:
15161 
          self.providerId = iprot.readI64();
15162 
        else:
15163 
          iprot.skip(ftype)
15164 
      else:
15165 
        iprot.skip(ftype)
15166 
      iprot.readFieldEnd()
15167 
    iprot.readStructEnd()
15168 
 
15169 
  def write(self, oprot):
15170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15172 
      return
15173 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15174 
    if self.providerId is not None:
15175 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15176 
      oprot.writeI64(self.providerId)
15177 
      oprot.writeFieldEnd()
15178 
    oprot.writeFieldStop()
15179 
    oprot.writeStructEnd()
15180 
 
15181 
  def validate(self):
15182 
    return
15183 
 
15184 
 
15185 
  def __repr__(self):
15186 
    L = ['%s=%r' % (key, value)
15187 
      for key, value in self.__dict__.iteritems()]
15188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15189 
 
15190 
  def __eq__(self, other):
15191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15192 
 
15193 
  def __ne__(self, other):
15194 
    return not (self == other)
15195 
 
15196 
class getOrdersNotLocalConnected_result:
15197 
  """
15198 
  Attributes:
15199 
   - success
15200 
  """
15201 
 
15202 
  thrift_spec = (
15203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15204 
  )
15205 
 
15206 
  def __init__(self, success=None,):
15207 
    self.success = success
15208 
 
15209 
  def read(self, iprot):
15210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15212 
      return
15213 
    iprot.readStructBegin()
15214 
    while True:
15215 
      (fname, ftype, fid) = iprot.readFieldBegin()
15216 
      if ftype == TType.STOP:
15217 
        break
15218 
      if fid == 0:
15219 
        if ftype == TType.LIST:
15220 
          self.success = []
6188 rajveer 15221 
          (_etype371, _size368) = iprot.readListBegin()
15222 
          for _i372 in xrange(_size368):
15223 
            _elem373 = Order()
15224 
            _elem373.read(iprot)
15225 
            self.success.append(_elem373)
4910 phani.kuma 15226 
          iprot.readListEnd()
15227 
        else:
15228 
          iprot.skip(ftype)
15229 
      else:
15230 
        iprot.skip(ftype)
15231 
      iprot.readFieldEnd()
15232 
    iprot.readStructEnd()
15233 
 
15234 
  def write(self, oprot):
15235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15237 
      return
15238 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15239 
    if self.success is not None:
15240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15241 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15242 
      for iter374 in self.success:
15243 
        iter374.write(oprot)
4581 phani.kuma 15244 
      oprot.writeListEnd()
15245 
      oprot.writeFieldEnd()
4910 phani.kuma 15246 
    oprot.writeFieldStop()
15247 
    oprot.writeStructEnd()
15248 
 
15249 
  def validate(self):
15250 
    return
15251 
 
15252 
 
15253 
  def __repr__(self):
15254 
    L = ['%s=%r' % (key, value)
15255 
      for key, value in self.__dict__.iteritems()]
15256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15257 
 
15258 
  def __eq__(self, other):
15259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15260 
 
15261 
  def __ne__(self, other):
15262 
    return not (self == other)
15263 
 
15264 
class markOrdersAsDestinationCityReached_args:
15265 
  """
15266 
  Attributes:
15267 
   - providerId
15268 
   - destination_city_reached_orders
15269 
  """
15270 
 
15271 
  thrift_spec = (
15272 
    None, # 0
15273 
    (1, TType.I64, 'providerId', None, None, ), # 1
15274 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15275 
  )
15276 
 
15277 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15278 
    self.providerId = providerId
15279 
    self.destination_city_reached_orders = destination_city_reached_orders
15280 
 
15281 
  def read(self, iprot):
15282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15284 
      return
15285 
    iprot.readStructBegin()
15286 
    while True:
15287 
      (fname, ftype, fid) = iprot.readFieldBegin()
15288 
      if ftype == TType.STOP:
15289 
        break
15290 
      if fid == 1:
15291 
        if ftype == TType.I64:
15292 
          self.providerId = iprot.readI64();
15293 
        else:
15294 
          iprot.skip(ftype)
15295 
      elif fid == 2:
15296 
        if ftype == TType.MAP:
15297 
          self.destination_city_reached_orders = {}
6188 rajveer 15298 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15299 
          for _i379 in xrange(_size375):
15300 
            _key380 = iprot.readString();
15301 
            _val381 = iprot.readString();
15302 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15303 
          iprot.readMapEnd()
15304 
        else:
15305 
          iprot.skip(ftype)
15306 
      else:
15307 
        iprot.skip(ftype)
15308 
      iprot.readFieldEnd()
15309 
    iprot.readStructEnd()
15310 
 
15311 
  def write(self, oprot):
15312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15314 
      return
15315 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15316 
    if self.providerId is not None:
15317 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15318 
      oprot.writeI64(self.providerId)
15319 
      oprot.writeFieldEnd()
15320 
    if self.destination_city_reached_orders is not None:
15321 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15322 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15323 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15324 
        oprot.writeString(kiter382)
15325 
        oprot.writeString(viter383)
4910 phani.kuma 15326 
      oprot.writeMapEnd()
15327 
      oprot.writeFieldEnd()
15328 
    oprot.writeFieldStop()
15329 
    oprot.writeStructEnd()
15330 
 
15331 
  def validate(self):
15332 
    return
15333 
 
15334 
 
15335 
  def __repr__(self):
15336 
    L = ['%s=%r' % (key, value)
15337 
      for key, value in self.__dict__.iteritems()]
15338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15339 
 
15340 
  def __eq__(self, other):
15341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15342 
 
15343 
  def __ne__(self, other):
15344 
    return not (self == other)
15345 
 
15346 
class markOrdersAsDestinationCityReached_result:
15347 
  """
15348 
  Attributes:
15349 
   - ex
15350 
  """
15351 
 
15352 
  thrift_spec = (
15353 
    None, # 0
15354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15355 
  )
15356 
 
15357 
  def __init__(self, ex=None,):
15358 
    self.ex = ex
15359 
 
15360 
  def read(self, iprot):
15361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15363 
      return
15364 
    iprot.readStructBegin()
15365 
    while True:
15366 
      (fname, ftype, fid) = iprot.readFieldBegin()
15367 
      if ftype == TType.STOP:
15368 
        break
15369 
      if fid == 1:
15370 
        if ftype == TType.STRUCT:
15371 
          self.ex = TransactionServiceException()
15372 
          self.ex.read(iprot)
15373 
        else:
15374 
          iprot.skip(ftype)
15375 
      else:
15376 
        iprot.skip(ftype)
15377 
      iprot.readFieldEnd()
15378 
    iprot.readStructEnd()
15379 
 
15380 
  def write(self, oprot):
15381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15383 
      return
15384 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15385 
    if self.ex is not None:
3064 chandransh 15386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15387 
      self.ex.write(oprot)
1627 ankur.sing 15388 
      oprot.writeFieldEnd()
15389 
    oprot.writeFieldStop()
15390 
    oprot.writeStructEnd()
15391 
 
3431 rajveer 15392 
  def validate(self):
15393 
    return
15394 
 
15395 
 
1627 ankur.sing 15396 
  def __repr__(self):
15397 
    L = ['%s=%r' % (key, value)
15398 
      for key, value in self.__dict__.iteritems()]
15399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15400 
 
15401 
  def __eq__(self, other):
15402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15403 
 
15404 
  def __ne__(self, other):
15405 
    return not (self == other)
15406 
 
4910 phani.kuma 15407 
class markOrdersAsFirstDeliveryAttempted_args:
15408 
  """
15409 
  Attributes:
15410 
   - providerId
15411 
   - first_atdl_orders
15412 
  """
15413 
 
15414 
  thrift_spec = (
15415 
    None, # 0
15416 
    (1, TType.I64, 'providerId', None, None, ), # 1
15417 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15418 
  )
15419 
 
15420 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15421 
    self.providerId = providerId
15422 
    self.first_atdl_orders = first_atdl_orders
15423 
 
15424 
  def read(self, iprot):
15425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15427 
      return
15428 
    iprot.readStructBegin()
15429 
    while True:
15430 
      (fname, ftype, fid) = iprot.readFieldBegin()
15431 
      if ftype == TType.STOP:
15432 
        break
15433 
      if fid == 1:
15434 
        if ftype == TType.I64:
15435 
          self.providerId = iprot.readI64();
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      elif fid == 2:
15439 
        if ftype == TType.MAP:
15440 
          self.first_atdl_orders = {}
6188 rajveer 15441 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15442 
          for _i388 in xrange(_size384):
15443 
            _key389 = iprot.readString();
15444 
            _val390 = iprot.readString();
15445 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15446 
          iprot.readMapEnd()
15447 
        else:
15448 
          iprot.skip(ftype)
15449 
      else:
15450 
        iprot.skip(ftype)
15451 
      iprot.readFieldEnd()
15452 
    iprot.readStructEnd()
15453 
 
15454 
  def write(self, oprot):
15455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15457 
      return
15458 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15459 
    if self.providerId is not None:
15460 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15461 
      oprot.writeI64(self.providerId)
15462 
      oprot.writeFieldEnd()
15463 
    if self.first_atdl_orders is not None:
15464 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15465 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15466 
      for kiter391,viter392 in self.first_atdl_orders.items():
15467 
        oprot.writeString(kiter391)
15468 
        oprot.writeString(viter392)
4910 phani.kuma 15469 
      oprot.writeMapEnd()
15470 
      oprot.writeFieldEnd()
15471 
    oprot.writeFieldStop()
15472 
    oprot.writeStructEnd()
15473 
 
15474 
  def validate(self):
15475 
    return
15476 
 
15477 
 
15478 
  def __repr__(self):
15479 
    L = ['%s=%r' % (key, value)
15480 
      for key, value in self.__dict__.iteritems()]
15481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15482 
 
15483 
  def __eq__(self, other):
15484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15485 
 
15486 
  def __ne__(self, other):
15487 
    return not (self == other)
15488 
 
15489 
class markOrdersAsFirstDeliveryAttempted_result:
15490 
  """
15491 
  Attributes:
15492 
   - ex
15493 
  """
15494 
 
15495 
  thrift_spec = (
15496 
    None, # 0
15497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15498 
  )
15499 
 
15500 
  def __init__(self, ex=None,):
15501 
    self.ex = ex
15502 
 
15503 
  def read(self, iprot):
15504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15506 
      return
15507 
    iprot.readStructBegin()
15508 
    while True:
15509 
      (fname, ftype, fid) = iprot.readFieldBegin()
15510 
      if ftype == TType.STOP:
15511 
        break
15512 
      if fid == 1:
15513 
        if ftype == TType.STRUCT:
15514 
          self.ex = TransactionServiceException()
15515 
          self.ex.read(iprot)
15516 
        else:
15517 
          iprot.skip(ftype)
15518 
      else:
15519 
        iprot.skip(ftype)
15520 
      iprot.readFieldEnd()
15521 
    iprot.readStructEnd()
15522 
 
15523 
  def write(self, oprot):
15524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15526 
      return
15527 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15528 
    if self.ex is not None:
15529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15530 
      self.ex.write(oprot)
15531 
      oprot.writeFieldEnd()
15532 
    oprot.writeFieldStop()
15533 
    oprot.writeStructEnd()
15534 
 
15535 
  def validate(self):
15536 
    return
15537 
 
15538 
 
15539 
  def __repr__(self):
15540 
    L = ['%s=%r' % (key, value)
15541 
      for key, value in self.__dict__.iteritems()]
15542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15543 
 
15544 
  def __eq__(self, other):
15545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15546 
 
15547 
  def __ne__(self, other):
15548 
    return not (self == other)
15549 
 
3064 chandransh 15550 
class getUndeliveredOrders_args:
1886 ankur.sing 15551 
  """
15552 
  Attributes:
3064 chandransh 15553 
   - providerId
15554 
   - warehouseId
1886 ankur.sing 15555 
  """
1627 ankur.sing 15556 
 
1886 ankur.sing 15557 
  thrift_spec = (
15558 
    None, # 0
3064 chandransh 15559 
    (1, TType.I64, 'providerId', None, None, ), # 1
15560 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15561 
  )
15562 
 
3064 chandransh 15563 
  def __init__(self, providerId=None, warehouseId=None,):
15564 
    self.providerId = providerId
15565 
    self.warehouseId = warehouseId
1886 ankur.sing 15566 
 
15567 
  def read(self, iprot):
15568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15570 
      return
15571 
    iprot.readStructBegin()
15572 
    while True:
15573 
      (fname, ftype, fid) = iprot.readFieldBegin()
15574 
      if ftype == TType.STOP:
15575 
        break
15576 
      if fid == 1:
15577 
        if ftype == TType.I64:
3064 chandransh 15578 
          self.providerId = iprot.readI64();
1886 ankur.sing 15579 
        else:
15580 
          iprot.skip(ftype)
3064 chandransh 15581 
      elif fid == 2:
15582 
        if ftype == TType.I64:
15583 
          self.warehouseId = iprot.readI64();
15584 
        else:
15585 
          iprot.skip(ftype)
1886 ankur.sing 15586 
      else:
15587 
        iprot.skip(ftype)
15588 
      iprot.readFieldEnd()
15589 
    iprot.readStructEnd()
15590 
 
15591 
  def write(self, oprot):
15592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15594 
      return
3064 chandransh 15595 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15596 
    if self.providerId is not None:
3064 chandransh 15597 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15598 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15599 
      oprot.writeFieldEnd()
3431 rajveer 15600 
    if self.warehouseId is not None:
3064 chandransh 15601 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15602 
      oprot.writeI64(self.warehouseId)
15603 
      oprot.writeFieldEnd()
1886 ankur.sing 15604 
    oprot.writeFieldStop()
15605 
    oprot.writeStructEnd()
15606 
 
3431 rajveer 15607 
  def validate(self):
15608 
    return
15609 
 
15610 
 
1886 ankur.sing 15611 
  def __repr__(self):
15612 
    L = ['%s=%r' % (key, value)
15613 
      for key, value in self.__dict__.iteritems()]
15614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15615 
 
15616 
  def __eq__(self, other):
15617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15618 
 
15619 
  def __ne__(self, other):
15620 
    return not (self == other)
15621 
 
3064 chandransh 15622 
class getUndeliveredOrders_result:
1886 ankur.sing 15623 
  """
15624 
  Attributes:
15625 
   - success
15626 
  """
15627 
 
15628 
  thrift_spec = (
15629 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15630 
  )
15631 
 
15632 
  def __init__(self, success=None,):
15633 
    self.success = success
15634 
 
15635 
  def read(self, iprot):
15636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15638 
      return
15639 
    iprot.readStructBegin()
15640 
    while True:
15641 
      (fname, ftype, fid) = iprot.readFieldBegin()
15642 
      if ftype == TType.STOP:
15643 
        break
15644 
      if fid == 0:
15645 
        if ftype == TType.LIST:
15646 
          self.success = []
6188 rajveer 15647 
          (_etype396, _size393) = iprot.readListBegin()
15648 
          for _i397 in xrange(_size393):
15649 
            _elem398 = Order()
15650 
            _elem398.read(iprot)
15651 
            self.success.append(_elem398)
1886 ankur.sing 15652 
          iprot.readListEnd()
15653 
        else:
15654 
          iprot.skip(ftype)
15655 
      else:
15656 
        iprot.skip(ftype)
15657 
      iprot.readFieldEnd()
15658 
    iprot.readStructEnd()
15659 
 
15660 
  def write(self, oprot):
15661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15663 
      return
3064 chandransh 15664 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15665 
    if self.success is not None:
1886 ankur.sing 15666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15667 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15668 
      for iter399 in self.success:
15669 
        iter399.write(oprot)
1886 ankur.sing 15670 
      oprot.writeListEnd()
15671 
      oprot.writeFieldEnd()
15672 
    oprot.writeFieldStop()
15673 
    oprot.writeStructEnd()
15674 
 
3431 rajveer 15675 
  def validate(self):
15676 
    return
15677 
 
15678 
 
1886 ankur.sing 15679 
  def __repr__(self):
15680 
    L = ['%s=%r' % (key, value)
15681 
      for key, value in self.__dict__.iteritems()]
15682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15683 
 
15684 
  def __eq__(self, other):
15685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15686 
 
15687 
  def __ne__(self, other):
15688 
    return not (self == other)
15689 
 
4783 phani.kuma 15690 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15691 
 
15692 
  thrift_spec = (
15693 
  )
15694 
 
15695 
  def read(self, iprot):
15696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15698 
      return
15699 
    iprot.readStructBegin()
15700 
    while True:
15701 
      (fname, ftype, fid) = iprot.readFieldBegin()
15702 
      if ftype == TType.STOP:
15703 
        break
15704 
      else:
15705 
        iprot.skip(ftype)
15706 
      iprot.readFieldEnd()
15707 
    iprot.readStructEnd()
15708 
 
15709 
  def write(self, oprot):
15710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15712 
      return
15713 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15714 
    oprot.writeFieldStop()
15715 
    oprot.writeStructEnd()
15716 
 
15717 
  def validate(self):
15718 
    return
15719 
 
15720 
 
15721 
  def __repr__(self):
15722 
    L = ['%s=%r' % (key, value)
15723 
      for key, value in self.__dict__.iteritems()]
15724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15725 
 
15726 
  def __eq__(self, other):
15727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15728 
 
15729 
  def __ne__(self, other):
15730 
    return not (self == other)
15731 
 
15732 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15733 
  """
15734 
  Attributes:
15735 
   - success
15736 
  """
15737 
 
15738 
  thrift_spec = (
15739 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15740 
  )
15741 
 
15742 
  def __init__(self, success=None,):
15743 
    self.success = success
15744 
 
15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
15754 
      if fid == 0:
15755 
        if ftype == TType.LIST:
15756 
          self.success = []
6188 rajveer 15757 
          (_etype403, _size400) = iprot.readListBegin()
15758 
          for _i404 in xrange(_size400):
15759 
            _elem405 = Order()
15760 
            _elem405.read(iprot)
15761 
            self.success.append(_elem405)
4783 phani.kuma 15762 
          iprot.readListEnd()
15763 
        else:
15764 
          iprot.skip(ftype)
15765 
      else:
15766 
        iprot.skip(ftype)
15767 
      iprot.readFieldEnd()
15768 
    iprot.readStructEnd()
15769 
 
15770 
  def write(self, oprot):
15771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15773 
      return
15774 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15775 
    if self.success is not None:
15776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15778 
      for iter406 in self.success:
15779 
        iter406.write(oprot)
4783 phani.kuma 15780 
      oprot.writeListEnd()
15781 
      oprot.writeFieldEnd()
15782 
    oprot.writeFieldStop()
15783 
    oprot.writeStructEnd()
15784 
 
15785 
  def validate(self):
15786 
    return
15787 
 
15788 
 
15789 
  def __repr__(self):
15790 
    L = ['%s=%r' % (key, value)
15791 
      for key, value in self.__dict__.iteritems()]
15792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15793 
 
15794 
  def __eq__(self, other):
15795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15796 
 
15797 
  def __ne__(self, other):
15798 
    return not (self == other)
15799 
 
2536 chandransh 15800 
class toggleDOAFlag_args:
15801 
  """
15802 
  Attributes:
15803 
   - orderId
15804 
  """
1886 ankur.sing 15805 
 
2536 chandransh 15806 
  thrift_spec = (
15807 
    None, # 0
15808 
    (1, TType.I64, 'orderId', None, None, ), # 1
15809 
  )
15810 
 
15811 
  def __init__(self, orderId=None,):
15812 
    self.orderId = orderId
15813 
 
15814 
  def read(self, iprot):
15815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15817 
      return
15818 
    iprot.readStructBegin()
15819 
    while True:
15820 
      (fname, ftype, fid) = iprot.readFieldBegin()
15821 
      if ftype == TType.STOP:
15822 
        break
15823 
      if fid == 1:
15824 
        if ftype == TType.I64:
15825 
          self.orderId = iprot.readI64();
15826 
        else:
15827 
          iprot.skip(ftype)
15828 
      else:
15829 
        iprot.skip(ftype)
15830 
      iprot.readFieldEnd()
15831 
    iprot.readStructEnd()
15832 
 
15833 
  def write(self, oprot):
15834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15836 
      return
15837 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15838 
    if self.orderId is not None:
2536 chandransh 15839 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15840 
      oprot.writeI64(self.orderId)
15841 
      oprot.writeFieldEnd()
15842 
    oprot.writeFieldStop()
15843 
    oprot.writeStructEnd()
15844 
 
3431 rajveer 15845 
  def validate(self):
15846 
    return
15847 
 
15848 
 
2536 chandransh 15849 
  def __repr__(self):
15850 
    L = ['%s=%r' % (key, value)
15851 
      for key, value in self.__dict__.iteritems()]
15852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15853 
 
15854 
  def __eq__(self, other):
15855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15856 
 
15857 
  def __ne__(self, other):
15858 
    return not (self == other)
15859 
 
15860 
class toggleDOAFlag_result:
15861 
  """
15862 
  Attributes:
15863 
   - success
15864 
   - ex
15865 
  """
15866 
 
15867 
  thrift_spec = (
15868 
    (0, TType.BOOL, 'success', None, None, ), # 0
15869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15870 
  )
15871 
 
15872 
  def __init__(self, success=None, ex=None,):
15873 
    self.success = success
15874 
    self.ex = ex
15875 
 
15876 
  def read(self, iprot):
15877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15879 
      return
15880 
    iprot.readStructBegin()
15881 
    while True:
15882 
      (fname, ftype, fid) = iprot.readFieldBegin()
15883 
      if ftype == TType.STOP:
15884 
        break
15885 
      if fid == 0:
15886 
        if ftype == TType.BOOL:
15887 
          self.success = iprot.readBool();
15888 
        else:
15889 
          iprot.skip(ftype)
15890 
      elif fid == 1:
15891 
        if ftype == TType.STRUCT:
15892 
          self.ex = TransactionServiceException()
15893 
          self.ex.read(iprot)
15894 
        else:
15895 
          iprot.skip(ftype)
15896 
      else:
15897 
        iprot.skip(ftype)
15898 
      iprot.readFieldEnd()
15899 
    iprot.readStructEnd()
15900 
 
15901 
  def write(self, oprot):
15902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15904 
      return
15905 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15906 
    if self.success is not None:
2536 chandransh 15907 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15908 
      oprot.writeBool(self.success)
15909 
      oprot.writeFieldEnd()
3431 rajveer 15910 
    if self.ex is not None:
2536 chandransh 15911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15912 
      self.ex.write(oprot)
15913 
      oprot.writeFieldEnd()
15914 
    oprot.writeFieldStop()
15915 
    oprot.writeStructEnd()
15916 
 
3431 rajveer 15917 
  def validate(self):
15918 
    return
15919 
 
15920 
 
2536 chandransh 15921 
  def __repr__(self):
15922 
    L = ['%s=%r' % (key, value)
15923 
      for key, value in self.__dict__.iteritems()]
15924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15925 
 
15926 
  def __eq__(self, other):
15927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15928 
 
15929 
  def __ne__(self, other):
15930 
    return not (self == other)
15931 
 
4712 rajveer 15932 
class markOrderAsDelivered_args:
15933 
  """
15934 
  Attributes:
15935 
   - orderId
15936 
   - deliveryTimestamp
15937 
   - receiver
15938 
  """
15939 
 
15940 
  thrift_spec = None
15941 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15942 
    self.orderId = orderId
15943 
    self.deliveryTimestamp = deliveryTimestamp
15944 
    self.receiver = receiver
15945 
 
15946 
  def read(self, iprot):
15947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15949 
      return
15950 
    iprot.readStructBegin()
15951 
    while True:
15952 
      (fname, ftype, fid) = iprot.readFieldBegin()
15953 
      if ftype == TType.STOP:
15954 
        break
15955 
      if fid == 1:
15956 
        if ftype == TType.I64:
15957 
          self.orderId = iprot.readI64();
15958 
        else:
15959 
          iprot.skip(ftype)
15960 
      elif fid == 2:
15961 
        if ftype == TType.I64:
15962 
          self.deliveryTimestamp = iprot.readI64();
15963 
        else:
15964 
          iprot.skip(ftype)
15965 
      elif fid == -1:
15966 
        if ftype == TType.STRING:
15967 
          self.receiver = iprot.readString();
15968 
        else:
15969 
          iprot.skip(ftype)
15970 
      else:
15971 
        iprot.skip(ftype)
15972 
      iprot.readFieldEnd()
15973 
    iprot.readStructEnd()
15974 
 
15975 
  def write(self, oprot):
15976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15978 
      return
15979 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15980 
    if self.receiver is not None:
15981 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15982 
      oprot.writeString(self.receiver)
15983 
      oprot.writeFieldEnd()
15984 
    if self.orderId is not None:
15985 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15986 
      oprot.writeI64(self.orderId)
15987 
      oprot.writeFieldEnd()
15988 
    if self.deliveryTimestamp is not None:
15989 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15990 
      oprot.writeI64(self.deliveryTimestamp)
15991 
      oprot.writeFieldEnd()
15992 
    oprot.writeFieldStop()
15993 
    oprot.writeStructEnd()
15994 
 
15995 
  def validate(self):
15996 
    return
15997 
 
15998 
 
15999 
  def __repr__(self):
16000 
    L = ['%s=%r' % (key, value)
16001 
      for key, value in self.__dict__.iteritems()]
16002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16003 
 
16004 
  def __eq__(self, other):
16005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16006 
 
16007 
  def __ne__(self, other):
16008 
    return not (self == other)
16009 
 
16010 
class markOrderAsDelivered_result:
16011 
  """
16012 
  Attributes:
16013 
   - ex
16014 
  """
16015 
 
16016 
  thrift_spec = (
16017 
    None, # 0
16018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16019 
  )
16020 
 
16021 
  def __init__(self, ex=None,):
16022 
    self.ex = ex
16023 
 
16024 
  def read(self, iprot):
16025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16027 
      return
16028 
    iprot.readStructBegin()
16029 
    while True:
16030 
      (fname, ftype, fid) = iprot.readFieldBegin()
16031 
      if ftype == TType.STOP:
16032 
        break
16033 
      if fid == 1:
16034 
        if ftype == TType.STRUCT:
16035 
          self.ex = TransactionServiceException()
16036 
          self.ex.read(iprot)
16037 
        else:
16038 
          iprot.skip(ftype)
16039 
      else:
16040 
        iprot.skip(ftype)
16041 
      iprot.readFieldEnd()
16042 
    iprot.readStructEnd()
16043 
 
16044 
  def write(self, oprot):
16045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16047 
      return
16048 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16049 
    if self.ex is not None:
16050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16051 
      self.ex.write(oprot)
16052 
      oprot.writeFieldEnd()
16053 
    oprot.writeFieldStop()
16054 
    oprot.writeStructEnd()
16055 
 
16056 
  def validate(self):
16057 
    return
16058 
 
16059 
 
16060 
  def __repr__(self):
16061 
    L = ['%s=%r' % (key, value)
16062 
      for key, value in self.__dict__.iteritems()]
16063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16064 
 
16065 
  def __eq__(self, other):
16066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16067 
 
16068 
  def __ne__(self, other):
16069 
    return not (self == other)
16070 
 
5553 rajveer 16071 
class markOrderAsReceivedAtStore_args:
16072 
  """
16073 
  Attributes:
16074 
   - orderId
16075 
   - deliveryTimestamp
16076 
  """
16077 
 
16078 
  thrift_spec = (
16079 
    None, # 0
16080 
    (1, TType.I64, 'orderId', None, None, ), # 1
16081 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16082 
  )
16083 
 
16084 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16085 
    self.orderId = orderId
16086 
    self.deliveryTimestamp = deliveryTimestamp
16087 
 
16088 
  def read(self, iprot):
16089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16091 
      return
16092 
    iprot.readStructBegin()
16093 
    while True:
16094 
      (fname, ftype, fid) = iprot.readFieldBegin()
16095 
      if ftype == TType.STOP:
16096 
        break
16097 
      if fid == 1:
16098 
        if ftype == TType.I64:
16099 
          self.orderId = iprot.readI64();
16100 
        else:
16101 
          iprot.skip(ftype)
16102 
      elif fid == 2:
16103 
        if ftype == TType.I64:
16104 
          self.deliveryTimestamp = iprot.readI64();
16105 
        else:
16106 
          iprot.skip(ftype)
16107 
      else:
16108 
        iprot.skip(ftype)
16109 
      iprot.readFieldEnd()
16110 
    iprot.readStructEnd()
16111 
 
16112 
  def write(self, oprot):
16113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16115 
      return
16116 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16117 
    if self.orderId is not None:
16118 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16119 
      oprot.writeI64(self.orderId)
16120 
      oprot.writeFieldEnd()
16121 
    if self.deliveryTimestamp is not None:
16122 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16123 
      oprot.writeI64(self.deliveryTimestamp)
16124 
      oprot.writeFieldEnd()
16125 
    oprot.writeFieldStop()
16126 
    oprot.writeStructEnd()
16127 
 
16128 
  def validate(self):
16129 
    return
16130 
 
16131 
 
16132 
  def __repr__(self):
16133 
    L = ['%s=%r' % (key, value)
16134 
      for key, value in self.__dict__.iteritems()]
16135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16136 
 
16137 
  def __eq__(self, other):
16138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16139 
 
16140 
  def __ne__(self, other):
16141 
    return not (self == other)
16142 
 
16143 
class markOrderAsReceivedAtStore_result:
16144 
  """
16145 
  Attributes:
16146 
   - ex
16147 
  """
16148 
 
16149 
  thrift_spec = (
16150 
    None, # 0
16151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16152 
  )
16153 
 
16154 
  def __init__(self, ex=None,):
16155 
    self.ex = ex
16156 
 
16157 
  def read(self, iprot):
16158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16160 
      return
16161 
    iprot.readStructBegin()
16162 
    while True:
16163 
      (fname, ftype, fid) = iprot.readFieldBegin()
16164 
      if ftype == TType.STOP:
16165 
        break
16166 
      if fid == 1:
16167 
        if ftype == TType.STRUCT:
16168 
          self.ex = TransactionServiceException()
16169 
          self.ex.read(iprot)
16170 
        else:
16171 
          iprot.skip(ftype)
16172 
      else:
16173 
        iprot.skip(ftype)
16174 
      iprot.readFieldEnd()
16175 
    iprot.readStructEnd()
16176 
 
16177 
  def write(self, oprot):
16178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16180 
      return
16181 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16182 
    if self.ex is not None:
16183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16184 
      self.ex.write(oprot)
16185 
      oprot.writeFieldEnd()
16186 
    oprot.writeFieldStop()
16187 
    oprot.writeStructEnd()
16188 
 
16189 
  def validate(self):
16190 
    return
16191 
 
16192 
 
16193 
  def __repr__(self):
16194 
    L = ['%s=%r' % (key, value)
16195 
      for key, value in self.__dict__.iteritems()]
16196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16197 
 
16198 
  def __eq__(self, other):
16199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16200 
 
16201 
  def __ne__(self, other):
16202 
    return not (self == other)
16203 
 
4454 rajveer 16204 
class markOrderDoaRequestReceived_args:
16205 
  """
16206 
  Attributes:
16207 
   - orderId
16208 
  """
16209 
 
16210 
  thrift_spec = (
16211 
    None, # 0
16212 
    (1, TType.I64, 'orderId', None, None, ), # 1
16213 
  )
16214 
 
16215 
  def __init__(self, orderId=None,):
16216 
    self.orderId = orderId
16217 
 
16218 
  def read(self, iprot):
16219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16221 
      return
16222 
    iprot.readStructBegin()
16223 
    while True:
16224 
      (fname, ftype, fid) = iprot.readFieldBegin()
16225 
      if ftype == TType.STOP:
16226 
        break
16227 
      if fid == 1:
16228 
        if ftype == TType.I64:
16229 
          self.orderId = iprot.readI64();
16230 
        else:
16231 
          iprot.skip(ftype)
16232 
      else:
16233 
        iprot.skip(ftype)
16234 
      iprot.readFieldEnd()
16235 
    iprot.readStructEnd()
16236 
 
16237 
  def write(self, oprot):
16238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16240 
      return
16241 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16242 
    if self.orderId is not None:
16243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16244 
      oprot.writeI64(self.orderId)
16245 
      oprot.writeFieldEnd()
16246 
    oprot.writeFieldStop()
16247 
    oprot.writeStructEnd()
16248 
 
16249 
  def validate(self):
16250 
    return
16251 
 
16252 
 
16253 
  def __repr__(self):
16254 
    L = ['%s=%r' % (key, value)
16255 
      for key, value in self.__dict__.iteritems()]
16256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16257 
 
16258 
  def __eq__(self, other):
16259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16260 
 
16261 
  def __ne__(self, other):
16262 
    return not (self == other)
16263 
 
16264 
class markOrderDoaRequestReceived_result:
16265 
  """
16266 
  Attributes:
16267 
   - success
16268 
   - ex
16269 
  """
16270 
 
16271 
  thrift_spec = (
16272 
    (0, TType.BOOL, 'success', None, None, ), # 0
16273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16274 
  )
16275 
 
16276 
  def __init__(self, success=None, ex=None,):
16277 
    self.success = success
16278 
    self.ex = ex
16279 
 
16280 
  def read(self, iprot):
16281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16283 
      return
16284 
    iprot.readStructBegin()
16285 
    while True:
16286 
      (fname, ftype, fid) = iprot.readFieldBegin()
16287 
      if ftype == TType.STOP:
16288 
        break
16289 
      if fid == 0:
16290 
        if ftype == TType.BOOL:
16291 
          self.success = iprot.readBool();
16292 
        else:
16293 
          iprot.skip(ftype)
16294 
      elif fid == 1:
16295 
        if ftype == TType.STRUCT:
16296 
          self.ex = TransactionServiceException()
16297 
          self.ex.read(iprot)
16298 
        else:
16299 
          iprot.skip(ftype)
16300 
      else:
16301 
        iprot.skip(ftype)
16302 
      iprot.readFieldEnd()
16303 
    iprot.readStructEnd()
16304 
 
16305 
  def write(self, oprot):
16306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16308 
      return
16309 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16310 
    if self.success is not None:
16311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16312 
      oprot.writeBool(self.success)
16313 
      oprot.writeFieldEnd()
16314 
    if self.ex is not None:
16315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16316 
      self.ex.write(oprot)
16317 
      oprot.writeFieldEnd()
16318 
    oprot.writeFieldStop()
16319 
    oprot.writeStructEnd()
16320 
 
16321 
  def validate(self):
16322 
    return
16323 
 
16324 
 
16325 
  def __repr__(self):
16326 
    L = ['%s=%r' % (key, value)
16327 
      for key, value in self.__dict__.iteritems()]
16328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16329 
 
16330 
  def __eq__(self, other):
16331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16332 
 
16333 
  def __ne__(self, other):
16334 
    return not (self == other)
16335 
 
16336 
class markOrderDoaRequestAuthorized_args:
16337 
  """
16338 
  Attributes:
16339 
   - orderId
16340 
   - isAuthorized
16341 
  """
16342 
 
16343 
  thrift_spec = (
16344 
    None, # 0
16345 
    (1, TType.I64, 'orderId', None, None, ), # 1
16346 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16347 
  )
16348 
 
16349 
  def __init__(self, orderId=None, isAuthorized=None,):
16350 
    self.orderId = orderId
16351 
    self.isAuthorized = isAuthorized
16352 
 
16353 
  def read(self, iprot):
16354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16356 
      return
16357 
    iprot.readStructBegin()
16358 
    while True:
16359 
      (fname, ftype, fid) = iprot.readFieldBegin()
16360 
      if ftype == TType.STOP:
16361 
        break
16362 
      if fid == 1:
16363 
        if ftype == TType.I64:
16364 
          self.orderId = iprot.readI64();
16365 
        else:
16366 
          iprot.skip(ftype)
16367 
      elif fid == 2:
16368 
        if ftype == TType.BOOL:
16369 
          self.isAuthorized = iprot.readBool();
16370 
        else:
16371 
          iprot.skip(ftype)
16372 
      else:
16373 
        iprot.skip(ftype)
16374 
      iprot.readFieldEnd()
16375 
    iprot.readStructEnd()
16376 
 
16377 
  def write(self, oprot):
16378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16380 
      return
16381 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16382 
    if self.orderId is not None:
16383 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16384 
      oprot.writeI64(self.orderId)
16385 
      oprot.writeFieldEnd()
16386 
    if self.isAuthorized is not None:
16387 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16388 
      oprot.writeBool(self.isAuthorized)
16389 
      oprot.writeFieldEnd()
16390 
    oprot.writeFieldStop()
16391 
    oprot.writeStructEnd()
16392 
 
16393 
  def validate(self):
16394 
    return
16395 
 
16396 
 
16397 
  def __repr__(self):
16398 
    L = ['%s=%r' % (key, value)
16399 
      for key, value in self.__dict__.iteritems()]
16400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16401 
 
16402 
  def __eq__(self, other):
16403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16404 
 
16405 
  def __ne__(self, other):
16406 
    return not (self == other)
16407 
 
16408 
class markOrderDoaRequestAuthorized_result:
16409 
  """
16410 
  Attributes:
16411 
   - success
16412 
   - ex
16413 
  """
16414 
 
16415 
  thrift_spec = (
16416 
    (0, TType.BOOL, 'success', None, None, ), # 0
16417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16418 
  )
16419 
 
16420 
  def __init__(self, success=None, ex=None,):
16421 
    self.success = success
16422 
    self.ex = ex
16423 
 
16424 
  def read(self, iprot):
16425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16427 
      return
16428 
    iprot.readStructBegin()
16429 
    while True:
16430 
      (fname, ftype, fid) = iprot.readFieldBegin()
16431 
      if ftype == TType.STOP:
16432 
        break
16433 
      if fid == 0:
16434 
        if ftype == TType.BOOL:
16435 
          self.success = iprot.readBool();
16436 
        else:
16437 
          iprot.skip(ftype)
16438 
      elif fid == 1:
16439 
        if ftype == TType.STRUCT:
16440 
          self.ex = TransactionServiceException()
16441 
          self.ex.read(iprot)
16442 
        else:
16443 
          iprot.skip(ftype)
16444 
      else:
16445 
        iprot.skip(ftype)
16446 
      iprot.readFieldEnd()
16447 
    iprot.readStructEnd()
16448 
 
16449 
  def write(self, oprot):
16450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16452 
      return
16453 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16454 
    if self.success is not None:
16455 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16456 
      oprot.writeBool(self.success)
16457 
      oprot.writeFieldEnd()
16458 
    if self.ex is not None:
16459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16460 
      self.ex.write(oprot)
16461 
      oprot.writeFieldEnd()
16462 
    oprot.writeFieldStop()
16463 
    oprot.writeStructEnd()
16464 
 
16465 
  def validate(self):
16466 
    return
16467 
 
16468 
 
16469 
  def __repr__(self):
16470 
    L = ['%s=%r' % (key, value)
16471 
      for key, value in self.__dict__.iteritems()]
16472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16473 
 
16474 
  def __eq__(self, other):
16475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16476 
 
16477 
  def __ne__(self, other):
16478 
    return not (self == other)
16479 
 
4488 rajveer 16480 
class markOrderReturnRequestReceived_args:
16481 
  """
16482 
  Attributes:
16483 
   - orderId
16484 
  """
16485 
 
16486 
  thrift_spec = (
16487 
    None, # 0
16488 
    (1, TType.I64, 'orderId', None, None, ), # 1
16489 
  )
16490 
 
16491 
  def __init__(self, orderId=None,):
16492 
    self.orderId = orderId
16493 
 
16494 
  def read(self, iprot):
16495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16497 
      return
16498 
    iprot.readStructBegin()
16499 
    while True:
16500 
      (fname, ftype, fid) = iprot.readFieldBegin()
16501 
      if ftype == TType.STOP:
16502 
        break
16503 
      if fid == 1:
16504 
        if ftype == TType.I64:
16505 
          self.orderId = iprot.readI64();
16506 
        else:
16507 
          iprot.skip(ftype)
16508 
      else:
16509 
        iprot.skip(ftype)
16510 
      iprot.readFieldEnd()
16511 
    iprot.readStructEnd()
16512 
 
16513 
  def write(self, oprot):
16514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16516 
      return
16517 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16518 
    if self.orderId is not None:
16519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16520 
      oprot.writeI64(self.orderId)
16521 
      oprot.writeFieldEnd()
16522 
    oprot.writeFieldStop()
16523 
    oprot.writeStructEnd()
16524 
 
16525 
  def validate(self):
16526 
    return
16527 
 
16528 
 
16529 
  def __repr__(self):
16530 
    L = ['%s=%r' % (key, value)
16531 
      for key, value in self.__dict__.iteritems()]
16532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16533 
 
16534 
  def __eq__(self, other):
16535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16536 
 
16537 
  def __ne__(self, other):
16538 
    return not (self == other)
16539 
 
16540 
class markOrderReturnRequestReceived_result:
16541 
  """
16542 
  Attributes:
16543 
   - success
16544 
   - ex
16545 
  """
16546 
 
16547 
  thrift_spec = (
16548 
    (0, TType.BOOL, 'success', None, None, ), # 0
16549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16550 
  )
16551 
 
16552 
  def __init__(self, success=None, ex=None,):
16553 
    self.success = success
16554 
    self.ex = ex
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 0:
16566 
        if ftype == TType.BOOL:
16567 
          self.success = iprot.readBool();
16568 
        else:
16569 
          iprot.skip(ftype)
16570 
      elif fid == 1:
16571 
        if ftype == TType.STRUCT:
16572 
          self.ex = TransactionServiceException()
16573 
          self.ex.read(iprot)
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      else:
16577 
        iprot.skip(ftype)
16578 
      iprot.readFieldEnd()
16579 
    iprot.readStructEnd()
16580 
 
16581 
  def write(self, oprot):
16582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16584 
      return
16585 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16586 
    if self.success is not None:
16587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16588 
      oprot.writeBool(self.success)
16589 
      oprot.writeFieldEnd()
16590 
    if self.ex is not None:
16591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16592 
      self.ex.write(oprot)
16593 
      oprot.writeFieldEnd()
16594 
    oprot.writeFieldStop()
16595 
    oprot.writeStructEnd()
16596 
 
16597 
  def validate(self):
16598 
    return
16599 
 
16600 
 
16601 
  def __repr__(self):
16602 
    L = ['%s=%r' % (key, value)
16603 
      for key, value in self.__dict__.iteritems()]
16604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16605 
 
16606 
  def __eq__(self, other):
16607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16608 
 
16609 
  def __ne__(self, other):
16610 
    return not (self == other)
16611 
 
16612 
class markOrderReturnRequestAuthorized_args:
16613 
  """
16614 
  Attributes:
16615 
   - orderId
16616 
   - isAuthorized
16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    None, # 0
16621 
    (1, TType.I64, 'orderId', None, None, ), # 1
16622 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16623 
  )
16624 
 
16625 
  def __init__(self, orderId=None, isAuthorized=None,):
16626 
    self.orderId = orderId
16627 
    self.isAuthorized = isAuthorized
16628 
 
16629 
  def read(self, iprot):
16630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16632 
      return
16633 
    iprot.readStructBegin()
16634 
    while True:
16635 
      (fname, ftype, fid) = iprot.readFieldBegin()
16636 
      if ftype == TType.STOP:
16637 
        break
16638 
      if fid == 1:
16639 
        if ftype == TType.I64:
16640 
          self.orderId = iprot.readI64();
16641 
        else:
16642 
          iprot.skip(ftype)
16643 
      elif fid == 2:
16644 
        if ftype == TType.BOOL:
16645 
          self.isAuthorized = iprot.readBool();
16646 
        else:
16647 
          iprot.skip(ftype)
16648 
      else:
16649 
        iprot.skip(ftype)
16650 
      iprot.readFieldEnd()
16651 
    iprot.readStructEnd()
16652 
 
16653 
  def write(self, oprot):
16654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16656 
      return
16657 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16658 
    if self.orderId is not None:
16659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16660 
      oprot.writeI64(self.orderId)
16661 
      oprot.writeFieldEnd()
16662 
    if self.isAuthorized is not None:
16663 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16664 
      oprot.writeBool(self.isAuthorized)
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class markOrderReturnRequestAuthorized_result:
16685 
  """
16686 
  Attributes:
16687 
   - success
16688 
   - ex
16689 
  """
16690 
 
16691 
  thrift_spec = (
16692 
    (0, TType.BOOL, 'success', None, None, ), # 0
16693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16694 
  )
16695 
 
16696 
  def __init__(self, success=None, ex=None,):
16697 
    self.success = success
16698 
    self.ex = ex
16699 
 
16700 
  def read(self, iprot):
16701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16703 
      return
16704 
    iprot.readStructBegin()
16705 
    while True:
16706 
      (fname, ftype, fid) = iprot.readFieldBegin()
16707 
      if ftype == TType.STOP:
16708 
        break
16709 
      if fid == 0:
16710 
        if ftype == TType.BOOL:
16711 
          self.success = iprot.readBool();
16712 
        else:
16713 
          iprot.skip(ftype)
16714 
      elif fid == 1:
16715 
        if ftype == TType.STRUCT:
16716 
          self.ex = TransactionServiceException()
16717 
          self.ex.read(iprot)
16718 
        else:
16719 
          iprot.skip(ftype)
16720 
      else:
16721 
        iprot.skip(ftype)
16722 
      iprot.readFieldEnd()
16723 
    iprot.readStructEnd()
16724 
 
16725 
  def write(self, oprot):
16726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16728 
      return
16729 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16730 
    if self.success is not None:
16731 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16732 
      oprot.writeBool(self.success)
16733 
      oprot.writeFieldEnd()
16734 
    if self.ex is not None:
16735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16736 
      self.ex.write(oprot)
16737 
      oprot.writeFieldEnd()
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
2536 chandransh 16756 
class requestPickupNumber_args:
16757 
  """
16758 
  Attributes:
16759 
   - orderId
4579 rajveer 16760 
   - providerId
2536 chandransh 16761 
  """
16762 
 
16763 
  thrift_spec = (
16764 
    None, # 0
16765 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16766 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16767 
  )
16768 
 
4579 rajveer 16769 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16770 
    self.orderId = orderId
4579 rajveer 16771 
    self.providerId = providerId
2536 chandransh 16772 
 
16773 
  def read(self, iprot):
16774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16776 
      return
16777 
    iprot.readStructBegin()
16778 
    while True:
16779 
      (fname, ftype, fid) = iprot.readFieldBegin()
16780 
      if ftype == TType.STOP:
16781 
        break
16782 
      if fid == 1:
16783 
        if ftype == TType.I64:
16784 
          self.orderId = iprot.readI64();
16785 
        else:
16786 
          iprot.skip(ftype)
4579 rajveer 16787 
      elif fid == 2:
16788 
        if ftype == TType.I64:
16789 
          self.providerId = iprot.readI64();
16790 
        else:
16791 
          iprot.skip(ftype)
2536 chandransh 16792 
      else:
16793 
        iprot.skip(ftype)
16794 
      iprot.readFieldEnd()
16795 
    iprot.readStructEnd()
16796 
 
16797 
  def write(self, oprot):
16798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16800 
      return
16801 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16802 
    if self.orderId is not None:
2536 chandransh 16803 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16804 
      oprot.writeI64(self.orderId)
16805 
      oprot.writeFieldEnd()
4579 rajveer 16806 
    if self.providerId is not None:
16807 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16808 
      oprot.writeI64(self.providerId)
16809 
      oprot.writeFieldEnd()
2536 chandransh 16810 
    oprot.writeFieldStop()
16811 
    oprot.writeStructEnd()
16812 
 
3431 rajveer 16813 
  def validate(self):
16814 
    return
16815 
 
16816 
 
2536 chandransh 16817 
  def __repr__(self):
16818 
    L = ['%s=%r' % (key, value)
16819 
      for key, value in self.__dict__.iteritems()]
16820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16821 
 
16822 
  def __eq__(self, other):
16823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16824 
 
16825 
  def __ne__(self, other):
16826 
    return not (self == other)
16827 
 
16828 
class requestPickupNumber_result:
16829 
  """
16830 
  Attributes:
16831 
   - success
16832 
   - ex
16833 
  """
16834 
 
16835 
  thrift_spec = (
16836 
    (0, TType.BOOL, 'success', None, None, ), # 0
16837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16838 
  )
16839 
 
16840 
  def __init__(self, success=None, ex=None,):
16841 
    self.success = success
16842 
    self.ex = ex
16843 
 
16844 
  def read(self, iprot):
16845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16847 
      return
16848 
    iprot.readStructBegin()
16849 
    while True:
16850 
      (fname, ftype, fid) = iprot.readFieldBegin()
16851 
      if ftype == TType.STOP:
16852 
        break
16853 
      if fid == 0:
16854 
        if ftype == TType.BOOL:
16855 
          self.success = iprot.readBool();
16856 
        else:
16857 
          iprot.skip(ftype)
16858 
      elif fid == 1:
16859 
        if ftype == TType.STRUCT:
16860 
          self.ex = TransactionServiceException()
16861 
          self.ex.read(iprot)
16862 
        else:
16863 
          iprot.skip(ftype)
16864 
      else:
16865 
        iprot.skip(ftype)
16866 
      iprot.readFieldEnd()
16867 
    iprot.readStructEnd()
16868 
 
16869 
  def write(self, oprot):
16870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16872 
      return
16873 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16874 
    if self.success is not None:
2536 chandransh 16875 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16876 
      oprot.writeBool(self.success)
16877 
      oprot.writeFieldEnd()
3431 rajveer 16878 
    if self.ex is not None:
2536 chandransh 16879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16880 
      self.ex.write(oprot)
16881 
      oprot.writeFieldEnd()
16882 
    oprot.writeFieldStop()
16883 
    oprot.writeStructEnd()
16884 
 
3431 rajveer 16885 
  def validate(self):
16886 
    return
16887 
 
16888 
 
2536 chandransh 16889 
  def __repr__(self):
16890 
    L = ['%s=%r' % (key, value)
16891 
      for key, value in self.__dict__.iteritems()]
16892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16893 
 
16894 
  def __eq__(self, other):
16895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16896 
 
16897 
  def __ne__(self, other):
16898 
    return not (self == other)
16899 
 
16900 
class authorizePickup_args:
16901 
  """
16902 
  Attributes:
16903 
   - orderId
16904 
   - pickupNumber
4602 rajveer 16905 
   - providerId
2536 chandransh 16906 
  """
16907 
 
16908 
  thrift_spec = (
16909 
    None, # 0
16910 
    (1, TType.I64, 'orderId', None, None, ), # 1
16911 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16912 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16913 
  )
16914 
 
4602 rajveer 16915 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16916 
    self.orderId = orderId
16917 
    self.pickupNumber = pickupNumber
4602 rajveer 16918 
    self.providerId = providerId
2536 chandransh 16919 
 
16920 
  def read(self, iprot):
16921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16923 
      return
16924 
    iprot.readStructBegin()
16925 
    while True:
16926 
      (fname, ftype, fid) = iprot.readFieldBegin()
16927 
      if ftype == TType.STOP:
16928 
        break
16929 
      if fid == 1:
16930 
        if ftype == TType.I64:
16931 
          self.orderId = iprot.readI64();
16932 
        else:
16933 
          iprot.skip(ftype)
16934 
      elif fid == 2:
16935 
        if ftype == TType.STRING:
16936 
          self.pickupNumber = iprot.readString();
16937 
        else:
16938 
          iprot.skip(ftype)
4602 rajveer 16939 
      elif fid == 3:
16940 
        if ftype == TType.I64:
16941 
          self.providerId = iprot.readI64();
16942 
        else:
16943 
          iprot.skip(ftype)
2536 chandransh 16944 
      else:
16945 
        iprot.skip(ftype)
16946 
      iprot.readFieldEnd()
16947 
    iprot.readStructEnd()
16948 
 
16949 
  def write(self, oprot):
16950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16952 
      return
16953 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16954 
    if self.orderId is not None:
2536 chandransh 16955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16956 
      oprot.writeI64(self.orderId)
16957 
      oprot.writeFieldEnd()
3431 rajveer 16958 
    if self.pickupNumber is not None:
2536 chandransh 16959 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16960 
      oprot.writeString(self.pickupNumber)
16961 
      oprot.writeFieldEnd()
4602 rajveer 16962 
    if self.providerId is not None:
16963 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16964 
      oprot.writeI64(self.providerId)
16965 
      oprot.writeFieldEnd()
2536 chandransh 16966 
    oprot.writeFieldStop()
16967 
    oprot.writeStructEnd()
16968 
 
3431 rajveer 16969 
  def validate(self):
16970 
    return
16971 
 
16972 
 
2536 chandransh 16973 
  def __repr__(self):
16974 
    L = ['%s=%r' % (key, value)
16975 
      for key, value in self.__dict__.iteritems()]
16976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16977 
 
16978 
  def __eq__(self, other):
16979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16980 
 
16981 
  def __ne__(self, other):
16982 
    return not (self == other)
16983 
 
16984 
class authorizePickup_result:
16985 
  """
16986 
  Attributes:
16987 
   - success
16988 
   - ex
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    (0, TType.BOOL, 'success', None, None, ), # 0
16993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16994 
  )
16995 
 
16996 
  def __init__(self, success=None, ex=None,):
16997 
    self.success = success
16998 
    self.ex = ex
16999 
 
17000 
  def read(self, iprot):
17001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17003 
      return
17004 
    iprot.readStructBegin()
17005 
    while True:
17006 
      (fname, ftype, fid) = iprot.readFieldBegin()
17007 
      if ftype == TType.STOP:
17008 
        break
17009 
      if fid == 0:
17010 
        if ftype == TType.BOOL:
17011 
          self.success = iprot.readBool();
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      elif fid == 1:
17015 
        if ftype == TType.STRUCT:
17016 
          self.ex = TransactionServiceException()
17017 
          self.ex.read(iprot)
17018 
        else:
17019 
          iprot.skip(ftype)
17020 
      else:
17021 
        iprot.skip(ftype)
17022 
      iprot.readFieldEnd()
17023 
    iprot.readStructEnd()
17024 
 
17025 
  def write(self, oprot):
17026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17028 
      return
17029 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17030 
    if self.success is not None:
2536 chandransh 17031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17032 
      oprot.writeBool(self.success)
17033 
      oprot.writeFieldEnd()
3431 rajveer 17034 
    if self.ex is not None:
2536 chandransh 17035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17036 
      self.ex.write(oprot)
17037 
      oprot.writeFieldEnd()
17038 
    oprot.writeFieldStop()
17039 
    oprot.writeStructEnd()
17040 
 
3431 rajveer 17041 
  def validate(self):
17042 
    return
17043 
 
17044 
 
2536 chandransh 17045 
  def __repr__(self):
17046 
    L = ['%s=%r' % (key, value)
17047 
      for key, value in self.__dict__.iteritems()]
17048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17049 
 
17050 
  def __eq__(self, other):
17051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17052 
 
17053 
  def __ne__(self, other):
17054 
    return not (self == other)
17055 
 
2764 chandransh 17056 
class markDoasAsPickedUp_args:
17057 
  """
17058 
  Attributes:
17059 
   - providerId
17060 
   - pickupDetails
17061 
  """
17062 
 
17063 
  thrift_spec = (
17064 
    None, # 0
17065 
    (1, TType.I64, 'providerId', None, None, ), # 1
17066 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17067 
  )
17068 
 
17069 
  def __init__(self, providerId=None, pickupDetails=None,):
17070 
    self.providerId = providerId
17071 
    self.pickupDetails = pickupDetails
17072 
 
17073 
  def read(self, iprot):
17074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17076 
      return
17077 
    iprot.readStructBegin()
17078 
    while True:
17079 
      (fname, ftype, fid) = iprot.readFieldBegin()
17080 
      if ftype == TType.STOP:
17081 
        break
17082 
      if fid == 1:
17083 
        if ftype == TType.I64:
17084 
          self.providerId = iprot.readI64();
17085 
        else:
17086 
          iprot.skip(ftype)
17087 
      elif fid == 2:
17088 
        if ftype == TType.MAP:
17089 
          self.pickupDetails = {}
6188 rajveer 17090 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17091 
          for _i411 in xrange(_size407):
17092 
            _key412 = iprot.readString();
17093 
            _val413 = iprot.readString();
17094 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17095 
          iprot.readMapEnd()
17096 
        else:
17097 
          iprot.skip(ftype)
17098 
      else:
17099 
        iprot.skip(ftype)
17100 
      iprot.readFieldEnd()
17101 
    iprot.readStructEnd()
17102 
 
17103 
  def write(self, oprot):
17104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17106 
      return
17107 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17108 
    if self.providerId is not None:
2764 chandransh 17109 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17110 
      oprot.writeI64(self.providerId)
17111 
      oprot.writeFieldEnd()
3431 rajveer 17112 
    if self.pickupDetails is not None:
2764 chandransh 17113 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17114 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17115 
      for kiter414,viter415 in self.pickupDetails.items():
17116 
        oprot.writeString(kiter414)
17117 
        oprot.writeString(viter415)
2764 chandransh 17118 
      oprot.writeMapEnd()
17119 
      oprot.writeFieldEnd()
17120 
    oprot.writeFieldStop()
17121 
    oprot.writeStructEnd()
17122 
 
3431 rajveer 17123 
  def validate(self):
17124 
    return
17125 
 
17126 
 
2764 chandransh 17127 
  def __repr__(self):
17128 
    L = ['%s=%r' % (key, value)
17129 
      for key, value in self.__dict__.iteritems()]
17130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17131 
 
17132 
  def __eq__(self, other):
17133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17134 
 
17135 
  def __ne__(self, other):
17136 
    return not (self == other)
17137 
 
17138 
class markDoasAsPickedUp_result:
4910 phani.kuma 17139 
 
17140 
  thrift_spec = (
17141 
  )
17142 
 
17143 
  def read(self, iprot):
17144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17146 
      return
17147 
    iprot.readStructBegin()
17148 
    while True:
17149 
      (fname, ftype, fid) = iprot.readFieldBegin()
17150 
      if ftype == TType.STOP:
17151 
        break
17152 
      else:
17153 
        iprot.skip(ftype)
17154 
      iprot.readFieldEnd()
17155 
    iprot.readStructEnd()
17156 
 
17157 
  def write(self, oprot):
17158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17160 
      return
17161 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17162 
    oprot.writeFieldStop()
17163 
    oprot.writeStructEnd()
17164 
 
17165 
  def validate(self):
17166 
    return
17167 
 
17168 
 
17169 
  def __repr__(self):
17170 
    L = ['%s=%r' % (key, value)
17171 
      for key, value in self.__dict__.iteritems()]
17172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17173 
 
17174 
  def __eq__(self, other):
17175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17176 
 
17177 
  def __ne__(self, other):
17178 
    return not (self == other)
17179 
 
17180 
class getDoasNotPickedUp_args:
2764 chandransh 17181 
  """
17182 
  Attributes:
4910 phani.kuma 17183 
   - providerId
17184 
  """
17185 
 
17186 
  thrift_spec = (
17187 
    None, # 0
17188 
    (1, TType.I64, 'providerId', None, None, ), # 1
17189 
  )
17190 
 
17191 
  def __init__(self, providerId=None,):
17192 
    self.providerId = providerId
17193 
 
17194 
  def read(self, iprot):
17195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17197 
      return
17198 
    iprot.readStructBegin()
17199 
    while True:
17200 
      (fname, ftype, fid) = iprot.readFieldBegin()
17201 
      if ftype == TType.STOP:
17202 
        break
17203 
      if fid == 1:
17204 
        if ftype == TType.I64:
17205 
          self.providerId = iprot.readI64();
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      else:
17209 
        iprot.skip(ftype)
17210 
      iprot.readFieldEnd()
17211 
    iprot.readStructEnd()
17212 
 
17213 
  def write(self, oprot):
17214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17216 
      return
17217 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17218 
    if self.providerId is not None:
17219 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17220 
      oprot.writeI64(self.providerId)
17221 
      oprot.writeFieldEnd()
17222 
    oprot.writeFieldStop()
17223 
    oprot.writeStructEnd()
17224 
 
17225 
  def validate(self):
17226 
    return
17227 
 
17228 
 
17229 
  def __repr__(self):
17230 
    L = ['%s=%r' % (key, value)
17231 
      for key, value in self.__dict__.iteritems()]
17232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17233 
 
17234 
  def __eq__(self, other):
17235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17236 
 
17237 
  def __ne__(self, other):
17238 
    return not (self == other)
17239 
 
17240 
class getDoasNotPickedUp_result:
17241 
  """
17242 
  Attributes:
2764 chandransh 17243 
   - success
17244 
  """
17245 
 
17246 
  thrift_spec = (
17247 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17248 
  )
17249 
 
17250 
  def __init__(self, success=None,):
17251 
    self.success = success
17252 
 
17253 
  def read(self, iprot):
17254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17256 
      return
17257 
    iprot.readStructBegin()
17258 
    while True:
17259 
      (fname, ftype, fid) = iprot.readFieldBegin()
17260 
      if ftype == TType.STOP:
17261 
        break
17262 
      if fid == 0:
17263 
        if ftype == TType.LIST:
17264 
          self.success = []
6188 rajveer 17265 
          (_etype419, _size416) = iprot.readListBegin()
17266 
          for _i420 in xrange(_size416):
17267 
            _elem421 = Order()
17268 
            _elem421.read(iprot)
17269 
            self.success.append(_elem421)
2764 chandransh 17270 
          iprot.readListEnd()
17271 
        else:
17272 
          iprot.skip(ftype)
17273 
      else:
17274 
        iprot.skip(ftype)
17275 
      iprot.readFieldEnd()
17276 
    iprot.readStructEnd()
17277 
 
17278 
  def write(self, oprot):
17279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17281 
      return
4910 phani.kuma 17282 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17283 
    if self.success is not None:
2764 chandransh 17284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17286 
      for iter422 in self.success:
17287 
        iter422.write(oprot)
2764 chandransh 17288 
      oprot.writeListEnd()
17289 
      oprot.writeFieldEnd()
17290 
    oprot.writeFieldStop()
17291 
    oprot.writeStructEnd()
17292 
 
3431 rajveer 17293 
  def validate(self):
17294 
    return
17295 
 
17296 
 
2764 chandransh 17297 
  def __repr__(self):
17298 
    L = ['%s=%r' % (key, value)
17299 
      for key, value in self.__dict__.iteritems()]
17300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17301 
 
17302 
  def __eq__(self, other):
17303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17304 
 
17305 
  def __ne__(self, other):
17306 
    return not (self == other)
17307 
 
4741 phani.kuma 17308 
class markReturnOrdersAsPickedUp_args:
17309 
  """
17310 
  Attributes:
17311 
   - providerId
17312 
   - pickupDetails
17313 
  """
17314 
 
17315 
  thrift_spec = (
17316 
    None, # 0
17317 
    (1, TType.I64, 'providerId', None, None, ), # 1
17318 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17319 
  )
17320 
 
17321 
  def __init__(self, providerId=None, pickupDetails=None,):
17322 
    self.providerId = providerId
17323 
    self.pickupDetails = pickupDetails
17324 
 
17325 
  def read(self, iprot):
17326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17328 
      return
17329 
    iprot.readStructBegin()
17330 
    while True:
17331 
      (fname, ftype, fid) = iprot.readFieldBegin()
17332 
      if ftype == TType.STOP:
17333 
        break
17334 
      if fid == 1:
17335 
        if ftype == TType.I64:
17336 
          self.providerId = iprot.readI64();
17337 
        else:
17338 
          iprot.skip(ftype)
17339 
      elif fid == 2:
17340 
        if ftype == TType.MAP:
17341 
          self.pickupDetails = {}
6188 rajveer 17342 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17343 
          for _i427 in xrange(_size423):
17344 
            _key428 = iprot.readString();
17345 
            _val429 = iprot.readString();
17346 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17347 
          iprot.readMapEnd()
17348 
        else:
17349 
          iprot.skip(ftype)
17350 
      else:
17351 
        iprot.skip(ftype)
17352 
      iprot.readFieldEnd()
17353 
    iprot.readStructEnd()
17354 
 
17355 
  def write(self, oprot):
17356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17358 
      return
17359 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17360 
    if self.providerId is not None:
17361 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17362 
      oprot.writeI64(self.providerId)
17363 
      oprot.writeFieldEnd()
17364 
    if self.pickupDetails is not None:
17365 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17366 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17367 
      for kiter430,viter431 in self.pickupDetails.items():
17368 
        oprot.writeString(kiter430)
17369 
        oprot.writeString(viter431)
4741 phani.kuma 17370 
      oprot.writeMapEnd()
17371 
      oprot.writeFieldEnd()
17372 
    oprot.writeFieldStop()
17373 
    oprot.writeStructEnd()
17374 
 
17375 
  def validate(self):
17376 
    return
17377 
 
17378 
 
17379 
  def __repr__(self):
17380 
    L = ['%s=%r' % (key, value)
17381 
      for key, value in self.__dict__.iteritems()]
17382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17383 
 
17384 
  def __eq__(self, other):
17385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17386 
 
17387 
  def __ne__(self, other):
17388 
    return not (self == other)
17389 
 
17390 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17391 
 
17392 
  thrift_spec = (
17393 
  )
17394 
 
17395 
  def read(self, iprot):
17396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17398 
      return
17399 
    iprot.readStructBegin()
17400 
    while True:
17401 
      (fname, ftype, fid) = iprot.readFieldBegin()
17402 
      if ftype == TType.STOP:
17403 
        break
17404 
      else:
17405 
        iprot.skip(ftype)
17406 
      iprot.readFieldEnd()
17407 
    iprot.readStructEnd()
17408 
 
17409 
  def write(self, oprot):
17410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17412 
      return
17413 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17414 
    oprot.writeFieldStop()
17415 
    oprot.writeStructEnd()
17416 
 
17417 
  def validate(self):
17418 
    return
17419 
 
17420 
 
17421 
  def __repr__(self):
17422 
    L = ['%s=%r' % (key, value)
17423 
      for key, value in self.__dict__.iteritems()]
17424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17425 
 
17426 
  def __eq__(self, other):
17427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17428 
 
17429 
  def __ne__(self, other):
17430 
    return not (self == other)
17431 
 
17432 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17433 
  """
17434 
  Attributes:
4910 phani.kuma 17435 
   - providerId
17436 
  """
17437 
 
17438 
  thrift_spec = (
17439 
    None, # 0
17440 
    (1, TType.I64, 'providerId', None, None, ), # 1
17441 
  )
17442 
 
17443 
  def __init__(self, providerId=None,):
17444 
    self.providerId = providerId
17445 
 
17446 
  def read(self, iprot):
17447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17449 
      return
17450 
    iprot.readStructBegin()
17451 
    while True:
17452 
      (fname, ftype, fid) = iprot.readFieldBegin()
17453 
      if ftype == TType.STOP:
17454 
        break
17455 
      if fid == 1:
17456 
        if ftype == TType.I64:
17457 
          self.providerId = iprot.readI64();
17458 
        else:
17459 
          iprot.skip(ftype)
17460 
      else:
17461 
        iprot.skip(ftype)
17462 
      iprot.readFieldEnd()
17463 
    iprot.readStructEnd()
17464 
 
17465 
  def write(self, oprot):
17466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17468 
      return
17469 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17470 
    if self.providerId is not None:
17471 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17472 
      oprot.writeI64(self.providerId)
17473 
      oprot.writeFieldEnd()
17474 
    oprot.writeFieldStop()
17475 
    oprot.writeStructEnd()
17476 
 
17477 
  def validate(self):
17478 
    return
17479 
 
17480 
 
17481 
  def __repr__(self):
17482 
    L = ['%s=%r' % (key, value)
17483 
      for key, value in self.__dict__.iteritems()]
17484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17485 
 
17486 
  def __eq__(self, other):
17487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17488 
 
17489 
  def __ne__(self, other):
17490 
    return not (self == other)
17491 
 
17492 
class getReturnOrdersNotPickedUp_result:
17493 
  """
17494 
  Attributes:
4741 phani.kuma 17495 
   - success
17496 
  """
17497 
 
17498 
  thrift_spec = (
17499 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17500 
  )
17501 
 
17502 
  def __init__(self, success=None,):
17503 
    self.success = success
17504 
 
17505 
  def read(self, iprot):
17506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17508 
      return
17509 
    iprot.readStructBegin()
17510 
    while True:
17511 
      (fname, ftype, fid) = iprot.readFieldBegin()
17512 
      if ftype == TType.STOP:
17513 
        break
17514 
      if fid == 0:
17515 
        if ftype == TType.LIST:
17516 
          self.success = []
6188 rajveer 17517 
          (_etype435, _size432) = iprot.readListBegin()
17518 
          for _i436 in xrange(_size432):
17519 
            _elem437 = Order()
17520 
            _elem437.read(iprot)
17521 
            self.success.append(_elem437)
4741 phani.kuma 17522 
          iprot.readListEnd()
17523 
        else:
17524 
          iprot.skip(ftype)
17525 
      else:
17526 
        iprot.skip(ftype)
17527 
      iprot.readFieldEnd()
17528 
    iprot.readStructEnd()
17529 
 
17530 
  def write(self, oprot):
17531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17533 
      return
4910 phani.kuma 17534 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17535 
    if self.success is not None:
17536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17538 
      for iter438 in self.success:
17539 
        iter438.write(oprot)
4741 phani.kuma 17540 
      oprot.writeListEnd()
17541 
      oprot.writeFieldEnd()
17542 
    oprot.writeFieldStop()
17543 
    oprot.writeStructEnd()
17544 
 
17545 
  def validate(self):
17546 
    return
17547 
 
17548 
 
17549 
  def __repr__(self):
17550 
    L = ['%s=%r' % (key, value)
17551 
      for key, value in self.__dict__.iteritems()]
17552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17553 
 
17554 
  def __eq__(self, other):
17555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17556 
 
17557 
  def __ne__(self, other):
17558 
    return not (self == other)
17559 
 
2616 chandransh 17560 
class receiveReturn_args:
2591 chandransh 17561 
  """
17562 
  Attributes:
17563 
   - orderId
4479 rajveer 17564 
   - receiveCondition
2591 chandransh 17565 
  """
2536 chandransh 17566 
 
2591 chandransh 17567 
  thrift_spec = (
17568 
    None, # 0
17569 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17570 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17571 
  )
17572 
 
4479 rajveer 17573 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17574 
    self.orderId = orderId
4479 rajveer 17575 
    self.receiveCondition = receiveCondition
2591 chandransh 17576 
 
17577 
  def read(self, iprot):
17578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17580 
      return
17581 
    iprot.readStructBegin()
17582 
    while True:
17583 
      (fname, ftype, fid) = iprot.readFieldBegin()
17584 
      if ftype == TType.STOP:
17585 
        break
17586 
      if fid == 1:
17587 
        if ftype == TType.I64:
17588 
          self.orderId = iprot.readI64();
17589 
        else:
17590 
          iprot.skip(ftype)
4479 rajveer 17591 
      elif fid == 2:
17592 
        if ftype == TType.I64:
17593 
          self.receiveCondition = iprot.readI64();
17594 
        else:
17595 
          iprot.skip(ftype)
2591 chandransh 17596 
      else:
17597 
        iprot.skip(ftype)
17598 
      iprot.readFieldEnd()
17599 
    iprot.readStructEnd()
17600 
 
17601 
  def write(self, oprot):
17602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17604 
      return
2616 chandransh 17605 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17606 
    if self.orderId is not None:
2591 chandransh 17607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17608 
      oprot.writeI64(self.orderId)
17609 
      oprot.writeFieldEnd()
4479 rajveer 17610 
    if self.receiveCondition is not None:
17611 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17612 
      oprot.writeI64(self.receiveCondition)
17613 
      oprot.writeFieldEnd()
2591 chandransh 17614 
    oprot.writeFieldStop()
17615 
    oprot.writeStructEnd()
17616 
 
3431 rajveer 17617 
  def validate(self):
17618 
    return
17619 
 
17620 
 
2591 chandransh 17621 
  def __repr__(self):
17622 
    L = ['%s=%r' % (key, value)
17623 
      for key, value in self.__dict__.iteritems()]
17624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17625 
 
17626 
  def __eq__(self, other):
17627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17628 
 
17629 
  def __ne__(self, other):
17630 
    return not (self == other)
17631 
 
2616 chandransh 17632 
class receiveReturn_result:
2591 chandransh 17633 
  """
17634 
  Attributes:
17635 
   - success
17636 
   - ex
17637 
  """
17638 
 
17639 
  thrift_spec = (
17640 
    (0, TType.BOOL, 'success', None, None, ), # 0
17641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17642 
  )
17643 
 
17644 
  def __init__(self, success=None, ex=None,):
17645 
    self.success = success
17646 
    self.ex = ex
17647 
 
17648 
  def read(self, iprot):
17649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17651 
      return
17652 
    iprot.readStructBegin()
17653 
    while True:
17654 
      (fname, ftype, fid) = iprot.readFieldBegin()
17655 
      if ftype == TType.STOP:
17656 
        break
17657 
      if fid == 0:
17658 
        if ftype == TType.BOOL:
17659 
          self.success = iprot.readBool();
17660 
        else:
17661 
          iprot.skip(ftype)
17662 
      elif fid == 1:
17663 
        if ftype == TType.STRUCT:
17664 
          self.ex = TransactionServiceException()
17665 
          self.ex.read(iprot)
17666 
        else:
17667 
          iprot.skip(ftype)
17668 
      else:
17669 
        iprot.skip(ftype)
17670 
      iprot.readFieldEnd()
17671 
    iprot.readStructEnd()
17672 
 
17673 
  def write(self, oprot):
17674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17676 
      return
2616 chandransh 17677 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17678 
    if self.success is not None:
2591 chandransh 17679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17680 
      oprot.writeBool(self.success)
17681 
      oprot.writeFieldEnd()
3431 rajveer 17682 
    if self.ex is not None:
2591 chandransh 17683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17684 
      self.ex.write(oprot)
17685 
      oprot.writeFieldEnd()
17686 
    oprot.writeFieldStop()
17687 
    oprot.writeStructEnd()
17688 
 
3431 rajveer 17689 
  def validate(self):
17690 
    return
17691 
 
17692 
 
2591 chandransh 17693 
  def __repr__(self):
17694 
    L = ['%s=%r' % (key, value)
17695 
      for key, value in self.__dict__.iteritems()]
17696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17697 
 
17698 
  def __eq__(self, other):
17699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17700 
 
17701 
  def __ne__(self, other):
17702 
    return not (self == other)
17703 
 
17704 
class validateDoa_args:
17705 
  """
17706 
  Attributes:
17707 
   - orderId
17708 
   - isValid
17709 
  """
17710 
 
17711 
  thrift_spec = (
17712 
    None, # 0
17713 
    (1, TType.I64, 'orderId', None, None, ), # 1
17714 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17715 
  )
17716 
 
17717 
  def __init__(self, orderId=None, isValid=None,):
17718 
    self.orderId = orderId
17719 
    self.isValid = isValid
17720 
 
17721 
  def read(self, iprot):
17722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17724 
      return
17725 
    iprot.readStructBegin()
17726 
    while True:
17727 
      (fname, ftype, fid) = iprot.readFieldBegin()
17728 
      if ftype == TType.STOP:
17729 
        break
17730 
      if fid == 1:
17731 
        if ftype == TType.I64:
17732 
          self.orderId = iprot.readI64();
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      elif fid == 2:
17736 
        if ftype == TType.BOOL:
17737 
          self.isValid = iprot.readBool();
17738 
        else:
17739 
          iprot.skip(ftype)
17740 
      else:
17741 
        iprot.skip(ftype)
17742 
      iprot.readFieldEnd()
17743 
    iprot.readStructEnd()
17744 
 
17745 
  def write(self, oprot):
17746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17748 
      return
17749 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17750 
    if self.orderId is not None:
2591 chandransh 17751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17752 
      oprot.writeI64(self.orderId)
17753 
      oprot.writeFieldEnd()
3431 rajveer 17754 
    if self.isValid is not None:
2591 chandransh 17755 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17756 
      oprot.writeBool(self.isValid)
17757 
      oprot.writeFieldEnd()
17758 
    oprot.writeFieldStop()
17759 
    oprot.writeStructEnd()
17760 
 
3431 rajveer 17761 
  def validate(self):
17762 
    return
17763 
 
17764 
 
2591 chandransh 17765 
  def __repr__(self):
17766 
    L = ['%s=%r' % (key, value)
17767 
      for key, value in self.__dict__.iteritems()]
17768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17769 
 
17770 
  def __eq__(self, other):
17771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17772 
 
17773 
  def __ne__(self, other):
17774 
    return not (self == other)
17775 
 
17776 
class validateDoa_result:
17777 
  """
17778 
  Attributes:
17779 
   - success
17780 
   - ex
17781 
  """
17782 
 
17783 
  thrift_spec = (
17784 
    (0, TType.BOOL, 'success', None, None, ), # 0
17785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17786 
  )
17787 
 
17788 
  def __init__(self, success=None, ex=None,):
17789 
    self.success = success
17790 
    self.ex = ex
17791 
 
17792 
  def read(self, iprot):
17793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17795 
      return
17796 
    iprot.readStructBegin()
17797 
    while True:
17798 
      (fname, ftype, fid) = iprot.readFieldBegin()
17799 
      if ftype == TType.STOP:
17800 
        break
17801 
      if fid == 0:
17802 
        if ftype == TType.BOOL:
17803 
          self.success = iprot.readBool();
17804 
        else:
17805 
          iprot.skip(ftype)
17806 
      elif fid == 1:
17807 
        if ftype == TType.STRUCT:
17808 
          self.ex = TransactionServiceException()
17809 
          self.ex.read(iprot)
17810 
        else:
17811 
          iprot.skip(ftype)
17812 
      else:
17813 
        iprot.skip(ftype)
17814 
      iprot.readFieldEnd()
17815 
    iprot.readStructEnd()
17816 
 
17817 
  def write(self, oprot):
17818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17820 
      return
17821 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17822 
    if self.success is not None:
2591 chandransh 17823 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17824 
      oprot.writeBool(self.success)
17825 
      oprot.writeFieldEnd()
3431 rajveer 17826 
    if self.ex is not None:
2591 chandransh 17827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17828 
      self.ex.write(oprot)
17829 
      oprot.writeFieldEnd()
17830 
    oprot.writeFieldStop()
17831 
    oprot.writeStructEnd()
17832 
 
3431 rajveer 17833 
  def validate(self):
17834 
    return
17835 
 
17836 
 
2591 chandransh 17837 
  def __repr__(self):
17838 
    L = ['%s=%r' % (key, value)
17839 
      for key, value in self.__dict__.iteritems()]
17840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17841 
 
17842 
  def __eq__(self, other):
17843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17844 
 
17845 
  def __ne__(self, other):
17846 
    return not (self == other)
17847 
 
4495 rajveer 17848 
class validateReturnProduct_args:
17849 
  """
17850 
  Attributes:
17851 
   - orderId
17852 
   - isUsable
17853 
  """
17854 
 
17855 
  thrift_spec = (
17856 
    None, # 0
17857 
    (1, TType.I64, 'orderId', None, None, ), # 1
17858 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17859 
  )
17860 
 
17861 
  def __init__(self, orderId=None, isUsable=None,):
17862 
    self.orderId = orderId
17863 
    self.isUsable = isUsable
17864 
 
17865 
  def read(self, iprot):
17866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17868 
      return
17869 
    iprot.readStructBegin()
17870 
    while True:
17871 
      (fname, ftype, fid) = iprot.readFieldBegin()
17872 
      if ftype == TType.STOP:
17873 
        break
17874 
      if fid == 1:
17875 
        if ftype == TType.I64:
17876 
          self.orderId = iprot.readI64();
17877 
        else:
17878 
          iprot.skip(ftype)
17879 
      elif fid == 2:
17880 
        if ftype == TType.BOOL:
17881 
          self.isUsable = iprot.readBool();
17882 
        else:
17883 
          iprot.skip(ftype)
17884 
      else:
17885 
        iprot.skip(ftype)
17886 
      iprot.readFieldEnd()
17887 
    iprot.readStructEnd()
17888 
 
17889 
  def write(self, oprot):
17890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17892 
      return
17893 
    oprot.writeStructBegin('validateReturnProduct_args')
17894 
    if self.orderId is not None:
17895 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17896 
      oprot.writeI64(self.orderId)
17897 
      oprot.writeFieldEnd()
17898 
    if self.isUsable is not None:
17899 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17900 
      oprot.writeBool(self.isUsable)
17901 
      oprot.writeFieldEnd()
17902 
    oprot.writeFieldStop()
17903 
    oprot.writeStructEnd()
17904 
 
17905 
  def validate(self):
17906 
    return
17907 
 
17908 
 
17909 
  def __repr__(self):
17910 
    L = ['%s=%r' % (key, value)
17911 
      for key, value in self.__dict__.iteritems()]
17912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17913 
 
17914 
  def __eq__(self, other):
17915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17916 
 
17917 
  def __ne__(self, other):
17918 
    return not (self == other)
17919 
 
17920 
class validateReturnProduct_result:
17921 
  """
17922 
  Attributes:
17923 
   - success
17924 
   - ex
17925 
  """
17926 
 
17927 
  thrift_spec = (
17928 
    (0, TType.BOOL, 'success', None, None, ), # 0
17929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17930 
  )
17931 
 
17932 
  def __init__(self, success=None, ex=None,):
17933 
    self.success = success
17934 
    self.ex = ex
17935 
 
17936 
  def read(self, iprot):
17937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17939 
      return
17940 
    iprot.readStructBegin()
17941 
    while True:
17942 
      (fname, ftype, fid) = iprot.readFieldBegin()
17943 
      if ftype == TType.STOP:
17944 
        break
17945 
      if fid == 0:
17946 
        if ftype == TType.BOOL:
17947 
          self.success = iprot.readBool();
17948 
        else:
17949 
          iprot.skip(ftype)
17950 
      elif fid == 1:
17951 
        if ftype == TType.STRUCT:
17952 
          self.ex = TransactionServiceException()
17953 
          self.ex.read(iprot)
17954 
        else:
17955 
          iprot.skip(ftype)
17956 
      else:
17957 
        iprot.skip(ftype)
17958 
      iprot.readFieldEnd()
17959 
    iprot.readStructEnd()
17960 
 
17961 
  def write(self, oprot):
17962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17964 
      return
17965 
    oprot.writeStructBegin('validateReturnProduct_result')
17966 
    if self.success is not None:
17967 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17968 
      oprot.writeBool(self.success)
17969 
      oprot.writeFieldEnd()
17970 
    if self.ex is not None:
17971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17972 
      self.ex.write(oprot)
17973 
      oprot.writeFieldEnd()
17974 
    oprot.writeFieldStop()
17975 
    oprot.writeStructEnd()
17976 
 
17977 
  def validate(self):
17978 
    return
17979 
 
17980 
 
17981 
  def __repr__(self):
17982 
    L = ['%s=%r' % (key, value)
17983 
      for key, value in self.__dict__.iteritems()]
17984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17985 
 
17986 
  def __eq__(self, other):
17987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17988 
 
17989 
  def __ne__(self, other):
17990 
    return not (self == other)
17991 
 
2616 chandransh 17992 
class reshipOrder_args:
17993 
  """
17994 
  Attributes:
17995 
   - orderId
17996 
  """
2591 chandransh 17997 
 
2616 chandransh 17998 
  thrift_spec = (
17999 
    None, # 0
18000 
    (1, TType.I64, 'orderId', None, None, ), # 1
18001 
  )
18002 
 
18003 
  def __init__(self, orderId=None,):
18004 
    self.orderId = orderId
18005 
 
18006 
  def read(self, iprot):
18007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18009 
      return
18010 
    iprot.readStructBegin()
18011 
    while True:
18012 
      (fname, ftype, fid) = iprot.readFieldBegin()
18013 
      if ftype == TType.STOP:
18014 
        break
18015 
      if fid == 1:
18016 
        if ftype == TType.I64:
18017 
          self.orderId = iprot.readI64();
18018 
        else:
18019 
          iprot.skip(ftype)
18020 
      else:
18021 
        iprot.skip(ftype)
18022 
      iprot.readFieldEnd()
18023 
    iprot.readStructEnd()
18024 
 
18025 
  def write(self, oprot):
18026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18028 
      return
18029 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18030 
    if self.orderId is not None:
2616 chandransh 18031 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18032 
      oprot.writeI64(self.orderId)
18033 
      oprot.writeFieldEnd()
18034 
    oprot.writeFieldStop()
18035 
    oprot.writeStructEnd()
18036 
 
3431 rajveer 18037 
  def validate(self):
18038 
    return
18039 
 
18040 
 
2616 chandransh 18041 
  def __repr__(self):
18042 
    L = ['%s=%r' % (key, value)
18043 
      for key, value in self.__dict__.iteritems()]
18044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18045 
 
18046 
  def __eq__(self, other):
18047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18048 
 
18049 
  def __ne__(self, other):
18050 
    return not (self == other)
18051 
 
18052 
class reshipOrder_result:
18053 
  """
18054 
  Attributes:
18055 
   - success
18056 
   - ex
18057 
  """
18058 
 
18059 
  thrift_spec = (
18060 
    (0, TType.I64, 'success', None, None, ), # 0
18061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18062 
  )
18063 
 
18064 
  def __init__(self, success=None, ex=None,):
18065 
    self.success = success
18066 
    self.ex = ex
18067 
 
18068 
  def read(self, iprot):
18069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18071 
      return
18072 
    iprot.readStructBegin()
18073 
    while True:
18074 
      (fname, ftype, fid) = iprot.readFieldBegin()
18075 
      if ftype == TType.STOP:
18076 
        break
18077 
      if fid == 0:
18078 
        if ftype == TType.I64:
18079 
          self.success = iprot.readI64();
18080 
        else:
18081 
          iprot.skip(ftype)
18082 
      elif fid == 1:
18083 
        if ftype == TType.STRUCT:
18084 
          self.ex = TransactionServiceException()
18085 
          self.ex.read(iprot)
18086 
        else:
18087 
          iprot.skip(ftype)
18088 
      else:
18089 
        iprot.skip(ftype)
18090 
      iprot.readFieldEnd()
18091 
    iprot.readStructEnd()
18092 
 
18093 
  def write(self, oprot):
18094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18096 
      return
18097 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18098 
    if self.success is not None:
2616 chandransh 18099 
      oprot.writeFieldBegin('success', TType.I64, 0)
18100 
      oprot.writeI64(self.success)
18101 
      oprot.writeFieldEnd()
3431 rajveer 18102 
    if self.ex is not None:
2616 chandransh 18103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18104 
      self.ex.write(oprot)
18105 
      oprot.writeFieldEnd()
18106 
    oprot.writeFieldStop()
18107 
    oprot.writeStructEnd()
18108 
 
3431 rajveer 18109 
  def validate(self):
18110 
    return
18111 
 
18112 
 
2616 chandransh 18113 
  def __repr__(self):
18114 
    L = ['%s=%r' % (key, value)
18115 
      for key, value in self.__dict__.iteritems()]
18116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18117 
 
18118 
  def __eq__(self, other):
18119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18120 
 
18121 
  def __ne__(self, other):
18122 
    return not (self == other)
18123 
 
18124 
class refundOrder_args:
18125 
  """
18126 
  Attributes:
18127 
   - orderId
3226 chandransh 18128 
   - refundedBy
18129 
   - reason
2616 chandransh 18130 
  """
18131 
 
18132 
  thrift_spec = (
18133 
    None, # 0
18134 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18135 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18136 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18137 
  )
18138 
 
3226 chandransh 18139 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18140 
    self.orderId = orderId
3226 chandransh 18141 
    self.refundedBy = refundedBy
18142 
    self.reason = reason
2616 chandransh 18143 
 
18144 
  def read(self, iprot):
18145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18147 
      return
18148 
    iprot.readStructBegin()
18149 
    while True:
18150 
      (fname, ftype, fid) = iprot.readFieldBegin()
18151 
      if ftype == TType.STOP:
18152 
        break
18153 
      if fid == 1:
18154 
        if ftype == TType.I64:
18155 
          self.orderId = iprot.readI64();
18156 
        else:
18157 
          iprot.skip(ftype)
3226 chandransh 18158 
      elif fid == 2:
18159 
        if ftype == TType.STRING:
18160 
          self.refundedBy = iprot.readString();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      elif fid == 3:
18164 
        if ftype == TType.STRING:
18165 
          self.reason = iprot.readString();
18166 
        else:
18167 
          iprot.skip(ftype)
2616 chandransh 18168 
      else:
18169 
        iprot.skip(ftype)
18170 
      iprot.readFieldEnd()
18171 
    iprot.readStructEnd()
18172 
 
18173 
  def write(self, oprot):
18174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18176 
      return
18177 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18178 
    if self.orderId is not None:
2616 chandransh 18179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18180 
      oprot.writeI64(self.orderId)
18181 
      oprot.writeFieldEnd()
3431 rajveer 18182 
    if self.refundedBy is not None:
3226 chandransh 18183 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18184 
      oprot.writeString(self.refundedBy)
18185 
      oprot.writeFieldEnd()
3431 rajveer 18186 
    if self.reason is not None:
3226 chandransh 18187 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18188 
      oprot.writeString(self.reason)
18189 
      oprot.writeFieldEnd()
2616 chandransh 18190 
    oprot.writeFieldStop()
18191 
    oprot.writeStructEnd()
18192 
 
3431 rajveer 18193 
  def validate(self):
18194 
    return
18195 
 
18196 
 
2616 chandransh 18197 
  def __repr__(self):
18198 
    L = ['%s=%r' % (key, value)
18199 
      for key, value in self.__dict__.iteritems()]
18200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18201 
 
18202 
  def __eq__(self, other):
18203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18204 
 
18205 
  def __ne__(self, other):
18206 
    return not (self == other)
18207 
 
18208 
class refundOrder_result:
18209 
  """
18210 
  Attributes:
18211 
   - success
18212 
   - ex
18213 
  """
18214 
 
18215 
  thrift_spec = (
18216 
    (0, TType.BOOL, 'success', None, None, ), # 0
18217 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18218 
  )
18219 
 
18220 
  def __init__(self, success=None, ex=None,):
18221 
    self.success = success
18222 
    self.ex = ex
18223 
 
18224 
  def read(self, iprot):
18225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18227 
      return
18228 
    iprot.readStructBegin()
18229 
    while True:
18230 
      (fname, ftype, fid) = iprot.readFieldBegin()
18231 
      if ftype == TType.STOP:
18232 
        break
18233 
      if fid == 0:
18234 
        if ftype == TType.BOOL:
18235 
          self.success = iprot.readBool();
18236 
        else:
18237 
          iprot.skip(ftype)
18238 
      elif fid == 1:
18239 
        if ftype == TType.STRUCT:
18240 
          self.ex = TransactionServiceException()
18241 
          self.ex.read(iprot)
18242 
        else:
18243 
          iprot.skip(ftype)
18244 
      else:
18245 
        iprot.skip(ftype)
18246 
      iprot.readFieldEnd()
18247 
    iprot.readStructEnd()
18248 
 
18249 
  def write(self, oprot):
18250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18252 
      return
18253 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18254 
    if self.success is not None:
2616 chandransh 18255 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18256 
      oprot.writeBool(self.success)
18257 
      oprot.writeFieldEnd()
3431 rajveer 18258 
    if self.ex is not None:
2616 chandransh 18259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18260 
      self.ex.write(oprot)
18261 
      oprot.writeFieldEnd()
18262 
    oprot.writeFieldStop()
18263 
    oprot.writeStructEnd()
18264 
 
3431 rajveer 18265 
  def validate(self):
18266 
    return
18267 
 
18268 
 
2616 chandransh 18269 
  def __repr__(self):
18270 
    L = ['%s=%r' % (key, value)
18271 
      for key, value in self.__dict__.iteritems()]
18272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18273 
 
18274 
  def __eq__(self, other):
18275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18276 
 
18277 
  def __ne__(self, other):
18278 
    return not (self == other)
18279 
 
2690 chandransh 18280 
class getReturnOrders_args:
18281 
  """
18282 
  Attributes:
18283 
   - warehouseId
18284 
   - fromDate
18285 
   - toDate
18286 
  """
2616 chandransh 18287 
 
2690 chandransh 18288 
  thrift_spec = (
18289 
    None, # 0
18290 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18291 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18292 
    (3, TType.I64, 'toDate', None, None, ), # 3
18293 
  )
18294 
 
18295 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18296 
    self.warehouseId = warehouseId
18297 
    self.fromDate = fromDate
18298 
    self.toDate = toDate
18299 
 
18300 
  def read(self, iprot):
18301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18303 
      return
18304 
    iprot.readStructBegin()
18305 
    while True:
18306 
      (fname, ftype, fid) = iprot.readFieldBegin()
18307 
      if ftype == TType.STOP:
18308 
        break
18309 
      if fid == 1:
18310 
        if ftype == TType.I64:
18311 
          self.warehouseId = iprot.readI64();
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      elif fid == 2:
18315 
        if ftype == TType.I64:
18316 
          self.fromDate = iprot.readI64();
18317 
        else:
18318 
          iprot.skip(ftype)
18319 
      elif fid == 3:
18320 
        if ftype == TType.I64:
18321 
          self.toDate = iprot.readI64();
18322 
        else:
18323 
          iprot.skip(ftype)
18324 
      else:
18325 
        iprot.skip(ftype)
18326 
      iprot.readFieldEnd()
18327 
    iprot.readStructEnd()
18328 
 
18329 
  def write(self, oprot):
18330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18332 
      return
18333 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18334 
    if self.warehouseId is not None:
2690 chandransh 18335 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18336 
      oprot.writeI64(self.warehouseId)
18337 
      oprot.writeFieldEnd()
3431 rajveer 18338 
    if self.fromDate is not None:
2690 chandransh 18339 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18340 
      oprot.writeI64(self.fromDate)
18341 
      oprot.writeFieldEnd()
3431 rajveer 18342 
    if self.toDate is not None:
2690 chandransh 18343 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18344 
      oprot.writeI64(self.toDate)
18345 
      oprot.writeFieldEnd()
18346 
    oprot.writeFieldStop()
18347 
    oprot.writeStructEnd()
18348 
 
3431 rajveer 18349 
  def validate(self):
18350 
    return
18351 
 
18352 
 
2690 chandransh 18353 
  def __repr__(self):
18354 
    L = ['%s=%r' % (key, value)
18355 
      for key, value in self.__dict__.iteritems()]
18356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18357 
 
18358 
  def __eq__(self, other):
18359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18360 
 
18361 
  def __ne__(self, other):
18362 
    return not (self == other)
18363 
 
18364 
class getReturnOrders_result:
18365 
  """
18366 
  Attributes:
18367 
   - success
18368 
  """
18369 
 
18370 
  thrift_spec = (
18371 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18372 
  )
18373 
 
18374 
  def __init__(self, success=None,):
18375 
    self.success = success
18376 
 
18377 
  def read(self, iprot):
18378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18380 
      return
18381 
    iprot.readStructBegin()
18382 
    while True:
18383 
      (fname, ftype, fid) = iprot.readFieldBegin()
18384 
      if ftype == TType.STOP:
18385 
        break
18386 
      if fid == 0:
18387 
        if ftype == TType.LIST:
18388 
          self.success = []
6188 rajveer 18389 
          (_etype442, _size439) = iprot.readListBegin()
18390 
          for _i443 in xrange(_size439):
18391 
            _elem444 = ReturnOrder()
18392 
            _elem444.read(iprot)
18393 
            self.success.append(_elem444)
2690 chandransh 18394 
          iprot.readListEnd()
18395 
        else:
18396 
          iprot.skip(ftype)
18397 
      else:
18398 
        iprot.skip(ftype)
18399 
      iprot.readFieldEnd()
18400 
    iprot.readStructEnd()
18401 
 
18402 
  def write(self, oprot):
18403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18405 
      return
18406 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18407 
    if self.success is not None:
2690 chandransh 18408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18410 
      for iter445 in self.success:
18411 
        iter445.write(oprot)
2690 chandransh 18412 
      oprot.writeListEnd()
18413 
      oprot.writeFieldEnd()
18414 
    oprot.writeFieldStop()
18415 
    oprot.writeStructEnd()
18416 
 
3431 rajveer 18417 
  def validate(self):
18418 
    return
18419 
 
18420 
 
2690 chandransh 18421 
  def __repr__(self):
18422 
    L = ['%s=%r' % (key, value)
18423 
      for key, value in self.__dict__.iteritems()]
18424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18425 
 
18426 
  def __eq__(self, other):
18427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18428 
 
18429 
  def __ne__(self, other):
18430 
    return not (self == other)
18431 
 
5481 phani.kuma 18432 
class getAllReturnOrders_args:
18433 
  """
18434 
  Attributes:
18435 
   - onlyNotProcessed
18436 
   - fromDate
18437 
   - toDate
18438 
  """
18439 
 
18440 
  thrift_spec = (
18441 
    None, # 0
18442 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18443 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18444 
    (3, TType.I64, 'toDate', None, None, ), # 3
18445 
  )
18446 
 
18447 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18448 
    self.onlyNotProcessed = onlyNotProcessed
18449 
    self.fromDate = fromDate
18450 
    self.toDate = toDate
18451 
 
18452 
  def read(self, iprot):
18453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18455 
      return
18456 
    iprot.readStructBegin()
18457 
    while True:
18458 
      (fname, ftype, fid) = iprot.readFieldBegin()
18459 
      if ftype == TType.STOP:
18460 
        break
18461 
      if fid == 1:
18462 
        if ftype == TType.BOOL:
18463 
          self.onlyNotProcessed = iprot.readBool();
18464 
        else:
18465 
          iprot.skip(ftype)
18466 
      elif fid == 2:
18467 
        if ftype == TType.I64:
18468 
          self.fromDate = iprot.readI64();
18469 
        else:
18470 
          iprot.skip(ftype)
18471 
      elif fid == 3:
18472 
        if ftype == TType.I64:
18473 
          self.toDate = iprot.readI64();
18474 
        else:
18475 
          iprot.skip(ftype)
18476 
      else:
18477 
        iprot.skip(ftype)
18478 
      iprot.readFieldEnd()
18479 
    iprot.readStructEnd()
18480 
 
18481 
  def write(self, oprot):
18482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18484 
      return
18485 
    oprot.writeStructBegin('getAllReturnOrders_args')
18486 
    if self.onlyNotProcessed is not None:
18487 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18488 
      oprot.writeBool(self.onlyNotProcessed)
18489 
      oprot.writeFieldEnd()
18490 
    if self.fromDate is not None:
18491 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18492 
      oprot.writeI64(self.fromDate)
18493 
      oprot.writeFieldEnd()
18494 
    if self.toDate is not None:
18495 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18496 
      oprot.writeI64(self.toDate)
18497 
      oprot.writeFieldEnd()
18498 
    oprot.writeFieldStop()
18499 
    oprot.writeStructEnd()
18500 
 
18501 
  def validate(self):
18502 
    return
18503 
 
18504 
 
18505 
  def __repr__(self):
18506 
    L = ['%s=%r' % (key, value)
18507 
      for key, value in self.__dict__.iteritems()]
18508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18509 
 
18510 
  def __eq__(self, other):
18511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18512 
 
18513 
  def __ne__(self, other):
18514 
    return not (self == other)
18515 
 
18516 
class getAllReturnOrders_result:
18517 
  """
18518 
  Attributes:
18519 
   - success
18520 
  """
18521 
 
18522 
  thrift_spec = (
18523 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18524 
  )
18525 
 
18526 
  def __init__(self, success=None,):
18527 
    self.success = success
18528 
 
18529 
  def read(self, iprot):
18530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18532 
      return
18533 
    iprot.readStructBegin()
18534 
    while True:
18535 
      (fname, ftype, fid) = iprot.readFieldBegin()
18536 
      if ftype == TType.STOP:
18537 
        break
18538 
      if fid == 0:
18539 
        if ftype == TType.LIST:
18540 
          self.success = []
6188 rajveer 18541 
          (_etype449, _size446) = iprot.readListBegin()
18542 
          for _i450 in xrange(_size446):
18543 
            _elem451 = ReturnOrder()
18544 
            _elem451.read(iprot)
18545 
            self.success.append(_elem451)
5481 phani.kuma 18546 
          iprot.readListEnd()
18547 
        else:
18548 
          iprot.skip(ftype)
18549 
      else:
18550 
        iprot.skip(ftype)
18551 
      iprot.readFieldEnd()
18552 
    iprot.readStructEnd()
18553 
 
18554 
  def write(self, oprot):
18555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18557 
      return
18558 
    oprot.writeStructBegin('getAllReturnOrders_result')
18559 
    if self.success is not None:
18560 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18561 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18562 
      for iter452 in self.success:
18563 
        iter452.write(oprot)
5481 phani.kuma 18564 
      oprot.writeListEnd()
18565 
      oprot.writeFieldEnd()
18566 
    oprot.writeFieldStop()
18567 
    oprot.writeStructEnd()
18568 
 
18569 
  def validate(self):
18570 
    return
18571 
 
18572 
 
18573 
  def __repr__(self):
18574 
    L = ['%s=%r' % (key, value)
18575 
      for key, value in self.__dict__.iteritems()]
18576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18577 
 
18578 
  def __eq__(self, other):
18579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18580 
 
18581 
  def __ne__(self, other):
18582 
    return not (self == other)
18583 
 
2700 chandransh 18584 
class getReturnOrder_args:
18585 
  """
18586 
  Attributes:
18587 
   - id
18588 
  """
18589 
 
18590 
  thrift_spec = (
18591 
    None, # 0
18592 
    (1, TType.I64, 'id', None, None, ), # 1
18593 
  )
18594 
 
18595 
  def __init__(self, id=None,):
18596 
    self.id = id
18597 
 
18598 
  def read(self, iprot):
18599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18601 
      return
18602 
    iprot.readStructBegin()
18603 
    while True:
18604 
      (fname, ftype, fid) = iprot.readFieldBegin()
18605 
      if ftype == TType.STOP:
18606 
        break
18607 
      if fid == 1:
18608 
        if ftype == TType.I64:
18609 
          self.id = iprot.readI64();
18610 
        else:
18611 
          iprot.skip(ftype)
18612 
      else:
18613 
        iprot.skip(ftype)
18614 
      iprot.readFieldEnd()
18615 
    iprot.readStructEnd()
18616 
 
18617 
  def write(self, oprot):
18618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18620 
      return
18621 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18622 
    if self.id is not None:
2700 chandransh 18623 
      oprot.writeFieldBegin('id', TType.I64, 1)
18624 
      oprot.writeI64(self.id)
18625 
      oprot.writeFieldEnd()
18626 
    oprot.writeFieldStop()
18627 
    oprot.writeStructEnd()
18628 
 
3431 rajveer 18629 
  def validate(self):
18630 
    return
18631 
 
18632 
 
2700 chandransh 18633 
  def __repr__(self):
18634 
    L = ['%s=%r' % (key, value)
18635 
      for key, value in self.__dict__.iteritems()]
18636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18637 
 
18638 
  def __eq__(self, other):
18639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18640 
 
18641 
  def __ne__(self, other):
18642 
    return not (self == other)
18643 
 
18644 
class getReturnOrder_result:
18645 
  """
18646 
  Attributes:
18647 
   - success
18648 
   - ex
18649 
  """
18650 
 
18651 
  thrift_spec = (
18652 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18654 
  )
18655 
 
18656 
  def __init__(self, success=None, ex=None,):
18657 
    self.success = success
18658 
    self.ex = ex
18659 
 
18660 
  def read(self, iprot):
18661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18663 
      return
18664 
    iprot.readStructBegin()
18665 
    while True:
18666 
      (fname, ftype, fid) = iprot.readFieldBegin()
18667 
      if ftype == TType.STOP:
18668 
        break
18669 
      if fid == 0:
18670 
        if ftype == TType.STRUCT:
18671 
          self.success = ReturnOrder()
18672 
          self.success.read(iprot)
18673 
        else:
18674 
          iprot.skip(ftype)
18675 
      elif fid == 1:
18676 
        if ftype == TType.STRUCT:
18677 
          self.ex = TransactionServiceException()
18678 
          self.ex.read(iprot)
18679 
        else:
18680 
          iprot.skip(ftype)
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18691 
    if self.success is not None:
2700 chandransh 18692 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18693 
      self.success.write(oprot)
18694 
      oprot.writeFieldEnd()
3431 rajveer 18695 
    if self.ex is not None:
2700 chandransh 18696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18697 
      self.ex.write(oprot)
18698 
      oprot.writeFieldEnd()
18699 
    oprot.writeFieldStop()
18700 
    oprot.writeStructEnd()
18701 
 
3431 rajveer 18702 
  def validate(self):
18703 
    return
18704 
 
18705 
 
2700 chandransh 18706 
  def __repr__(self):
18707 
    L = ['%s=%r' % (key, value)
18708 
      for key, value in self.__dict__.iteritems()]
18709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18710 
 
18711 
  def __eq__(self, other):
18712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18713 
 
18714 
  def __ne__(self, other):
18715 
    return not (self == other)
18716 
 
2690 chandransh 18717 
class processReturn_args:
18718 
  """
18719 
  Attributes:
18720 
   - returnOrderId
18721 
  """
18722 
 
18723 
  thrift_spec = (
18724 
    None, # 0
18725 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18726 
  )
18727 
 
18728 
  def __init__(self, returnOrderId=None,):
18729 
    self.returnOrderId = returnOrderId
18730 
 
18731 
  def read(self, iprot):
18732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18734 
      return
18735 
    iprot.readStructBegin()
18736 
    while True:
18737 
      (fname, ftype, fid) = iprot.readFieldBegin()
18738 
      if ftype == TType.STOP:
18739 
        break
18740 
      if fid == 1:
18741 
        if ftype == TType.I64:
18742 
          self.returnOrderId = iprot.readI64();
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
18754 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18755 
    if self.returnOrderId is not None:
2690 chandransh 18756 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18757 
      oprot.writeI64(self.returnOrderId)
18758 
      oprot.writeFieldEnd()
18759 
    oprot.writeFieldStop()
18760 
    oprot.writeStructEnd()
18761 
 
3431 rajveer 18762 
  def validate(self):
18763 
    return
18764 
 
18765 
 
2690 chandransh 18766 
  def __repr__(self):
18767 
    L = ['%s=%r' % (key, value)
18768 
      for key, value in self.__dict__.iteritems()]
18769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18770 
 
18771 
  def __eq__(self, other):
18772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18773 
 
18774 
  def __ne__(self, other):
18775 
    return not (self == other)
18776 
 
18777 
class processReturn_result:
18778 
  """
18779 
  Attributes:
18780 
   - ex
18781 
  """
18782 
 
18783 
  thrift_spec = (
18784 
    None, # 0
18785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18786 
  )
18787 
 
18788 
  def __init__(self, ex=None,):
18789 
    self.ex = ex
18790 
 
18791 
  def read(self, iprot):
18792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18794 
      return
18795 
    iprot.readStructBegin()
18796 
    while True:
18797 
      (fname, ftype, fid) = iprot.readFieldBegin()
18798 
      if ftype == TType.STOP:
18799 
        break
18800 
      if fid == 1:
18801 
        if ftype == TType.STRUCT:
18802 
          self.ex = TransactionServiceException()
18803 
          self.ex.read(iprot)
18804 
        else:
18805 
          iprot.skip(ftype)
18806 
      else:
18807 
        iprot.skip(ftype)
18808 
      iprot.readFieldEnd()
18809 
    iprot.readStructEnd()
18810 
 
18811 
  def write(self, oprot):
18812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18814 
      return
18815 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18816 
    if self.ex is not None:
2690 chandransh 18817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18818 
      self.ex.write(oprot)
18819 
      oprot.writeFieldEnd()
18820 
    oprot.writeFieldStop()
18821 
    oprot.writeStructEnd()
18822 
 
3431 rajveer 18823 
  def validate(self):
18824 
    return
18825 
 
18826 
 
2690 chandransh 18827 
  def __repr__(self):
18828 
    L = ['%s=%r' % (key, value)
18829 
      for key, value in self.__dict__.iteritems()]
18830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18831 
 
18832 
  def __eq__(self, other):
18833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18834 
 
18835 
  def __ne__(self, other):
18836 
    return not (self == other)
18837 
 
3451 chandransh 18838 
class updateWeight_args:
18839 
  """
18840 
  Attributes:
18841 
   - orderId
18842 
   - weight
18843 
  """
18844 
 
18845 
  thrift_spec = (
18846 
    None, # 0
18847 
    (1, TType.I64, 'orderId', None, None, ), # 1
18848 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18849 
  )
18850 
 
18851 
  def __init__(self, orderId=None, weight=None,):
18852 
    self.orderId = orderId
18853 
    self.weight = weight
18854 
 
18855 
  def read(self, iprot):
18856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18858 
      return
18859 
    iprot.readStructBegin()
18860 
    while True:
18861 
      (fname, ftype, fid) = iprot.readFieldBegin()
18862 
      if ftype == TType.STOP:
18863 
        break
18864 
      if fid == 1:
18865 
        if ftype == TType.I64:
18866 
          self.orderId = iprot.readI64();
18867 
        else:
18868 
          iprot.skip(ftype)
18869 
      elif fid == 2:
18870 
        if ftype == TType.DOUBLE:
18871 
          self.weight = iprot.readDouble();
18872 
        else:
18873 
          iprot.skip(ftype)
18874 
      else:
18875 
        iprot.skip(ftype)
18876 
      iprot.readFieldEnd()
18877 
    iprot.readStructEnd()
18878 
 
18879 
  def write(self, oprot):
18880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18882 
      return
18883 
    oprot.writeStructBegin('updateWeight_args')
18884 
    if self.orderId is not None:
18885 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18886 
      oprot.writeI64(self.orderId)
18887 
      oprot.writeFieldEnd()
18888 
    if self.weight is not None:
18889 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18890 
      oprot.writeDouble(self.weight)
18891 
      oprot.writeFieldEnd()
18892 
    oprot.writeFieldStop()
18893 
    oprot.writeStructEnd()
18894 
 
18895 
  def validate(self):
18896 
    return
18897 
 
18898 
 
18899 
  def __repr__(self):
18900 
    L = ['%s=%r' % (key, value)
18901 
      for key, value in self.__dict__.iteritems()]
18902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18903 
 
18904 
  def __eq__(self, other):
18905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18906 
 
18907 
  def __ne__(self, other):
18908 
    return not (self == other)
18909 
 
18910 
class updateWeight_result:
18911 
  """
18912 
  Attributes:
18913 
   - success
18914 
   - ex
18915 
  """
18916 
 
18917 
  thrift_spec = (
18918 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18920 
  )
18921 
 
18922 
  def __init__(self, success=None, ex=None,):
18923 
    self.success = success
18924 
    self.ex = ex
18925 
 
18926 
  def read(self, iprot):
18927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18929 
      return
18930 
    iprot.readStructBegin()
18931 
    while True:
18932 
      (fname, ftype, fid) = iprot.readFieldBegin()
18933 
      if ftype == TType.STOP:
18934 
        break
18935 
      if fid == 0:
18936 
        if ftype == TType.STRUCT:
18937 
          self.success = Order()
18938 
          self.success.read(iprot)
18939 
        else:
18940 
          iprot.skip(ftype)
18941 
      elif fid == 1:
18942 
        if ftype == TType.STRUCT:
18943 
          self.ex = TransactionServiceException()
18944 
          self.ex.read(iprot)
18945 
        else:
18946 
          iprot.skip(ftype)
18947 
      else:
18948 
        iprot.skip(ftype)
18949 
      iprot.readFieldEnd()
18950 
    iprot.readStructEnd()
18951 
 
18952 
  def write(self, oprot):
18953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18955 
      return
18956 
    oprot.writeStructBegin('updateWeight_result')
18957 
    if self.success is not None:
18958 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18959 
      self.success.write(oprot)
18960 
      oprot.writeFieldEnd()
18961 
    if self.ex is not None:
18962 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18963 
      self.ex.write(oprot)
18964 
      oprot.writeFieldEnd()
18965 
    oprot.writeFieldStop()
18966 
    oprot.writeStructEnd()
18967 
 
18968 
  def validate(self):
18969 
    return
18970 
 
18971 
 
18972 
  def __repr__(self):
18973 
    L = ['%s=%r' % (key, value)
18974 
      for key, value in self.__dict__.iteritems()]
18975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18976 
 
18977 
  def __eq__(self, other):
18978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18979 
 
18980 
  def __ne__(self, other):
18981 
    return not (self == other)
3469 chandransh 18982 
 
18983 
class changeItem_args:
18984 
  """
18985 
  Attributes:
18986 
   - orderId
18987 
   - itemId
18988 
  """
18989 
 
18990 
  thrift_spec = (
18991 
    None, # 0
18992 
    (1, TType.I64, 'orderId', None, None, ), # 1
18993 
    (2, TType.I64, 'itemId', None, None, ), # 2
18994 
  )
18995 
 
18996 
  def __init__(self, orderId=None, itemId=None,):
18997 
    self.orderId = orderId
18998 
    self.itemId = itemId
18999 
 
19000 
  def read(self, iprot):
19001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19003 
      return
19004 
    iprot.readStructBegin()
19005 
    while True:
19006 
      (fname, ftype, fid) = iprot.readFieldBegin()
19007 
      if ftype == TType.STOP:
19008 
        break
19009 
      if fid == 1:
19010 
        if ftype == TType.I64:
19011 
          self.orderId = iprot.readI64();
19012 
        else:
19013 
          iprot.skip(ftype)
19014 
      elif fid == 2:
19015 
        if ftype == TType.I64:
19016 
          self.itemId = iprot.readI64();
19017 
        else:
19018 
          iprot.skip(ftype)
19019 
      else:
19020 
        iprot.skip(ftype)
19021 
      iprot.readFieldEnd()
19022 
    iprot.readStructEnd()
19023 
 
19024 
  def write(self, oprot):
19025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19027 
      return
19028 
    oprot.writeStructBegin('changeItem_args')
19029 
    if self.orderId is not None:
19030 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19031 
      oprot.writeI64(self.orderId)
19032 
      oprot.writeFieldEnd()
19033 
    if self.itemId is not None:
19034 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19035 
      oprot.writeI64(self.itemId)
19036 
      oprot.writeFieldEnd()
19037 
    oprot.writeFieldStop()
19038 
    oprot.writeStructEnd()
19039 
 
19040 
  def validate(self):
19041 
    return
19042 
 
19043 
 
19044 
  def __repr__(self):
19045 
    L = ['%s=%r' % (key, value)
19046 
      for key, value in self.__dict__.iteritems()]
19047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19048 
 
19049 
  def __eq__(self, other):
19050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19051 
 
19052 
  def __ne__(self, other):
19053 
    return not (self == other)
19054 
 
19055 
class changeItem_result:
19056 
  """
19057 
  Attributes:
19058 
   - success
19059 
   - ex
19060 
  """
19061 
 
19062 
  thrift_spec = (
19063 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19065 
  )
19066 
 
19067 
  def __init__(self, success=None, ex=None,):
19068 
    self.success = success
19069 
    self.ex = ex
19070 
 
19071 
  def read(self, iprot):
19072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19074 
      return
19075 
    iprot.readStructBegin()
19076 
    while True:
19077 
      (fname, ftype, fid) = iprot.readFieldBegin()
19078 
      if ftype == TType.STOP:
19079 
        break
19080 
      if fid == 0:
19081 
        if ftype == TType.STRUCT:
19082 
          self.success = Order()
19083 
          self.success.read(iprot)
19084 
        else:
19085 
          iprot.skip(ftype)
19086 
      elif fid == 1:
19087 
        if ftype == TType.STRUCT:
19088 
          self.ex = TransactionServiceException()
19089 
          self.ex.read(iprot)
19090 
        else:
19091 
          iprot.skip(ftype)
19092 
      else:
19093 
        iprot.skip(ftype)
19094 
      iprot.readFieldEnd()
19095 
    iprot.readStructEnd()
19096 
 
19097 
  def write(self, oprot):
19098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19100 
      return
19101 
    oprot.writeStructBegin('changeItem_result')
19102 
    if self.success is not None:
19103 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19104 
      self.success.write(oprot)
19105 
      oprot.writeFieldEnd()
19106 
    if self.ex is not None:
19107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19108 
      self.ex.write(oprot)
19109 
      oprot.writeFieldEnd()
19110 
    oprot.writeFieldStop()
19111 
    oprot.writeStructEnd()
19112 
 
19113 
  def validate(self):
19114 
    return
19115 
 
19116 
 
19117 
  def __repr__(self):
19118 
    L = ['%s=%r' % (key, value)
19119 
      for key, value in self.__dict__.iteritems()]
19120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19121 
 
19122 
  def __eq__(self, other):
19123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19124 
 
19125 
  def __ne__(self, other):
19126 
    return not (self == other)
19127 
 
19128 
class shiftToWarehouse_args:
19129 
  """
19130 
  Attributes:
19131 
   - orderId
19132 
   - warehouseId
19133 
  """
19134 
 
19135 
  thrift_spec = (
19136 
    None, # 0
19137 
    (1, TType.I64, 'orderId', None, None, ), # 1
19138 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19139 
  )
19140 
 
19141 
  def __init__(self, orderId=None, warehouseId=None,):
19142 
    self.orderId = orderId
19143 
    self.warehouseId = warehouseId
19144 
 
19145 
  def read(self, iprot):
19146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19148 
      return
19149 
    iprot.readStructBegin()
19150 
    while True:
19151 
      (fname, ftype, fid) = iprot.readFieldBegin()
19152 
      if ftype == TType.STOP:
19153 
        break
19154 
      if fid == 1:
19155 
        if ftype == TType.I64:
19156 
          self.orderId = iprot.readI64();
19157 
        else:
19158 
          iprot.skip(ftype)
19159 
      elif fid == 2:
19160 
        if ftype == TType.I64:
19161 
          self.warehouseId = iprot.readI64();
19162 
        else:
19163 
          iprot.skip(ftype)
19164 
      else:
19165 
        iprot.skip(ftype)
19166 
      iprot.readFieldEnd()
19167 
    iprot.readStructEnd()
19168 
 
19169 
  def write(self, oprot):
19170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19172 
      return
19173 
    oprot.writeStructBegin('shiftToWarehouse_args')
19174 
    if self.orderId is not None:
19175 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19176 
      oprot.writeI64(self.orderId)
19177 
      oprot.writeFieldEnd()
19178 
    if self.warehouseId is not None:
19179 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19180 
      oprot.writeI64(self.warehouseId)
19181 
      oprot.writeFieldEnd()
19182 
    oprot.writeFieldStop()
19183 
    oprot.writeStructEnd()
19184 
 
19185 
  def validate(self):
19186 
    return
19187 
 
19188 
 
19189 
  def __repr__(self):
19190 
    L = ['%s=%r' % (key, value)
19191 
      for key, value in self.__dict__.iteritems()]
19192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19193 
 
19194 
  def __eq__(self, other):
19195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19196 
 
19197 
  def __ne__(self, other):
19198 
    return not (self == other)
19199 
 
19200 
class shiftToWarehouse_result:
19201 
  """
19202 
  Attributes:
19203 
   - success
19204 
   - ex
19205 
  """
19206 
 
19207 
  thrift_spec = (
19208 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19210 
  )
19211 
 
19212 
  def __init__(self, success=None, ex=None,):
19213 
    self.success = success
19214 
    self.ex = ex
19215 
 
19216 
  def read(self, iprot):
19217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19219 
      return
19220 
    iprot.readStructBegin()
19221 
    while True:
19222 
      (fname, ftype, fid) = iprot.readFieldBegin()
19223 
      if ftype == TType.STOP:
19224 
        break
19225 
      if fid == 0:
19226 
        if ftype == TType.STRUCT:
19227 
          self.success = Order()
19228 
          self.success.read(iprot)
19229 
        else:
19230 
          iprot.skip(ftype)
19231 
      elif fid == 1:
19232 
        if ftype == TType.STRUCT:
19233 
          self.ex = TransactionServiceException()
19234 
          self.ex.read(iprot)
19235 
        else:
19236 
          iprot.skip(ftype)
19237 
      else:
19238 
        iprot.skip(ftype)
19239 
      iprot.readFieldEnd()
19240 
    iprot.readStructEnd()
19241 
 
19242 
  def write(self, oprot):
19243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19245 
      return
19246 
    oprot.writeStructBegin('shiftToWarehouse_result')
19247 
    if self.success is not None:
19248 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19249 
      self.success.write(oprot)
19250 
      oprot.writeFieldEnd()
19251 
    if self.ex is not None:
19252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19253 
      self.ex.write(oprot)
19254 
      oprot.writeFieldEnd()
19255 
    oprot.writeFieldStop()
19256 
    oprot.writeStructEnd()
19257 
 
19258 
  def validate(self):
19259 
    return
19260 
 
19261 
 
19262 
  def __repr__(self):
19263 
    L = ['%s=%r' % (key, value)
19264 
      for key, value in self.__dict__.iteritems()]
19265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19266 
 
19267 
  def __eq__(self, other):
19268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19269 
 
19270 
  def __ne__(self, other):
19271 
    return not (self == other)
3553 chandransh 19272 
 
19273 
class addDelayReason_args:
19274 
  """
19275 
  Attributes:
19276 
   - orderId
19277 
   - delayReason
3986 chandransh 19278 
   - furtherDelay
4647 rajveer 19279 
   - delayReasonText
3553 chandransh 19280 
  """
19281 
 
19282 
  thrift_spec = (
19283 
    None, # 0
19284 
    (1, TType.I64, 'orderId', None, None, ), # 1
19285 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19286 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19287 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19288 
  )
19289 
 
4647 rajveer 19290 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19291 
    self.orderId = orderId
19292 
    self.delayReason = delayReason
3986 chandransh 19293 
    self.furtherDelay = furtherDelay
4647 rajveer 19294 
    self.delayReasonText = delayReasonText
3553 chandransh 19295 
 
19296 
  def read(self, iprot):
19297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19299 
      return
19300 
    iprot.readStructBegin()
19301 
    while True:
19302 
      (fname, ftype, fid) = iprot.readFieldBegin()
19303 
      if ftype == TType.STOP:
19304 
        break
19305 
      if fid == 1:
19306 
        if ftype == TType.I64:
19307 
          self.orderId = iprot.readI64();
19308 
        else:
19309 
          iprot.skip(ftype)
19310 
      elif fid == 2:
19311 
        if ftype == TType.I32:
19312 
          self.delayReason = iprot.readI32();
19313 
        else:
19314 
          iprot.skip(ftype)
3986 chandransh 19315 
      elif fid == 3:
19316 
        if ftype == TType.I64:
19317 
          self.furtherDelay = iprot.readI64();
19318 
        else:
19319 
          iprot.skip(ftype)
4647 rajveer 19320 
      elif fid == 4:
19321 
        if ftype == TType.STRING:
19322 
          self.delayReasonText = iprot.readString();
19323 
        else:
19324 
          iprot.skip(ftype)
3553 chandransh 19325 
      else:
19326 
        iprot.skip(ftype)
19327 
      iprot.readFieldEnd()
19328 
    iprot.readStructEnd()
19329 
 
19330 
  def write(self, oprot):
19331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19333 
      return
19334 
    oprot.writeStructBegin('addDelayReason_args')
19335 
    if self.orderId is not None:
19336 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19337 
      oprot.writeI64(self.orderId)
19338 
      oprot.writeFieldEnd()
19339 
    if self.delayReason is not None:
19340 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19341 
      oprot.writeI32(self.delayReason)
19342 
      oprot.writeFieldEnd()
3986 chandransh 19343 
    if self.furtherDelay is not None:
19344 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19345 
      oprot.writeI64(self.furtherDelay)
19346 
      oprot.writeFieldEnd()
4647 rajveer 19347 
    if self.delayReasonText is not None:
19348 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19349 
      oprot.writeString(self.delayReasonText)
19350 
      oprot.writeFieldEnd()
3553 chandransh 19351 
    oprot.writeFieldStop()
19352 
    oprot.writeStructEnd()
19353 
 
19354 
  def validate(self):
19355 
    return
19356 
 
19357 
 
19358 
  def __repr__(self):
19359 
    L = ['%s=%r' % (key, value)
19360 
      for key, value in self.__dict__.iteritems()]
19361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19362 
 
19363 
  def __eq__(self, other):
19364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19365 
 
19366 
  def __ne__(self, other):
19367 
    return not (self == other)
19368 
 
19369 
class addDelayReason_result:
19370 
  """
19371 
  Attributes:
19372 
   - success
19373 
   - ex
19374 
  """
19375 
 
19376 
  thrift_spec = (
19377 
    (0, TType.BOOL, 'success', None, None, ), # 0
19378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19379 
  )
19380 
 
19381 
  def __init__(self, success=None, ex=None,):
19382 
    self.success = success
19383 
    self.ex = ex
19384 
 
19385 
  def read(self, iprot):
19386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19388 
      return
19389 
    iprot.readStructBegin()
19390 
    while True:
19391 
      (fname, ftype, fid) = iprot.readFieldBegin()
19392 
      if ftype == TType.STOP:
19393 
        break
19394 
      if fid == 0:
19395 
        if ftype == TType.BOOL:
19396 
          self.success = iprot.readBool();
19397 
        else:
19398 
          iprot.skip(ftype)
19399 
      elif fid == 1:
19400 
        if ftype == TType.STRUCT:
19401 
          self.ex = TransactionServiceException()
19402 
          self.ex.read(iprot)
19403 
        else:
19404 
          iprot.skip(ftype)
19405 
      else:
19406 
        iprot.skip(ftype)
19407 
      iprot.readFieldEnd()
19408 
    iprot.readStructEnd()
19409 
 
19410 
  def write(self, oprot):
19411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19413 
      return
19414 
    oprot.writeStructBegin('addDelayReason_result')
19415 
    if self.success is not None:
19416 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19417 
      oprot.writeBool(self.success)
19418 
      oprot.writeFieldEnd()
19419 
    if self.ex is not None:
19420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19421 
      self.ex.write(oprot)
19422 
      oprot.writeFieldEnd()
19423 
    oprot.writeFieldStop()
19424 
    oprot.writeStructEnd()
19425 
 
19426 
  def validate(self):
19427 
    return
19428 
 
19429 
 
19430 
  def __repr__(self):
19431 
    L = ['%s=%r' % (key, value)
19432 
      for key, value in self.__dict__.iteritems()]
19433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19434 
 
19435 
  def __eq__(self, other):
19436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19437 
 
19438 
  def __ne__(self, other):
19439 
    return not (self == other)
3956 chandransh 19440 
 
19441 
class reconcileCodCollection_args:
19442 
  """
19443 
  Attributes:
19444 
   - collectedAmountMap
19445 
   - xferBy
19446 
   - xferTxnId
19447 
   - xferDate
19448 
  """
19449 
 
19450 
  thrift_spec = (
19451 
    None, # 0
19452 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19453 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19454 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19455 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19456 
  )
19457 
 
19458 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19459 
    self.collectedAmountMap = collectedAmountMap
19460 
    self.xferBy = xferBy
19461 
    self.xferTxnId = xferTxnId
19462 
    self.xferDate = xferDate
19463 
 
19464 
  def read(self, iprot):
19465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19467 
      return
19468 
    iprot.readStructBegin()
19469 
    while True:
19470 
      (fname, ftype, fid) = iprot.readFieldBegin()
19471 
      if ftype == TType.STOP:
19472 
        break
19473 
      if fid == 1:
19474 
        if ftype == TType.MAP:
19475 
          self.collectedAmountMap = {}
6188 rajveer 19476 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19477 
          for _i457 in xrange(_size453):
19478 
            _key458 = iprot.readString();
19479 
            _val459 = iprot.readDouble();
19480 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19481 
          iprot.readMapEnd()
19482 
        else:
19483 
          iprot.skip(ftype)
19484 
      elif fid == 2:
19485 
        if ftype == TType.STRING:
19486 
          self.xferBy = iprot.readString();
19487 
        else:
19488 
          iprot.skip(ftype)
19489 
      elif fid == 3:
19490 
        if ftype == TType.STRING:
19491 
          self.xferTxnId = iprot.readString();
19492 
        else:
19493 
          iprot.skip(ftype)
19494 
      elif fid == 4:
19495 
        if ftype == TType.I64:
19496 
          self.xferDate = iprot.readI64();
19497 
        else:
19498 
          iprot.skip(ftype)
19499 
      else:
19500 
        iprot.skip(ftype)
19501 
      iprot.readFieldEnd()
19502 
    iprot.readStructEnd()
19503 
 
19504 
  def write(self, oprot):
19505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19507 
      return
19508 
    oprot.writeStructBegin('reconcileCodCollection_args')
19509 
    if self.collectedAmountMap is not None:
19510 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19511 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19512 
      for kiter460,viter461 in self.collectedAmountMap.items():
19513 
        oprot.writeString(kiter460)
19514 
        oprot.writeDouble(viter461)
3956 chandransh 19515 
      oprot.writeMapEnd()
19516 
      oprot.writeFieldEnd()
19517 
    if self.xferBy is not None:
19518 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19519 
      oprot.writeString(self.xferBy)
19520 
      oprot.writeFieldEnd()
19521 
    if self.xferTxnId is not None:
19522 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19523 
      oprot.writeString(self.xferTxnId)
19524 
      oprot.writeFieldEnd()
19525 
    if self.xferDate is not None:
19526 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19527 
      oprot.writeI64(self.xferDate)
19528 
      oprot.writeFieldEnd()
19529 
    oprot.writeFieldStop()
19530 
    oprot.writeStructEnd()
19531 
 
19532 
  def validate(self):
19533 
    return
19534 
 
19535 
 
19536 
  def __repr__(self):
19537 
    L = ['%s=%r' % (key, value)
19538 
      for key, value in self.__dict__.iteritems()]
19539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19540 
 
19541 
  def __eq__(self, other):
19542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19543 
 
19544 
  def __ne__(self, other):
19545 
    return not (self == other)
19546 
 
19547 
class reconcileCodCollection_result:
19548 
  """
19549 
  Attributes:
19550 
   - success
19551 
   - ex
19552 
  """
19553 
 
19554 
  thrift_spec = (
19555 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19556 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19557 
  )
19558 
 
19559 
  def __init__(self, success=None, ex=None,):
19560 
    self.success = success
19561 
    self.ex = ex
19562 
 
19563 
  def read(self, iprot):
19564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19566 
      return
19567 
    iprot.readStructBegin()
19568 
    while True:
19569 
      (fname, ftype, fid) = iprot.readFieldBegin()
19570 
      if ftype == TType.STOP:
19571 
        break
19572 
      if fid == 0:
19573 
        if ftype == TType.MAP:
19574 
          self.success = {}
6188 rajveer 19575 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19576 
          for _i466 in xrange(_size462):
19577 
            _key467 = iprot.readString();
19578 
            _val468 = iprot.readString();
19579 
            self.success[_key467] = _val468
3956 chandransh 19580 
          iprot.readMapEnd()
19581 
        else:
19582 
          iprot.skip(ftype)
19583 
      elif fid == 1:
19584 
        if ftype == TType.STRUCT:
19585 
          self.ex = TransactionServiceException()
19586 
          self.ex.read(iprot)
19587 
        else:
19588 
          iprot.skip(ftype)
19589 
      else:
19590 
        iprot.skip(ftype)
19591 
      iprot.readFieldEnd()
19592 
    iprot.readStructEnd()
19593 
 
19594 
  def write(self, oprot):
19595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19597 
      return
19598 
    oprot.writeStructBegin('reconcileCodCollection_result')
19599 
    if self.success is not None:
19600 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19601 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19602 
      for kiter469,viter470 in self.success.items():
19603 
        oprot.writeString(kiter469)
19604 
        oprot.writeString(viter470)
3956 chandransh 19605 
      oprot.writeMapEnd()
19606 
      oprot.writeFieldEnd()
19607 
    if self.ex is not None:
19608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19609 
      self.ex.write(oprot)
19610 
      oprot.writeFieldEnd()
19611 
    oprot.writeFieldStop()
19612 
    oprot.writeStructEnd()
19613 
 
19614 
  def validate(self):
19615 
    return
19616 
 
19617 
 
19618 
  def __repr__(self):
19619 
    L = ['%s=%r' % (key, value)
19620 
      for key, value in self.__dict__.iteritems()]
19621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19622 
 
19623 
  def __eq__(self, other):
19624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19625 
 
19626 
  def __ne__(self, other):
19627 
    return not (self == other)
4008 mandeep.dh 19628 
 
19629 
class getTransactionsRequiringExtraProcessing_args:
19630 
  """
19631 
  Attributes:
19632 
   - category
19633 
  """
19634 
 
19635 
  thrift_spec = (
19636 
    None, # 0
19637 
    (1, TType.I32, 'category', None, None, ), # 1
19638 
  )
19639 
 
19640 
  def __init__(self, category=None,):
19641 
    self.category = category
19642 
 
19643 
  def read(self, iprot):
19644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19646 
      return
19647 
    iprot.readStructBegin()
19648 
    while True:
19649 
      (fname, ftype, fid) = iprot.readFieldBegin()
19650 
      if ftype == TType.STOP:
19651 
        break
19652 
      if fid == 1:
19653 
        if ftype == TType.I32:
19654 
          self.category = iprot.readI32();
19655 
        else:
19656 
          iprot.skip(ftype)
19657 
      else:
19658 
        iprot.skip(ftype)
19659 
      iprot.readFieldEnd()
19660 
    iprot.readStructEnd()
19661 
 
19662 
  def write(self, oprot):
19663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19665 
      return
19666 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19667 
    if self.category is not None:
19668 
      oprot.writeFieldBegin('category', TType.I32, 1)
19669 
      oprot.writeI32(self.category)
19670 
      oprot.writeFieldEnd()
19671 
    oprot.writeFieldStop()
19672 
    oprot.writeStructEnd()
19673 
 
19674 
  def validate(self):
19675 
    return
19676 
 
19677 
 
19678 
  def __repr__(self):
19679 
    L = ['%s=%r' % (key, value)
19680 
      for key, value in self.__dict__.iteritems()]
19681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19682 
 
19683 
  def __eq__(self, other):
19684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19685 
 
19686 
  def __ne__(self, other):
19687 
    return not (self == other)
19688 
 
19689 
class getTransactionsRequiringExtraProcessing_result:
19690 
  """
19691 
  Attributes:
19692 
   - success
19693 
  """
19694 
 
19695 
  thrift_spec = (
19696 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19697 
  )
19698 
 
19699 
  def __init__(self, success=None,):
19700 
    self.success = success
19701 
 
19702 
  def read(self, iprot):
19703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19705 
      return
19706 
    iprot.readStructBegin()
19707 
    while True:
19708 
      (fname, ftype, fid) = iprot.readFieldBegin()
19709 
      if ftype == TType.STOP:
19710 
        break
19711 
      if fid == 0:
19712 
        if ftype == TType.LIST:
19713 
          self.success = []
6188 rajveer 19714 
          (_etype474, _size471) = iprot.readListBegin()
19715 
          for _i475 in xrange(_size471):
19716 
            _elem476 = iprot.readI64();
19717 
            self.success.append(_elem476)
4008 mandeep.dh 19718 
          iprot.readListEnd()
19719 
        else:
19720 
          iprot.skip(ftype)
19721 
      else:
19722 
        iprot.skip(ftype)
19723 
      iprot.readFieldEnd()
19724 
    iprot.readStructEnd()
19725 
 
19726 
  def write(self, oprot):
19727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19729 
      return
19730 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19731 
    if self.success is not None:
19732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19733 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19734 
      for iter477 in self.success:
19735 
        oprot.writeI64(iter477)
4008 mandeep.dh 19736 
      oprot.writeListEnd()
19737 
      oprot.writeFieldEnd()
19738 
    oprot.writeFieldStop()
19739 
    oprot.writeStructEnd()
19740 
 
19741 
  def validate(self):
19742 
    return
19743 
 
19744 
 
19745 
  def __repr__(self):
19746 
    L = ['%s=%r' % (key, value)
19747 
      for key, value in self.__dict__.iteritems()]
19748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19749 
 
19750 
  def __eq__(self, other):
19751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19752 
 
19753 
  def __ne__(self, other):
19754 
    return not (self == other)
19755 
 
19756 
class markTransactionAsProcessed_args:
19757 
  """
19758 
  Attributes:
19759 
   - transactionId
19760 
   - category
19761 
  """
19762 
 
19763 
  thrift_spec = (
19764 
    None, # 0
19765 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19766 
    (2, TType.I32, 'category', None, None, ), # 2
19767 
  )
19768 
 
19769 
  def __init__(self, transactionId=None, category=None,):
19770 
    self.transactionId = transactionId
19771 
    self.category = category
19772 
 
19773 
  def read(self, iprot):
19774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19776 
      return
19777 
    iprot.readStructBegin()
19778 
    while True:
19779 
      (fname, ftype, fid) = iprot.readFieldBegin()
19780 
      if ftype == TType.STOP:
19781 
        break
19782 
      if fid == 1:
19783 
        if ftype == TType.I64:
19784 
          self.transactionId = iprot.readI64();
19785 
        else:
19786 
          iprot.skip(ftype)
19787 
      elif fid == 2:
19788 
        if ftype == TType.I32:
19789 
          self.category = iprot.readI32();
19790 
        else:
19791 
          iprot.skip(ftype)
19792 
      else:
19793 
        iprot.skip(ftype)
19794 
      iprot.readFieldEnd()
19795 
    iprot.readStructEnd()
19796 
 
19797 
  def write(self, oprot):
19798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19800 
      return
19801 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19802 
    if self.transactionId is not None:
19803 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19804 
      oprot.writeI64(self.transactionId)
19805 
      oprot.writeFieldEnd()
19806 
    if self.category is not None:
19807 
      oprot.writeFieldBegin('category', TType.I32, 2)
19808 
      oprot.writeI32(self.category)
19809 
      oprot.writeFieldEnd()
19810 
    oprot.writeFieldStop()
19811 
    oprot.writeStructEnd()
19812 
 
19813 
  def validate(self):
19814 
    return
19815 
 
19816 
 
19817 
  def __repr__(self):
19818 
    L = ['%s=%r' % (key, value)
19819 
      for key, value in self.__dict__.iteritems()]
19820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19821 
 
19822 
  def __eq__(self, other):
19823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19824 
 
19825 
  def __ne__(self, other):
19826 
    return not (self == other)
19827 
 
19828 
class markTransactionAsProcessed_result:
19829 
 
19830 
  thrift_spec = (
19831 
  )
19832 
 
19833 
  def read(self, iprot):
19834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19836 
      return
19837 
    iprot.readStructBegin()
19838 
    while True:
19839 
      (fname, ftype, fid) = iprot.readFieldBegin()
19840 
      if ftype == TType.STOP:
19841 
        break
19842 
      else:
19843 
        iprot.skip(ftype)
19844 
      iprot.readFieldEnd()
19845 
    iprot.readStructEnd()
19846 
 
19847 
  def write(self, oprot):
19848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19850 
      return
19851 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19852 
    oprot.writeFieldStop()
19853 
    oprot.writeStructEnd()
19854 
 
19855 
  def validate(self):
19856 
    return
19857 
 
19858 
 
19859 
  def __repr__(self):
19860 
    L = ['%s=%r' % (key, value)
19861 
      for key, value in self.__dict__.iteritems()]
19862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19863 
 
19864 
  def __eq__(self, other):
19865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19866 
 
19867 
  def __ne__(self, other):
19868 
    return not (self == other)
4018 chandransh 19869 
 
19870 
class getItemWiseRiskyOrdersCount_args:
19871 
 
19872 
  thrift_spec = (
19873 
  )
19874 
 
19875 
  def read(self, iprot):
19876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19878 
      return
19879 
    iprot.readStructBegin()
19880 
    while True:
19881 
      (fname, ftype, fid) = iprot.readFieldBegin()
19882 
      if ftype == TType.STOP:
19883 
        break
19884 
      else:
19885 
        iprot.skip(ftype)
19886 
      iprot.readFieldEnd()
19887 
    iprot.readStructEnd()
19888 
 
19889 
  def write(self, oprot):
19890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19892 
      return
19893 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19894 
    oprot.writeFieldStop()
19895 
    oprot.writeStructEnd()
19896 
 
19897 
  def validate(self):
19898 
    return
19899 
 
19900 
 
19901 
  def __repr__(self):
19902 
    L = ['%s=%r' % (key, value)
19903 
      for key, value in self.__dict__.iteritems()]
19904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19905 
 
19906 
  def __eq__(self, other):
19907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19908 
 
19909 
  def __ne__(self, other):
19910 
    return not (self == other)
19911 
 
19912 
class getItemWiseRiskyOrdersCount_result:
19913 
  """
19914 
  Attributes:
19915 
   - success
19916 
  """
19917 
 
19918 
  thrift_spec = (
19919 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19920 
  )
19921 
 
19922 
  def __init__(self, success=None,):
19923 
    self.success = success
19924 
 
19925 
  def read(self, iprot):
19926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19928 
      return
19929 
    iprot.readStructBegin()
19930 
    while True:
19931 
      (fname, ftype, fid) = iprot.readFieldBegin()
19932 
      if ftype == TType.STOP:
19933 
        break
19934 
      if fid == 0:
19935 
        if ftype == TType.MAP:
19936 
          self.success = {}
6188 rajveer 19937 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
19938 
          for _i482 in xrange(_size478):
19939 
            _key483 = iprot.readI64();
19940 
            _val484 = iprot.readI64();
19941 
            self.success[_key483] = _val484
4018 chandransh 19942 
          iprot.readMapEnd()
19943 
        else:
19944 
          iprot.skip(ftype)
19945 
      else:
19946 
        iprot.skip(ftype)
19947 
      iprot.readFieldEnd()
19948 
    iprot.readStructEnd()
19949 
 
19950 
  def write(self, oprot):
19951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19953 
      return
19954 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19955 
    if self.success is not None:
19956 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19957 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 19958 
      for kiter485,viter486 in self.success.items():
19959 
        oprot.writeI64(kiter485)
19960 
        oprot.writeI64(viter486)
4018 chandransh 19961 
      oprot.writeMapEnd()
19962 
      oprot.writeFieldEnd()
19963 
    oprot.writeFieldStop()
19964 
    oprot.writeStructEnd()
19965 
 
19966 
  def validate(self):
19967 
    return
19968 
 
19969 
 
19970 
  def __repr__(self):
19971 
    L = ['%s=%r' % (key, value)
19972 
      for key, value in self.__dict__.iteritems()]
19973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19974 
 
19975 
  def __eq__(self, other):
19976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19977 
 
19978 
  def __ne__(self, other):
19979 
    return not (self == other)
4247 rajveer 19980 
 
4295 varun.gupt 19981 
class getOrdersForItemIds_args:
19982 
  """
19983 
  Attributes:
19984 
   - itemIds
19985 
  """
19986 
 
19987 
  thrift_spec = (
19988 
    None, # 0
19989 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19990 
  )
19991 
 
19992 
  def __init__(self, itemIds=None,):
19993 
    self.itemIds = itemIds
19994 
 
19995 
  def read(self, iprot):
19996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19998 
      return
19999 
    iprot.readStructBegin()
20000 
    while True:
20001 
      (fname, ftype, fid) = iprot.readFieldBegin()
20002 
      if ftype == TType.STOP:
20003 
        break
20004 
      if fid == 1:
20005 
        if ftype == TType.LIST:
20006 
          self.itemIds = []
6188 rajveer 20007 
          (_etype490, _size487) = iprot.readListBegin()
20008 
          for _i491 in xrange(_size487):
20009 
            _elem492 = iprot.readI64();
20010 
            self.itemIds.append(_elem492)
4295 varun.gupt 20011 
          iprot.readListEnd()
20012 
        else:
20013 
          iprot.skip(ftype)
20014 
      else:
20015 
        iprot.skip(ftype)
20016 
      iprot.readFieldEnd()
20017 
    iprot.readStructEnd()
20018 
 
20019 
  def write(self, oprot):
20020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20022 
      return
20023 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20024 
    if self.itemIds is not None:
20025 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20026 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20027 
      for iter493 in self.itemIds:
20028 
        oprot.writeI64(iter493)
4295 varun.gupt 20029 
      oprot.writeListEnd()
20030 
      oprot.writeFieldEnd()
20031 
    oprot.writeFieldStop()
20032 
    oprot.writeStructEnd()
20033 
 
20034 
  def validate(self):
20035 
    return
20036 
 
20037 
 
20038 
  def __repr__(self):
20039 
    L = ['%s=%r' % (key, value)
20040 
      for key, value in self.__dict__.iteritems()]
20041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20042 
 
20043 
  def __eq__(self, other):
20044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20045 
 
20046 
  def __ne__(self, other):
20047 
    return not (self == other)
20048 
 
20049 
class getOrdersForItemIds_result:
20050 
  """
20051 
  Attributes:
20052 
   - success
20053 
  """
20054 
 
20055 
  thrift_spec = (
20056 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20057 
  )
20058 
 
20059 
  def __init__(self, success=None,):
20060 
    self.success = success
20061 
 
20062 
  def read(self, iprot):
20063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20065 
      return
20066 
    iprot.readStructBegin()
20067 
    while True:
20068 
      (fname, ftype, fid) = iprot.readFieldBegin()
20069 
      if ftype == TType.STOP:
20070 
        break
20071 
      if fid == 0:
20072 
        if ftype == TType.LIST:
20073 
          self.success = []
6188 rajveer 20074 
          (_etype497, _size494) = iprot.readListBegin()
20075 
          for _i498 in xrange(_size494):
20076 
            _elem499 = Order()
20077 
            _elem499.read(iprot)
20078 
            self.success.append(_elem499)
4295 varun.gupt 20079 
          iprot.readListEnd()
20080 
        else:
20081 
          iprot.skip(ftype)
20082 
      else:
20083 
        iprot.skip(ftype)
20084 
      iprot.readFieldEnd()
20085 
    iprot.readStructEnd()
20086 
 
20087 
  def write(self, oprot):
20088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20090 
      return
20091 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20092 
    if self.success is not None:
20093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20094 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20095 
      for iter500 in self.success:
20096 
        iter500.write(oprot)
4295 varun.gupt 20097 
      oprot.writeListEnd()
20098 
      oprot.writeFieldEnd()
20099 
    oprot.writeFieldStop()
20100 
    oprot.writeStructEnd()
20101 
 
20102 
  def validate(self):
20103 
    return
20104 
 
20105 
 
20106 
  def __repr__(self):
20107 
    L = ['%s=%r' % (key, value)
20108 
      for key, value in self.__dict__.iteritems()]
20109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20110 
 
20111 
  def __eq__(self, other):
20112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20113 
 
20114 
  def __ne__(self, other):
20115 
    return not (self == other)
20116 
 
4247 rajveer 20117 
class markOrderCancellationRequestReceived_args:
20118 
  """
20119 
  Attributes:
20120 
   - orderId
20121 
  """
20122 
 
20123 
  thrift_spec = (
20124 
    None, # 0
20125 
    (1, TType.I64, 'orderId', None, None, ), # 1
20126 
  )
20127 
 
20128 
  def __init__(self, orderId=None,):
20129 
    self.orderId = orderId
20130 
 
20131 
  def read(self, iprot):
20132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20134 
      return
20135 
    iprot.readStructBegin()
20136 
    while True:
20137 
      (fname, ftype, fid) = iprot.readFieldBegin()
20138 
      if ftype == TType.STOP:
20139 
        break
20140 
      if fid == 1:
20141 
        if ftype == TType.I64:
20142 
          self.orderId = iprot.readI64();
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20155 
    if self.orderId is not None:
20156 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20157 
      oprot.writeI64(self.orderId)
20158 
      oprot.writeFieldEnd()
20159 
    oprot.writeFieldStop()
20160 
    oprot.writeStructEnd()
20161 
 
20162 
  def validate(self):
20163 
    return
20164 
 
20165 
 
20166 
  def __repr__(self):
20167 
    L = ['%s=%r' % (key, value)
20168 
      for key, value in self.__dict__.iteritems()]
20169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20170 
 
20171 
  def __eq__(self, other):
20172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20173 
 
20174 
  def __ne__(self, other):
20175 
    return not (self == other)
20176 
 
20177 
class markOrderCancellationRequestReceived_result:
20178 
  """
20179 
  Attributes:
20180 
   - ex
20181 
  """
20182 
 
20183 
  thrift_spec = (
20184 
    None, # 0
20185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20186 
  )
20187 
 
20188 
  def __init__(self, ex=None,):
20189 
    self.ex = ex
20190 
 
20191 
  def read(self, iprot):
20192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20194 
      return
20195 
    iprot.readStructBegin()
20196 
    while True:
20197 
      (fname, ftype, fid) = iprot.readFieldBegin()
20198 
      if ftype == TType.STOP:
20199 
        break
20200 
      if fid == 1:
20201 
        if ftype == TType.STRUCT:
20202 
          self.ex = TransactionServiceException()
20203 
          self.ex.read(iprot)
20204 
        else:
20205 
          iprot.skip(ftype)
20206 
      else:
20207 
        iprot.skip(ftype)
20208 
      iprot.readFieldEnd()
20209 
    iprot.readStructEnd()
20210 
 
20211 
  def write(self, oprot):
20212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20214 
      return
20215 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20216 
    if self.ex is not None:
20217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20218 
      self.ex.write(oprot)
20219 
      oprot.writeFieldEnd()
20220 
    oprot.writeFieldStop()
20221 
    oprot.writeStructEnd()
20222 
 
20223 
  def validate(self):
20224 
    return
20225 
 
20226 
 
20227 
  def __repr__(self):
20228 
    L = ['%s=%r' % (key, value)
20229 
      for key, value in self.__dict__.iteritems()]
20230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20231 
 
20232 
  def __eq__(self, other):
20233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20234 
 
20235 
  def __ne__(self, other):
20236 
    return not (self == other)
20237 
 
20238 
class markOrderCancellationRequestConfirmed_args:
20239 
  """
20240 
  Attributes:
20241 
   - orderId
20242 
  """
20243 
 
20244 
  thrift_spec = (
20245 
    None, # 0
20246 
    (1, TType.I64, 'orderId', None, None, ), # 1
20247 
  )
20248 
 
20249 
  def __init__(self, orderId=None,):
20250 
    self.orderId = orderId
20251 
 
20252 
  def read(self, iprot):
20253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20255 
      return
20256 
    iprot.readStructBegin()
20257 
    while True:
20258 
      (fname, ftype, fid) = iprot.readFieldBegin()
20259 
      if ftype == TType.STOP:
20260 
        break
20261 
      if fid == 1:
20262 
        if ftype == TType.I64:
20263 
          self.orderId = iprot.readI64();
20264 
        else:
20265 
          iprot.skip(ftype)
20266 
      else:
20267 
        iprot.skip(ftype)
20268 
      iprot.readFieldEnd()
20269 
    iprot.readStructEnd()
20270 
 
20271 
  def write(self, oprot):
20272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20274 
      return
20275 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20276 
    if self.orderId is not None:
20277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20278 
      oprot.writeI64(self.orderId)
20279 
      oprot.writeFieldEnd()
20280 
    oprot.writeFieldStop()
20281 
    oprot.writeStructEnd()
20282 
 
20283 
  def validate(self):
20284 
    return
20285 
 
20286 
 
20287 
  def __repr__(self):
20288 
    L = ['%s=%r' % (key, value)
20289 
      for key, value in self.__dict__.iteritems()]
20290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20291 
 
20292 
  def __eq__(self, other):
20293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20294 
 
20295 
  def __ne__(self, other):
20296 
    return not (self == other)
20297 
 
20298 
class markOrderCancellationRequestConfirmed_result:
20299 
  """
20300 
  Attributes:
20301 
   - ex
20302 
  """
20303 
 
20304 
  thrift_spec = (
20305 
    None, # 0
20306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20307 
  )
20308 
 
20309 
  def __init__(self, ex=None,):
20310 
    self.ex = ex
20311 
 
20312 
  def read(self, iprot):
20313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20315 
      return
20316 
    iprot.readStructBegin()
20317 
    while True:
20318 
      (fname, ftype, fid) = iprot.readFieldBegin()
20319 
      if ftype == TType.STOP:
20320 
        break
20321 
      if fid == 1:
20322 
        if ftype == TType.STRUCT:
20323 
          self.ex = TransactionServiceException()
20324 
          self.ex.read(iprot)
20325 
        else:
20326 
          iprot.skip(ftype)
20327 
      else:
20328 
        iprot.skip(ftype)
20329 
      iprot.readFieldEnd()
20330 
    iprot.readStructEnd()
20331 
 
20332 
  def write(self, oprot):
20333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20335 
      return
20336 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20337 
    if self.ex is not None:
20338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20339 
      self.ex.write(oprot)
20340 
      oprot.writeFieldEnd()
20341 
    oprot.writeFieldStop()
20342 
    oprot.writeStructEnd()
20343 
 
20344 
  def validate(self):
20345 
    return
20346 
 
20347 
 
20348 
  def __repr__(self):
20349 
    L = ['%s=%r' % (key, value)
20350 
      for key, value in self.__dict__.iteritems()]
20351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20352 
 
20353 
  def __eq__(self, other):
20354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20355 
 
20356 
  def __ne__(self, other):
20357 
    return not (self == other)
20358 
 
20359 
class markOrderCancellationRequestDenied_args:
20360 
  """
20361 
  Attributes:
20362 
   - orderId
20363 
  """
20364 
 
20365 
  thrift_spec = (
20366 
    None, # 0
20367 
    (1, TType.I64, 'orderId', None, None, ), # 1
20368 
  )
20369 
 
20370 
  def __init__(self, orderId=None,):
20371 
    self.orderId = orderId
20372 
 
20373 
  def read(self, iprot):
20374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20376 
      return
20377 
    iprot.readStructBegin()
20378 
    while True:
20379 
      (fname, ftype, fid) = iprot.readFieldBegin()
20380 
      if ftype == TType.STOP:
20381 
        break
20382 
      if fid == 1:
20383 
        if ftype == TType.I64:
20384 
          self.orderId = iprot.readI64();
20385 
        else:
20386 
          iprot.skip(ftype)
20387 
      else:
20388 
        iprot.skip(ftype)
20389 
      iprot.readFieldEnd()
20390 
    iprot.readStructEnd()
20391 
 
20392 
  def write(self, oprot):
20393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20395 
      return
20396 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20397 
    if self.orderId is not None:
20398 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20399 
      oprot.writeI64(self.orderId)
20400 
      oprot.writeFieldEnd()
20401 
    oprot.writeFieldStop()
20402 
    oprot.writeStructEnd()
20403 
 
20404 
  def validate(self):
20405 
    return
20406 
 
20407 
 
20408 
  def __repr__(self):
20409 
    L = ['%s=%r' % (key, value)
20410 
      for key, value in self.__dict__.iteritems()]
20411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20412 
 
20413 
  def __eq__(self, other):
20414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20415 
 
20416 
  def __ne__(self, other):
20417 
    return not (self == other)
20418 
 
20419 
class markOrderCancellationRequestDenied_result:
20420 
  """
20421 
  Attributes:
20422 
   - ex
20423 
  """
20424 
 
20425 
  thrift_spec = (
20426 
    None, # 0
20427 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20428 
  )
20429 
 
20430 
  def __init__(self, ex=None,):
20431 
    self.ex = ex
20432 
 
20433 
  def read(self, iprot):
20434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20436 
      return
20437 
    iprot.readStructBegin()
20438 
    while True:
20439 
      (fname, ftype, fid) = iprot.readFieldBegin()
20440 
      if ftype == TType.STOP:
20441 
        break
20442 
      if fid == 1:
20443 
        if ftype == TType.STRUCT:
20444 
          self.ex = TransactionServiceException()
20445 
          self.ex.read(iprot)
20446 
        else:
20447 
          iprot.skip(ftype)
20448 
      else:
20449 
        iprot.skip(ftype)
20450 
      iprot.readFieldEnd()
20451 
    iprot.readStructEnd()
20452 
 
20453 
  def write(self, oprot):
20454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20456 
      return
20457 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20458 
    if self.ex is not None:
20459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20460 
      self.ex.write(oprot)
20461 
      oprot.writeFieldEnd()
20462 
    oprot.writeFieldStop()
20463 
    oprot.writeStructEnd()
20464 
 
20465 
  def validate(self):
20466 
    return
20467 
 
20468 
 
20469 
  def __repr__(self):
20470 
    L = ['%s=%r' % (key, value)
20471 
      for key, value in self.__dict__.iteritems()]
20472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20473 
 
20474 
  def __eq__(self, other):
20475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20476 
 
20477 
  def __ne__(self, other):
20478 
    return not (self == other)
20479 
 
4258 rajveer 20480 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20481 
  """
20482 
  Attributes:
4258 rajveer 20483 
   - transactionId
4247 rajveer 20484 
  """
20485 
 
20486 
  thrift_spec = (
20487 
    None, # 0
4258 rajveer 20488 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20489 
  )
20490 
 
4258 rajveer 20491 
  def __init__(self, transactionId=None,):
20492 
    self.transactionId = transactionId
4247 rajveer 20493 
 
20494 
  def read(self, iprot):
20495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20497 
      return
20498 
    iprot.readStructBegin()
20499 
    while True:
20500 
      (fname, ftype, fid) = iprot.readFieldBegin()
20501 
      if ftype == TType.STOP:
20502 
        break
20503 
      if fid == 1:
20504 
        if ftype == TType.I64:
4258 rajveer 20505 
          self.transactionId = iprot.readI64();
4247 rajveer 20506 
        else:
20507 
          iprot.skip(ftype)
20508 
      else:
20509 
        iprot.skip(ftype)
20510 
      iprot.readFieldEnd()
20511 
    iprot.readStructEnd()
20512 
 
20513 
  def write(self, oprot):
20514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20516 
      return
4258 rajveer 20517 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20518 
    if self.transactionId is not None:
20519 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20520 
      oprot.writeI64(self.transactionId)
4247 rajveer 20521 
      oprot.writeFieldEnd()
20522 
    oprot.writeFieldStop()
20523 
    oprot.writeStructEnd()
20524 
 
20525 
  def validate(self):
20526 
    return
20527 
 
20528 
 
20529 
  def __repr__(self):
20530 
    L = ['%s=%r' % (key, value)
20531 
      for key, value in self.__dict__.iteritems()]
20532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20533 
 
20534 
  def __eq__(self, other):
20535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20536 
 
20537 
  def __ne__(self, other):
20538 
    return not (self == other)
20539 
 
4258 rajveer 20540 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20541 
  """
20542 
  Attributes:
20543 
   - ex
20544 
  """
20545 
 
20546 
  thrift_spec = (
20547 
    None, # 0
20548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20549 
  )
20550 
 
20551 
  def __init__(self, ex=None,):
20552 
    self.ex = ex
20553 
 
20554 
  def read(self, iprot):
20555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20557 
      return
20558 
    iprot.readStructBegin()
20559 
    while True:
20560 
      (fname, ftype, fid) = iprot.readFieldBegin()
20561 
      if ftype == TType.STOP:
20562 
        break
20563 
      if fid == 1:
20564 
        if ftype == TType.STRUCT:
20565 
          self.ex = TransactionServiceException()
20566 
          self.ex.read(iprot)
20567 
        else:
20568 
          iprot.skip(ftype)
20569 
      else:
20570 
        iprot.skip(ftype)
20571 
      iprot.readFieldEnd()
20572 
    iprot.readStructEnd()
20573 
 
20574 
  def write(self, oprot):
20575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20577 
      return
4258 rajveer 20578 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20579 
    if self.ex is not None:
20580 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20581 
      self.ex.write(oprot)
20582 
      oprot.writeFieldEnd()
20583 
    oprot.writeFieldStop()
20584 
    oprot.writeStructEnd()
20585 
 
20586 
  def validate(self):
20587 
    return
20588 
 
20589 
 
20590 
  def __repr__(self):
20591 
    L = ['%s=%r' % (key, value)
20592 
      for key, value in self.__dict__.iteritems()]
20593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20594 
 
20595 
  def __eq__(self, other):
20596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20597 
 
20598 
  def __ne__(self, other):
20599 
    return not (self == other)
4259 anupam.sin 20600 
 
20601 
class refundTransaction_args:
20602 
  """
20603 
  Attributes:
20604 
   - transactionId
20605 
   - refundedBy
20606 
   - reason
20607 
  """
20608 
 
20609 
  thrift_spec = (
20610 
    None, # 0
20611 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20612 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20613 
    (3, TType.STRING, 'reason', None, None, ), # 3
20614 
  )
20615 
 
20616 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20617 
    self.transactionId = transactionId
20618 
    self.refundedBy = refundedBy
20619 
    self.reason = reason
20620 
 
20621 
  def read(self, iprot):
20622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20624 
      return
20625 
    iprot.readStructBegin()
20626 
    while True:
20627 
      (fname, ftype, fid) = iprot.readFieldBegin()
20628 
      if ftype == TType.STOP:
20629 
        break
20630 
      if fid == 1:
20631 
        if ftype == TType.I64:
20632 
          self.transactionId = iprot.readI64();
20633 
        else:
20634 
          iprot.skip(ftype)
20635 
      elif fid == 2:
20636 
        if ftype == TType.STRING:
20637 
          self.refundedBy = iprot.readString();
20638 
        else:
20639 
          iprot.skip(ftype)
20640 
      elif fid == 3:
20641 
        if ftype == TType.STRING:
20642 
          self.reason = iprot.readString();
20643 
        else:
20644 
          iprot.skip(ftype)
20645 
      else:
20646 
        iprot.skip(ftype)
20647 
      iprot.readFieldEnd()
20648 
    iprot.readStructEnd()
20649 
 
20650 
  def write(self, oprot):
20651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20653 
      return
20654 
    oprot.writeStructBegin('refundTransaction_args')
20655 
    if self.transactionId is not None:
20656 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20657 
      oprot.writeI64(self.transactionId)
20658 
      oprot.writeFieldEnd()
20659 
    if self.refundedBy is not None:
20660 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20661 
      oprot.writeString(self.refundedBy)
20662 
      oprot.writeFieldEnd()
20663 
    if self.reason is not None:
20664 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20665 
      oprot.writeString(self.reason)
20666 
      oprot.writeFieldEnd()
20667 
    oprot.writeFieldStop()
20668 
    oprot.writeStructEnd()
20669 
 
20670 
  def validate(self):
20671 
    return
20672 
 
20673 
 
20674 
  def __repr__(self):
20675 
    L = ['%s=%r' % (key, value)
20676 
      for key, value in self.__dict__.iteritems()]
20677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20678 
 
20679 
  def __eq__(self, other):
20680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20681 
 
20682 
  def __ne__(self, other):
20683 
    return not (self == other)
20684 
 
20685 
class refundTransaction_result:
20686 
  """
20687 
  Attributes:
20688 
   - ex
20689 
  """
20690 
 
20691 
  thrift_spec = (
20692 
    None, # 0
20693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20694 
  )
20695 
 
20696 
  def __init__(self, ex=None,):
20697 
    self.ex = ex
20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 1:
20709 
        if ftype == TType.STRUCT:
20710 
          self.ex = TransactionServiceException()
20711 
          self.ex.read(iprot)
20712 
        else:
20713 
          iprot.skip(ftype)
20714 
      else:
20715 
        iprot.skip(ftype)
20716 
      iprot.readFieldEnd()
20717 
    iprot.readStructEnd()
20718 
 
20719 
  def write(self, oprot):
20720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20722 
      return
20723 
    oprot.writeStructBegin('refundTransaction_result')
20724 
    if self.ex is not None:
20725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20726 
      self.ex.write(oprot)
20727 
      oprot.writeFieldEnd()
20728 
    oprot.writeFieldStop()
20729 
    oprot.writeStructEnd()
20730 
 
20731 
  def validate(self):
20732 
    return
20733 
 
20734 
 
20735 
  def __repr__(self):
20736 
    L = ['%s=%r' % (key, value)
20737 
      for key, value in self.__dict__.iteritems()]
20738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20739 
 
20740 
  def __eq__(self, other):
20741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20742 
 
20743 
  def __ne__(self, other):
20744 
    return not (self == other)
4285 rajveer 20745 
 
4324 mandeep.dh 20746 
class updateShipmentAddress_args:
20747 
  """
20748 
  Attributes:
20749 
   - orderId
20750 
   - addressId
20751 
  """
20752 
 
20753 
  thrift_spec = (
20754 
    None, # 0
20755 
    (1, TType.I64, 'orderId', None, None, ), # 1
20756 
    (2, TType.I64, 'addressId', None, None, ), # 2
20757 
  )
20758 
 
20759 
  def __init__(self, orderId=None, addressId=None,):
20760 
    self.orderId = orderId
20761 
    self.addressId = addressId
20762 
 
20763 
  def read(self, iprot):
20764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20766 
      return
20767 
    iprot.readStructBegin()
20768 
    while True:
20769 
      (fname, ftype, fid) = iprot.readFieldBegin()
20770 
      if ftype == TType.STOP:
20771 
        break
20772 
      if fid == 1:
20773 
        if ftype == TType.I64:
20774 
          self.orderId = iprot.readI64();
20775 
        else:
20776 
          iprot.skip(ftype)
20777 
      elif fid == 2:
20778 
        if ftype == TType.I64:
20779 
          self.addressId = iprot.readI64();
20780 
        else:
20781 
          iprot.skip(ftype)
20782 
      else:
20783 
        iprot.skip(ftype)
20784 
      iprot.readFieldEnd()
20785 
    iprot.readStructEnd()
20786 
 
20787 
  def write(self, oprot):
20788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20790 
      return
20791 
    oprot.writeStructBegin('updateShipmentAddress_args')
20792 
    if self.orderId is not None:
20793 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20794 
      oprot.writeI64(self.orderId)
20795 
      oprot.writeFieldEnd()
20796 
    if self.addressId is not None:
20797 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20798 
      oprot.writeI64(self.addressId)
20799 
      oprot.writeFieldEnd()
20800 
    oprot.writeFieldStop()
20801 
    oprot.writeStructEnd()
20802 
 
20803 
  def validate(self):
20804 
    return
20805 
 
20806 
 
20807 
  def __repr__(self):
20808 
    L = ['%s=%r' % (key, value)
20809 
      for key, value in self.__dict__.iteritems()]
20810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20811 
 
20812 
  def __eq__(self, other):
20813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20814 
 
20815 
  def __ne__(self, other):
20816 
    return not (self == other)
20817 
 
20818 
class updateShipmentAddress_result:
20819 
  """
20820 
  Attributes:
20821 
   - ex
20822 
  """
20823 
 
20824 
  thrift_spec = (
20825 
    None, # 0
20826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20827 
  )
20828 
 
20829 
  def __init__(self, ex=None,):
20830 
    self.ex = ex
20831 
 
20832 
  def read(self, iprot):
20833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20835 
      return
20836 
    iprot.readStructBegin()
20837 
    while True:
20838 
      (fname, ftype, fid) = iprot.readFieldBegin()
20839 
      if ftype == TType.STOP:
20840 
        break
20841 
      if fid == 1:
20842 
        if ftype == TType.STRUCT:
20843 
          self.ex = TransactionServiceException()
20844 
          self.ex.read(iprot)
20845 
        else:
20846 
          iprot.skip(ftype)
20847 
      else:
20848 
        iprot.skip(ftype)
20849 
      iprot.readFieldEnd()
20850 
    iprot.readStructEnd()
20851 
 
20852 
  def write(self, oprot):
20853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20855 
      return
20856 
    oprot.writeStructBegin('updateShipmentAddress_result')
20857 
    if self.ex is not None:
20858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20859 
      self.ex.write(oprot)
20860 
      oprot.writeFieldEnd()
20861 
    oprot.writeFieldStop()
20862 
    oprot.writeStructEnd()
20863 
 
20864 
  def validate(self):
20865 
    return
20866 
 
20867 
 
20868 
  def __repr__(self):
20869 
    L = ['%s=%r' % (key, value)
20870 
      for key, value in self.__dict__.iteritems()]
20871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20872 
 
20873 
  def __eq__(self, other):
20874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20875 
 
20876 
  def __ne__(self, other):
20877 
    return not (self == other)
20878 
 
4285 rajveer 20879 
class acceptOrdersForItemId_args:
20880 
  """
20881 
  Attributes:
20882 
   - itemId
20883 
   - inventory
20884 
  """
20885 
 
20886 
  thrift_spec = (
20887 
    None, # 0
20888 
    (1, TType.I64, 'itemId', None, None, ), # 1
20889 
    (2, TType.I64, 'inventory', None, None, ), # 2
20890 
  )
20891 
 
20892 
  def __init__(self, itemId=None, inventory=None,):
20893 
    self.itemId = itemId
20894 
    self.inventory = inventory
20895 
 
20896 
  def read(self, iprot):
20897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20899 
      return
20900 
    iprot.readStructBegin()
20901 
    while True:
20902 
      (fname, ftype, fid) = iprot.readFieldBegin()
20903 
      if ftype == TType.STOP:
20904 
        break
20905 
      if fid == 1:
20906 
        if ftype == TType.I64:
20907 
          self.itemId = iprot.readI64();
20908 
        else:
20909 
          iprot.skip(ftype)
20910 
      elif fid == 2:
20911 
        if ftype == TType.I64:
20912 
          self.inventory = iprot.readI64();
20913 
        else:
20914 
          iprot.skip(ftype)
20915 
      else:
20916 
        iprot.skip(ftype)
20917 
      iprot.readFieldEnd()
20918 
    iprot.readStructEnd()
20919 
 
20920 
  def write(self, oprot):
20921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20923 
      return
20924 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20925 
    if self.itemId is not None:
20926 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20927 
      oprot.writeI64(self.itemId)
20928 
      oprot.writeFieldEnd()
20929 
    if self.inventory is not None:
20930 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20931 
      oprot.writeI64(self.inventory)
20932 
      oprot.writeFieldEnd()
20933 
    oprot.writeFieldStop()
20934 
    oprot.writeStructEnd()
20935 
 
20936 
  def validate(self):
20937 
    return
20938 
 
20939 
 
20940 
  def __repr__(self):
20941 
    L = ['%s=%r' % (key, value)
20942 
      for key, value in self.__dict__.iteritems()]
20943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20944 
 
20945 
  def __eq__(self, other):
20946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20947 
 
20948 
  def __ne__(self, other):
20949 
    return not (self == other)
20950 
 
20951 
class acceptOrdersForItemId_result:
20952 
  """
20953 
  Attributes:
20954 
   - success
20955 
   - ex
20956 
  """
20957 
 
20958 
  thrift_spec = (
20959 
    (0, TType.BOOL, 'success', None, None, ), # 0
20960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20961 
  )
20962 
 
20963 
  def __init__(self, success=None, ex=None,):
20964 
    self.success = success
20965 
    self.ex = ex
20966 
 
20967 
  def read(self, iprot):
20968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20970 
      return
20971 
    iprot.readStructBegin()
20972 
    while True:
20973 
      (fname, ftype, fid) = iprot.readFieldBegin()
20974 
      if ftype == TType.STOP:
20975 
        break
20976 
      if fid == 0:
20977 
        if ftype == TType.BOOL:
20978 
          self.success = iprot.readBool();
20979 
        else:
20980 
          iprot.skip(ftype)
20981 
      elif fid == 1:
20982 
        if ftype == TType.STRUCT:
20983 
          self.ex = TransactionServiceException()
20984 
          self.ex.read(iprot)
20985 
        else:
20986 
          iprot.skip(ftype)
20987 
      else:
20988 
        iprot.skip(ftype)
20989 
      iprot.readFieldEnd()
20990 
    iprot.readStructEnd()
20991 
 
20992 
  def write(self, oprot):
20993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20995 
      return
20996 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20997 
    if self.success is not None:
20998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20999 
      oprot.writeBool(self.success)
21000 
      oprot.writeFieldEnd()
21001 
    if self.ex is not None:
21002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21003 
      self.ex.write(oprot)
21004 
      oprot.writeFieldEnd()
21005 
    oprot.writeFieldStop()
21006 
    oprot.writeStructEnd()
21007 
 
21008 
  def validate(self):
21009 
    return
21010 
 
21011 
 
21012 
  def __repr__(self):
21013 
    L = ['%s=%r' % (key, value)
21014 
      for key, value in self.__dict__.iteritems()]
21015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21016 
 
21017 
  def __eq__(self, other):
21018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21019 
 
21020 
  def __ne__(self, other):
21021 
    return not (self == other)
4303 rajveer 21022 
 
21023 
class markOrdersAsPORaised_args:
21024 
  """
21025 
  Attributes:
21026 
   - vendorId
21027 
   - itemId
21028 
   - quantity
21029 
   - estimate
4369 rajveer 21030 
   - isReminder
4303 rajveer 21031 
  """
21032 
 
21033 
  thrift_spec = (
21034 
    None, # 0
21035 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21036 
    (2, TType.I64, 'itemId', None, None, ), # 2
21037 
    (3, TType.I64, 'quantity', None, None, ), # 3
21038 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21039 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21040 
  )
21041 
 
4369 rajveer 21042 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21043 
    self.vendorId = vendorId
21044 
    self.itemId = itemId
21045 
    self.quantity = quantity
21046 
    self.estimate = estimate
4369 rajveer 21047 
    self.isReminder = isReminder
4303 rajveer 21048 
 
21049 
  def read(self, iprot):
21050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21052 
      return
21053 
    iprot.readStructBegin()
21054 
    while True:
21055 
      (fname, ftype, fid) = iprot.readFieldBegin()
21056 
      if ftype == TType.STOP:
21057 
        break
21058 
      if fid == 1:
21059 
        if ftype == TType.I64:
21060 
          self.vendorId = iprot.readI64();
21061 
        else:
21062 
          iprot.skip(ftype)
21063 
      elif fid == 2:
21064 
        if ftype == TType.I64:
21065 
          self.itemId = iprot.readI64();
21066 
        else:
21067 
          iprot.skip(ftype)
21068 
      elif fid == 3:
21069 
        if ftype == TType.I64:
21070 
          self.quantity = iprot.readI64();
21071 
        else:
21072 
          iprot.skip(ftype)
21073 
      elif fid == 4:
21074 
        if ftype == TType.I64:
21075 
          self.estimate = iprot.readI64();
21076 
        else:
21077 
          iprot.skip(ftype)
4369 rajveer 21078 
      elif fid == 5:
21079 
        if ftype == TType.BOOL:
21080 
          self.isReminder = iprot.readBool();
21081 
        else:
21082 
          iprot.skip(ftype)
4303 rajveer 21083 
      else:
21084 
        iprot.skip(ftype)
21085 
      iprot.readFieldEnd()
21086 
    iprot.readStructEnd()
21087 
 
21088 
  def write(self, oprot):
21089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21091 
      return
21092 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21093 
    if self.vendorId is not None:
21094 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21095 
      oprot.writeI64(self.vendorId)
21096 
      oprot.writeFieldEnd()
21097 
    if self.itemId is not None:
21098 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21099 
      oprot.writeI64(self.itemId)
21100 
      oprot.writeFieldEnd()
21101 
    if self.quantity is not None:
21102 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21103 
      oprot.writeI64(self.quantity)
21104 
      oprot.writeFieldEnd()
21105 
    if self.estimate is not None:
21106 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21107 
      oprot.writeI64(self.estimate)
21108 
      oprot.writeFieldEnd()
4369 rajveer 21109 
    if self.isReminder is not None:
21110 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21111 
      oprot.writeBool(self.isReminder)
21112 
      oprot.writeFieldEnd()
4303 rajveer 21113 
    oprot.writeFieldStop()
21114 
    oprot.writeStructEnd()
21115 
 
21116 
  def validate(self):
21117 
    return
21118 
 
21119 
 
21120 
  def __repr__(self):
21121 
    L = ['%s=%r' % (key, value)
21122 
      for key, value in self.__dict__.iteritems()]
21123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21124 
 
21125 
  def __eq__(self, other):
21126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21127 
 
21128 
  def __ne__(self, other):
21129 
    return not (self == other)
21130 
 
21131 
class markOrdersAsPORaised_result:
21132 
  """
21133 
  Attributes:
21134 
   - ex
21135 
  """
21136 
 
21137 
  thrift_spec = (
21138 
    None, # 0
21139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21140 
  )
21141 
 
21142 
  def __init__(self, ex=None,):
21143 
    self.ex = ex
21144 
 
21145 
  def read(self, iprot):
21146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21148 
      return
21149 
    iprot.readStructBegin()
21150 
    while True:
21151 
      (fname, ftype, fid) = iprot.readFieldBegin()
21152 
      if ftype == TType.STOP:
21153 
        break
21154 
      if fid == 1:
21155 
        if ftype == TType.STRUCT:
21156 
          self.ex = TransactionServiceException()
21157 
          self.ex.read(iprot)
21158 
        else:
21159 
          iprot.skip(ftype)
21160 
      else:
21161 
        iprot.skip(ftype)
21162 
      iprot.readFieldEnd()
21163 
    iprot.readStructEnd()
21164 
 
21165 
  def write(self, oprot):
21166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21168 
      return
21169 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21170 
    if self.ex is not None:
21171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21172 
      self.ex.write(oprot)
21173 
      oprot.writeFieldEnd()
21174 
    oprot.writeFieldStop()
21175 
    oprot.writeStructEnd()
21176 
 
21177 
  def validate(self):
21178 
    return
21179 
 
21180 
 
21181 
  def __repr__(self):
21182 
    L = ['%s=%r' % (key, value)
21183 
      for key, value in self.__dict__.iteritems()]
21184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21185 
 
21186 
  def __eq__(self, other):
21187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21188 
 
21189 
  def __ne__(self, other):
21190 
    return not (self == other)
21191 
 
21192 
class markOrdersAsReversalInitiated_args:
21193 
  """
21194 
  Attributes:
21195 
   - vendorId
21196 
   - itemId
21197 
   - quantity
21198 
   - estimate
4369 rajveer 21199 
   - isReminder
4303 rajveer 21200 
  """
21201 
 
21202 
  thrift_spec = (
21203 
    None, # 0
21204 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21205 
    (2, TType.I64, 'itemId', None, None, ), # 2
21206 
    (3, TType.I64, 'quantity', None, None, ), # 3
21207 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21208 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21209 
  )
21210 
 
4369 rajveer 21211 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21212 
    self.vendorId = vendorId
21213 
    self.itemId = itemId
21214 
    self.quantity = quantity
21215 
    self.estimate = estimate
4369 rajveer 21216 
    self.isReminder = isReminder
4303 rajveer 21217 
 
21218 
  def read(self, iprot):
21219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21221 
      return
21222 
    iprot.readStructBegin()
21223 
    while True:
21224 
      (fname, ftype, fid) = iprot.readFieldBegin()
21225 
      if ftype == TType.STOP:
21226 
        break
21227 
      if fid == 1:
21228 
        if ftype == TType.I64:
21229 
          self.vendorId = iprot.readI64();
21230 
        else:
21231 
          iprot.skip(ftype)
21232 
      elif fid == 2:
21233 
        if ftype == TType.I64:
21234 
          self.itemId = iprot.readI64();
21235 
        else:
21236 
          iprot.skip(ftype)
21237 
      elif fid == 3:
21238 
        if ftype == TType.I64:
21239 
          self.quantity = iprot.readI64();
21240 
        else:
21241 
          iprot.skip(ftype)
21242 
      elif fid == 4:
21243 
        if ftype == TType.I64:
21244 
          self.estimate = iprot.readI64();
21245 
        else:
21246 
          iprot.skip(ftype)
4369 rajveer 21247 
      elif fid == 5:
21248 
        if ftype == TType.BOOL:
21249 
          self.isReminder = iprot.readBool();
21250 
        else:
21251 
          iprot.skip(ftype)
4303 rajveer 21252 
      else:
21253 
        iprot.skip(ftype)
21254 
      iprot.readFieldEnd()
21255 
    iprot.readStructEnd()
21256 
 
21257 
  def write(self, oprot):
21258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21260 
      return
21261 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21262 
    if self.vendorId is not None:
21263 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21264 
      oprot.writeI64(self.vendorId)
21265 
      oprot.writeFieldEnd()
21266 
    if self.itemId is not None:
21267 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21268 
      oprot.writeI64(self.itemId)
21269 
      oprot.writeFieldEnd()
21270 
    if self.quantity is not None:
21271 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21272 
      oprot.writeI64(self.quantity)
21273 
      oprot.writeFieldEnd()
21274 
    if self.estimate is not None:
21275 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21276 
      oprot.writeI64(self.estimate)
21277 
      oprot.writeFieldEnd()
4369 rajveer 21278 
    if self.isReminder is not None:
21279 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21280 
      oprot.writeBool(self.isReminder)
21281 
      oprot.writeFieldEnd()
4303 rajveer 21282 
    oprot.writeFieldStop()
21283 
    oprot.writeStructEnd()
21284 
 
21285 
  def validate(self):
21286 
    return
21287 
 
21288 
 
21289 
  def __repr__(self):
21290 
    L = ['%s=%r' % (key, value)
21291 
      for key, value in self.__dict__.iteritems()]
21292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21293 
 
21294 
  def __eq__(self, other):
21295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21296 
 
21297 
  def __ne__(self, other):
21298 
    return not (self == other)
21299 
 
21300 
class markOrdersAsReversalInitiated_result:
21301 
  """
21302 
  Attributes:
21303 
   - ex
21304 
  """
21305 
 
21306 
  thrift_spec = (
21307 
    None, # 0
21308 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21309 
  )
21310 
 
21311 
  def __init__(self, ex=None,):
21312 
    self.ex = ex
21313 
 
21314 
  def read(self, iprot):
21315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21317 
      return
21318 
    iprot.readStructBegin()
21319 
    while True:
21320 
      (fname, ftype, fid) = iprot.readFieldBegin()
21321 
      if ftype == TType.STOP:
21322 
        break
21323 
      if fid == 1:
21324 
        if ftype == TType.STRUCT:
21325 
          self.ex = TransactionServiceException()
21326 
          self.ex.read(iprot)
21327 
        else:
21328 
          iprot.skip(ftype)
21329 
      else:
21330 
        iprot.skip(ftype)
21331 
      iprot.readFieldEnd()
21332 
    iprot.readStructEnd()
21333 
 
21334 
  def write(self, oprot):
21335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21337 
      return
21338 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21339 
    if self.ex is not None:
21340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21341 
      self.ex.write(oprot)
21342 
      oprot.writeFieldEnd()
21343 
    oprot.writeFieldStop()
21344 
    oprot.writeStructEnd()
21345 
 
21346 
  def validate(self):
21347 
    return
21348 
 
21349 
 
21350 
  def __repr__(self):
21351 
    L = ['%s=%r' % (key, value)
21352 
      for key, value in self.__dict__.iteritems()]
21353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21354 
 
21355 
  def __eq__(self, other):
21356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21357 
 
21358 
  def __ne__(self, other):
21359 
    return not (self == other)
21360 
 
21361 
class markOrdersAsNotAvailabke_args:
21362 
  """
21363 
  Attributes:
21364 
   - vendorId
21365 
   - itemId
21366 
   - quantity
21367 
   - estimate
4369 rajveer 21368 
   - isReminder
4303 rajveer 21369 
  """
21370 
 
21371 
  thrift_spec = (
21372 
    None, # 0
21373 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21374 
    (2, TType.I64, 'itemId', None, None, ), # 2
21375 
    (3, TType.I64, 'quantity', None, None, ), # 3
21376 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21377 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21378 
  )
21379 
 
4369 rajveer 21380 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21381 
    self.vendorId = vendorId
21382 
    self.itemId = itemId
21383 
    self.quantity = quantity
21384 
    self.estimate = estimate
4369 rajveer 21385 
    self.isReminder = isReminder
4303 rajveer 21386 
 
21387 
  def read(self, iprot):
21388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21390 
      return
21391 
    iprot.readStructBegin()
21392 
    while True:
21393 
      (fname, ftype, fid) = iprot.readFieldBegin()
21394 
      if ftype == TType.STOP:
21395 
        break
21396 
      if fid == 1:
21397 
        if ftype == TType.I64:
21398 
          self.vendorId = iprot.readI64();
21399 
        else:
21400 
          iprot.skip(ftype)
21401 
      elif fid == 2:
21402 
        if ftype == TType.I64:
21403 
          self.itemId = iprot.readI64();
21404 
        else:
21405 
          iprot.skip(ftype)
21406 
      elif fid == 3:
21407 
        if ftype == TType.I64:
21408 
          self.quantity = iprot.readI64();
21409 
        else:
21410 
          iprot.skip(ftype)
21411 
      elif fid == 4:
21412 
        if ftype == TType.I64:
21413 
          self.estimate = iprot.readI64();
21414 
        else:
21415 
          iprot.skip(ftype)
4369 rajveer 21416 
      elif fid == 5:
21417 
        if ftype == TType.BOOL:
21418 
          self.isReminder = iprot.readBool();
21419 
        else:
21420 
          iprot.skip(ftype)
4303 rajveer 21421 
      else:
21422 
        iprot.skip(ftype)
21423 
      iprot.readFieldEnd()
21424 
    iprot.readStructEnd()
21425 
 
21426 
  def write(self, oprot):
21427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21429 
      return
21430 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21431 
    if self.vendorId is not None:
21432 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21433 
      oprot.writeI64(self.vendorId)
21434 
      oprot.writeFieldEnd()
21435 
    if self.itemId is not None:
21436 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21437 
      oprot.writeI64(self.itemId)
21438 
      oprot.writeFieldEnd()
21439 
    if self.quantity is not None:
21440 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21441 
      oprot.writeI64(self.quantity)
21442 
      oprot.writeFieldEnd()
21443 
    if self.estimate is not None:
21444 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21445 
      oprot.writeI64(self.estimate)
21446 
      oprot.writeFieldEnd()
4369 rajveer 21447 
    if self.isReminder is not None:
21448 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21449 
      oprot.writeBool(self.isReminder)
21450 
      oprot.writeFieldEnd()
4303 rajveer 21451 
    oprot.writeFieldStop()
21452 
    oprot.writeStructEnd()
21453 
 
21454 
  def validate(self):
21455 
    return
21456 
 
21457 
 
21458 
  def __repr__(self):
21459 
    L = ['%s=%r' % (key, value)
21460 
      for key, value in self.__dict__.iteritems()]
21461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21462 
 
21463 
  def __eq__(self, other):
21464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21465 
 
21466 
  def __ne__(self, other):
21467 
    return not (self == other)
21468 
 
21469 
class markOrdersAsNotAvailabke_result:
21470 
  """
21471 
  Attributes:
21472 
   - ex
21473 
  """
21474 
 
21475 
  thrift_spec = (
21476 
    None, # 0
21477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21478 
  )
21479 
 
21480 
  def __init__(self, ex=None,):
21481 
    self.ex = ex
21482 
 
21483 
  def read(self, iprot):
21484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21486 
      return
21487 
    iprot.readStructBegin()
21488 
    while True:
21489 
      (fname, ftype, fid) = iprot.readFieldBegin()
21490 
      if ftype == TType.STOP:
21491 
        break
21492 
      if fid == 1:
21493 
        if ftype == TType.STRUCT:
21494 
          self.ex = TransactionServiceException()
21495 
          self.ex.read(iprot)
21496 
        else:
21497 
          iprot.skip(ftype)
21498 
      else:
21499 
        iprot.skip(ftype)
21500 
      iprot.readFieldEnd()
21501 
    iprot.readStructEnd()
21502 
 
21503 
  def write(self, oprot):
21504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21506 
      return
21507 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21508 
    if self.ex is not None:
21509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21510 
      self.ex.write(oprot)
21511 
      oprot.writeFieldEnd()
21512 
    oprot.writeFieldStop()
21513 
    oprot.writeStructEnd()
21514 
 
21515 
  def validate(self):
21516 
    return
21517 
 
21518 
 
21519 
  def __repr__(self):
21520 
    L = ['%s=%r' % (key, value)
21521 
      for key, value in self.__dict__.iteritems()]
21522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21523 
 
21524 
  def __eq__(self, other):
21525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21526 
 
21527 
  def __ne__(self, other):
21528 
    return not (self == other)
4369 rajveer 21529 
 
21530 
class markOrdersAsTimeout_args:
21531 
  """
21532 
  Attributes:
21533 
   - vendorId
21534 
  """
21535 
 
21536 
  thrift_spec = (
21537 
    None, # 0
21538 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21539 
  )
21540 
 
21541 
  def __init__(self, vendorId=None,):
21542 
    self.vendorId = vendorId
21543 
 
21544 
  def read(self, iprot):
21545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21547 
      return
21548 
    iprot.readStructBegin()
21549 
    while True:
21550 
      (fname, ftype, fid) = iprot.readFieldBegin()
21551 
      if ftype == TType.STOP:
21552 
        break
21553 
      if fid == 1:
21554 
        if ftype == TType.I64:
21555 
          self.vendorId = iprot.readI64();
21556 
        else:
21557 
          iprot.skip(ftype)
21558 
      else:
21559 
        iprot.skip(ftype)
21560 
      iprot.readFieldEnd()
21561 
    iprot.readStructEnd()
21562 
 
21563 
  def write(self, oprot):
21564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21566 
      return
21567 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21568 
    if self.vendorId is not None:
21569 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21570 
      oprot.writeI64(self.vendorId)
21571 
      oprot.writeFieldEnd()
21572 
    oprot.writeFieldStop()
21573 
    oprot.writeStructEnd()
21574 
 
21575 
  def validate(self):
21576 
    return
21577 
 
21578 
 
21579 
  def __repr__(self):
21580 
    L = ['%s=%r' % (key, value)
21581 
      for key, value in self.__dict__.iteritems()]
21582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21583 
 
21584 
  def __eq__(self, other):
21585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21586 
 
21587 
  def __ne__(self, other):
21588 
    return not (self == other)
21589 
 
21590 
class markOrdersAsTimeout_result:
21591 
  """
21592 
  Attributes:
21593 
   - success
21594 
   - ex
21595 
  """
21596 
 
21597 
  thrift_spec = (
21598 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21600 
  )
21601 
 
21602 
  def __init__(self, success=None, ex=None,):
21603 
    self.success = success
21604 
    self.ex = ex
21605 
 
21606 
  def read(self, iprot):
21607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21609 
      return
21610 
    iprot.readStructBegin()
21611 
    while True:
21612 
      (fname, ftype, fid) = iprot.readFieldBegin()
21613 
      if ftype == TType.STOP:
21614 
        break
21615 
      if fid == 0:
21616 
        if ftype == TType.MAP:
21617 
          self.success = {}
6188 rajveer 21618 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21619 
          for _i505 in xrange(_size501):
21620 
            _key506 = iprot.readI32();
21621 
            _val507 = TimeoutSummary()
21622 
            _val507.read(iprot)
21623 
            self.success[_key506] = _val507
4369 rajveer 21624 
          iprot.readMapEnd()
21625 
        else:
21626 
          iprot.skip(ftype)
21627 
      elif fid == 1:
21628 
        if ftype == TType.STRUCT:
21629 
          self.ex = TransactionServiceException()
21630 
          self.ex.read(iprot)
21631 
        else:
21632 
          iprot.skip(ftype)
21633 
      else:
21634 
        iprot.skip(ftype)
21635 
      iprot.readFieldEnd()
21636 
    iprot.readStructEnd()
21637 
 
21638 
  def write(self, oprot):
21639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21641 
      return
21642 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21643 
    if self.success is not None:
21644 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21645 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21646 
      for kiter508,viter509 in self.success.items():
21647 
        oprot.writeI32(kiter508)
21648 
        viter509.write(oprot)
4369 rajveer 21649 
      oprot.writeMapEnd()
21650 
      oprot.writeFieldEnd()
21651 
    if self.ex is not None:
21652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21653 
      self.ex.write(oprot)
21654 
      oprot.writeFieldEnd()
21655 
    oprot.writeFieldStop()
21656 
    oprot.writeStructEnd()
21657 
 
21658 
  def validate(self):
21659 
    return
21660 
 
21661 
 
21662 
  def __repr__(self):
21663 
    L = ['%s=%r' % (key, value)
21664 
      for key, value in self.__dict__.iteritems()]
21665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21666 
 
21667 
  def __eq__(self, other):
21668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21669 
 
21670 
  def __ne__(self, other):
21671 
    return not (self == other)
4386 anupam.sin 21672 
 
4662 rajveer 21673 
class markOrderAsLostInTransit_args:
21674 
  """
21675 
  Attributes:
21676 
   - orderId
21677 
  """
21678 
 
21679 
  thrift_spec = (
21680 
    None, # 0
21681 
    (1, TType.I64, 'orderId', None, None, ), # 1
21682 
  )
21683 
 
21684 
  def __init__(self, orderId=None,):
21685 
    self.orderId = orderId
21686 
 
21687 
  def read(self, iprot):
21688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21690 
      return
21691 
    iprot.readStructBegin()
21692 
    while True:
21693 
      (fname, ftype, fid) = iprot.readFieldBegin()
21694 
      if ftype == TType.STOP:
21695 
        break
21696 
      if fid == 1:
21697 
        if ftype == TType.I64:
21698 
          self.orderId = iprot.readI64();
21699 
        else:
21700 
          iprot.skip(ftype)
21701 
      else:
21702 
        iprot.skip(ftype)
21703 
      iprot.readFieldEnd()
21704 
    iprot.readStructEnd()
21705 
 
21706 
  def write(self, oprot):
21707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21709 
      return
21710 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21711 
    if self.orderId is not None:
21712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21713 
      oprot.writeI64(self.orderId)
21714 
      oprot.writeFieldEnd()
21715 
    oprot.writeFieldStop()
21716 
    oprot.writeStructEnd()
21717 
 
21718 
  def validate(self):
21719 
    return
21720 
 
21721 
 
21722 
  def __repr__(self):
21723 
    L = ['%s=%r' % (key, value)
21724 
      for key, value in self.__dict__.iteritems()]
21725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21726 
 
21727 
  def __eq__(self, other):
21728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21729 
 
21730 
  def __ne__(self, other):
21731 
    return not (self == other)
21732 
 
21733 
class markOrderAsLostInTransit_result:
21734 
  """
21735 
  Attributes:
21736 
   - success
21737 
   - ex
21738 
  """
21739 
 
21740 
  thrift_spec = (
21741 
    (0, TType.BOOL, 'success', None, None, ), # 0
21742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21743 
  )
21744 
 
21745 
  def __init__(self, success=None, ex=None,):
21746 
    self.success = success
21747 
    self.ex = ex
21748 
 
21749 
  def read(self, iprot):
21750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21752 
      return
21753 
    iprot.readStructBegin()
21754 
    while True:
21755 
      (fname, ftype, fid) = iprot.readFieldBegin()
21756 
      if ftype == TType.STOP:
21757 
        break
21758 
      if fid == 0:
21759 
        if ftype == TType.BOOL:
21760 
          self.success = iprot.readBool();
21761 
        else:
21762 
          iprot.skip(ftype)
21763 
      elif fid == 1:
21764 
        if ftype == TType.STRUCT:
21765 
          self.ex = TransactionServiceException()
21766 
          self.ex.read(iprot)
21767 
        else:
21768 
          iprot.skip(ftype)
21769 
      else:
21770 
        iprot.skip(ftype)
21771 
      iprot.readFieldEnd()
21772 
    iprot.readStructEnd()
21773 
 
21774 
  def write(self, oprot):
21775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21777 
      return
21778 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21779 
    if self.success is not None:
21780 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21781 
      oprot.writeBool(self.success)
21782 
      oprot.writeFieldEnd()
21783 
    if self.ex is not None:
21784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21785 
      self.ex.write(oprot)
21786 
      oprot.writeFieldEnd()
21787 
    oprot.writeFieldStop()
21788 
    oprot.writeStructEnd()
21789 
 
21790 
  def validate(self):
21791 
    return
21792 
 
21793 
 
21794 
  def __repr__(self):
21795 
    L = ['%s=%r' % (key, value)
21796 
      for key, value in self.__dict__.iteritems()]
21797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21798 
 
21799 
  def __eq__(self, other):
21800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21801 
 
21802 
  def __ne__(self, other):
21803 
    return not (self == other)
21804 
 
4386 anupam.sin 21805 
class getOrderForAwb_args:
21806 
  """
21807 
  Attributes:
21808 
   - awb
21809 
  """
21810 
 
21811 
  thrift_spec = (
21812 
    None, # 0
21813 
    (1, TType.STRING, 'awb', None, None, ), # 1
21814 
  )
21815 
 
21816 
  def __init__(self, awb=None,):
21817 
    self.awb = awb
21818 
 
21819 
  def read(self, iprot):
21820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21822 
      return
21823 
    iprot.readStructBegin()
21824 
    while True:
21825 
      (fname, ftype, fid) = iprot.readFieldBegin()
21826 
      if ftype == TType.STOP:
21827 
        break
21828 
      if fid == 1:
21829 
        if ftype == TType.STRING:
21830 
          self.awb = iprot.readString();
21831 
        else:
21832 
          iprot.skip(ftype)
21833 
      else:
21834 
        iprot.skip(ftype)
21835 
      iprot.readFieldEnd()
21836 
    iprot.readStructEnd()
21837 
 
21838 
  def write(self, oprot):
21839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21841 
      return
21842 
    oprot.writeStructBegin('getOrderForAwb_args')
21843 
    if self.awb is not None:
21844 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21845 
      oprot.writeString(self.awb)
21846 
      oprot.writeFieldEnd()
21847 
    oprot.writeFieldStop()
21848 
    oprot.writeStructEnd()
21849 
 
21850 
  def validate(self):
21851 
    return
21852 
 
21853 
 
21854 
  def __repr__(self):
21855 
    L = ['%s=%r' % (key, value)
21856 
      for key, value in self.__dict__.iteritems()]
21857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21858 
 
21859 
  def __eq__(self, other):
21860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21861 
 
21862 
  def __ne__(self, other):
21863 
    return not (self == other)
21864 
 
21865 
class getOrderForAwb_result:
21866 
  """
21867 
  Attributes:
21868 
   - success
21869 
   - ex
21870 
  """
21871 
 
21872 
  thrift_spec = (
21873 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21875 
  )
21876 
 
21877 
  def __init__(self, success=None, ex=None,):
21878 
    self.success = success
21879 
    self.ex = ex
21880 
 
21881 
  def read(self, iprot):
21882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21884 
      return
21885 
    iprot.readStructBegin()
21886 
    while True:
21887 
      (fname, ftype, fid) = iprot.readFieldBegin()
21888 
      if ftype == TType.STOP:
21889 
        break
21890 
      if fid == 0:
21891 
        if ftype == TType.STRUCT:
21892 
          self.success = Order()
21893 
          self.success.read(iprot)
21894 
        else:
21895 
          iprot.skip(ftype)
21896 
      elif fid == 1:
21897 
        if ftype == TType.STRUCT:
21898 
          self.ex = TransactionServiceException()
21899 
          self.ex.read(iprot)
21900 
        else:
21901 
          iprot.skip(ftype)
21902 
      else:
21903 
        iprot.skip(ftype)
21904 
      iprot.readFieldEnd()
21905 
    iprot.readStructEnd()
21906 
 
21907 
  def write(self, oprot):
21908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21910 
      return
21911 
    oprot.writeStructBegin('getOrderForAwb_result')
21912 
    if self.success is not None:
21913 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21914 
      self.success.write(oprot)
21915 
      oprot.writeFieldEnd()
21916 
    if self.ex is not None:
21917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21918 
      self.ex.write(oprot)
21919 
      oprot.writeFieldEnd()
21920 
    oprot.writeFieldStop()
21921 
    oprot.writeStructEnd()
21922 
 
21923 
  def validate(self):
21924 
    return
21925 
 
21926 
 
21927 
  def __repr__(self):
21928 
    L = ['%s=%r' % (key, value)
21929 
      for key, value in self.__dict__.iteritems()]
21930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21931 
 
21932 
  def __eq__(self, other):
21933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21934 
 
21935 
  def __ne__(self, other):
21936 
    return not (self == other)
4506 phani.kuma 21937 
 
21938 
class getOrdersForProviderForStatus_args:
21939 
  """
21940 
  Attributes:
21941 
   - logistics_provider_id
4910 phani.kuma 21942 
   - order_status_list
4506 phani.kuma 21943 
  """
21944 
 
21945 
  thrift_spec = (
21946 
    None, # 0
21947 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21948 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21949 
  )
21950 
 
4910 phani.kuma 21951 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21952 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21953 
    self.order_status_list = order_status_list
4506 phani.kuma 21954 
 
21955 
  def read(self, iprot):
21956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21958 
      return
21959 
    iprot.readStructBegin()
21960 
    while True:
21961 
      (fname, ftype, fid) = iprot.readFieldBegin()
21962 
      if ftype == TType.STOP:
21963 
        break
21964 
      if fid == 1:
21965 
        if ftype == TType.I64:
21966 
          self.logistics_provider_id = iprot.readI64();
21967 
        else:
21968 
          iprot.skip(ftype)
21969 
      elif fid == 2:
4910 phani.kuma 21970 
        if ftype == TType.LIST:
21971 
          self.order_status_list = []
6188 rajveer 21972 
          (_etype513, _size510) = iprot.readListBegin()
21973 
          for _i514 in xrange(_size510):
21974 
            _elem515 = iprot.readI32();
21975 
            self.order_status_list.append(_elem515)
4910 phani.kuma 21976 
          iprot.readListEnd()
4506 phani.kuma 21977 
        else:
21978 
          iprot.skip(ftype)
21979 
      else:
21980 
        iprot.skip(ftype)
21981 
      iprot.readFieldEnd()
21982 
    iprot.readStructEnd()
21983 
 
21984 
  def write(self, oprot):
21985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21987 
      return
21988 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21989 
    if self.logistics_provider_id is not None:
21990 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21991 
      oprot.writeI64(self.logistics_provider_id)
21992 
      oprot.writeFieldEnd()
4910 phani.kuma 21993 
    if self.order_status_list is not None:
21994 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21995 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 21996 
      for iter516 in self.order_status_list:
21997 
        oprot.writeI32(iter516)
4910 phani.kuma 21998 
      oprot.writeListEnd()
4506 phani.kuma 21999 
      oprot.writeFieldEnd()
22000 
    oprot.writeFieldStop()
22001 
    oprot.writeStructEnd()
22002 
 
22003 
  def validate(self):
22004 
    return
22005 
 
22006 
 
22007 
  def __repr__(self):
22008 
    L = ['%s=%r' % (key, value)
22009 
      for key, value in self.__dict__.iteritems()]
22010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22011 
 
22012 
  def __eq__(self, other):
22013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22014 
 
22015 
  def __ne__(self, other):
22016 
    return not (self == other)
22017 
 
22018 
class getOrdersForProviderForStatus_result:
22019 
  """
22020 
  Attributes:
22021 
   - success
22022 
   - ex
22023 
  """
22024 
 
22025 
  thrift_spec = (
22026 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22028 
  )
22029 
 
22030 
  def __init__(self, success=None, ex=None,):
22031 
    self.success = success
22032 
    self.ex = ex
22033 
 
22034 
  def read(self, iprot):
22035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22037 
      return
22038 
    iprot.readStructBegin()
22039 
    while True:
22040 
      (fname, ftype, fid) = iprot.readFieldBegin()
22041 
      if ftype == TType.STOP:
22042 
        break
22043 
      if fid == 0:
22044 
        if ftype == TType.LIST:
22045 
          self.success = []
6188 rajveer 22046 
          (_etype520, _size517) = iprot.readListBegin()
22047 
          for _i521 in xrange(_size517):
22048 
            _elem522 = Order()
22049 
            _elem522.read(iprot)
22050 
            self.success.append(_elem522)
4506 phani.kuma 22051 
          iprot.readListEnd()
22052 
        else:
22053 
          iprot.skip(ftype)
22054 
      elif fid == 1:
22055 
        if ftype == TType.STRUCT:
22056 
          self.ex = TransactionServiceException()
22057 
          self.ex.read(iprot)
22058 
        else:
22059 
          iprot.skip(ftype)
22060 
      else:
22061 
        iprot.skip(ftype)
22062 
      iprot.readFieldEnd()
22063 
    iprot.readStructEnd()
22064 
 
22065 
  def write(self, oprot):
22066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22068 
      return
22069 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22070 
    if self.success is not None:
22071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22073 
      for iter523 in self.success:
22074 
        iter523.write(oprot)
4506 phani.kuma 22075 
      oprot.writeListEnd()
22076 
      oprot.writeFieldEnd()
22077 
    if self.ex is not None:
22078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22079 
      self.ex.write(oprot)
22080 
      oprot.writeFieldEnd()
22081 
    oprot.writeFieldStop()
22082 
    oprot.writeStructEnd()
22083 
 
22084 
  def validate(self):
22085 
    return
22086 
 
22087 
 
22088 
  def __repr__(self):
22089 
    L = ['%s=%r' % (key, value)
22090 
      for key, value in self.__dict__.iteritems()]
22091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22092 
 
22093 
  def __eq__(self, other):
22094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22095 
 
22096 
  def __ne__(self, other):
22097 
    return not (self == other)
4600 varun.gupt 22098 
 
22099 
class getBilledOrdersForVendor_args:
22100 
  """
22101 
  Attributes:
22102 
   - vendorId
22103 
   - billingDateFrom
22104 
   - billingDateTo
22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    None, # 0
22109 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22110 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22111 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22112 
  )
22113 
 
22114 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22115 
    self.vendorId = vendorId
22116 
    self.billingDateFrom = billingDateFrom
22117 
    self.billingDateTo = billingDateTo
22118 
 
22119 
  def read(self, iprot):
22120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22122 
      return
22123 
    iprot.readStructBegin()
22124 
    while True:
22125 
      (fname, ftype, fid) = iprot.readFieldBegin()
22126 
      if ftype == TType.STOP:
22127 
        break
22128 
      if fid == 1:
22129 
        if ftype == TType.I64:
22130 
          self.vendorId = iprot.readI64();
22131 
        else:
22132 
          iprot.skip(ftype)
22133 
      elif fid == 2:
22134 
        if ftype == TType.I64:
22135 
          self.billingDateFrom = iprot.readI64();
22136 
        else:
22137 
          iprot.skip(ftype)
22138 
      elif fid == 3:
22139 
        if ftype == TType.I64:
22140 
          self.billingDateTo = iprot.readI64();
22141 
        else:
22142 
          iprot.skip(ftype)
22143 
      else:
22144 
        iprot.skip(ftype)
22145 
      iprot.readFieldEnd()
22146 
    iprot.readStructEnd()
22147 
 
22148 
  def write(self, oprot):
22149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22151 
      return
22152 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22153 
    if self.vendorId is not None:
22154 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22155 
      oprot.writeI64(self.vendorId)
22156 
      oprot.writeFieldEnd()
22157 
    if self.billingDateFrom is not None:
22158 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22159 
      oprot.writeI64(self.billingDateFrom)
22160 
      oprot.writeFieldEnd()
22161 
    if self.billingDateTo is not None:
22162 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22163 
      oprot.writeI64(self.billingDateTo)
22164 
      oprot.writeFieldEnd()
22165 
    oprot.writeFieldStop()
22166 
    oprot.writeStructEnd()
22167 
 
22168 
  def validate(self):
22169 
    return
22170 
 
22171 
 
22172 
  def __repr__(self):
22173 
    L = ['%s=%r' % (key, value)
22174 
      for key, value in self.__dict__.iteritems()]
22175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22176 
 
22177 
  def __eq__(self, other):
22178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22179 
 
22180 
  def __ne__(self, other):
22181 
    return not (self == other)
22182 
 
22183 
class getBilledOrdersForVendor_result:
22184 
  """
22185 
  Attributes:
22186 
   - success
22187 
   - ex
22188 
  """
22189 
 
22190 
  thrift_spec = (
22191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22193 
  )
22194 
 
22195 
  def __init__(self, success=None, ex=None,):
22196 
    self.success = success
22197 
    self.ex = ex
22198 
 
22199 
  def read(self, iprot):
22200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22202 
      return
22203 
    iprot.readStructBegin()
22204 
    while True:
22205 
      (fname, ftype, fid) = iprot.readFieldBegin()
22206 
      if ftype == TType.STOP:
22207 
        break
22208 
      if fid == 0:
22209 
        if ftype == TType.LIST:
22210 
          self.success = []
6188 rajveer 22211 
          (_etype527, _size524) = iprot.readListBegin()
22212 
          for _i528 in xrange(_size524):
22213 
            _elem529 = Order()
22214 
            _elem529.read(iprot)
22215 
            self.success.append(_elem529)
4600 varun.gupt 22216 
          iprot.readListEnd()
22217 
        else:
22218 
          iprot.skip(ftype)
22219 
      elif fid == 1:
22220 
        if ftype == TType.STRUCT:
22221 
          self.ex = TransactionServiceException()
22222 
          self.ex.read(iprot)
22223 
        else:
22224 
          iprot.skip(ftype)
22225 
      else:
22226 
        iprot.skip(ftype)
22227 
      iprot.readFieldEnd()
22228 
    iprot.readStructEnd()
22229 
 
22230 
  def write(self, oprot):
22231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22233 
      return
22234 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22235 
    if self.success is not None:
22236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22237 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22238 
      for iter530 in self.success:
22239 
        iter530.write(oprot)
4600 varun.gupt 22240 
      oprot.writeListEnd()
22241 
      oprot.writeFieldEnd()
22242 
    if self.ex is not None:
22243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22244 
      self.ex.write(oprot)
22245 
      oprot.writeFieldEnd()
22246 
    oprot.writeFieldStop()
22247 
    oprot.writeStructEnd()
22248 
 
22249 
  def validate(self):
22250 
    return
22251 
 
22252 
 
22253 
  def __repr__(self):
22254 
    L = ['%s=%r' % (key, value)
22255 
      for key, value in self.__dict__.iteritems()]
22256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22257 
 
22258 
  def __eq__(self, other):
22259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22260 
 
22261 
  def __ne__(self, other):
22262 
    return not (self == other)
22263 
 
4607 rajveer 22264 
class getSlippedSippingDateOrders_args:
22265 
 
22266 
  thrift_spec = (
22267 
  )
22268 
 
22269 
  def read(self, iprot):
22270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22272 
      return
22273 
    iprot.readStructBegin()
22274 
    while True:
22275 
      (fname, ftype, fid) = iprot.readFieldBegin()
22276 
      if ftype == TType.STOP:
22277 
        break
22278 
      else:
22279 
        iprot.skip(ftype)
22280 
      iprot.readFieldEnd()
22281 
    iprot.readStructEnd()
22282 
 
22283 
  def write(self, oprot):
22284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22286 
      return
22287 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22288 
    oprot.writeFieldStop()
22289 
    oprot.writeStructEnd()
22290 
 
22291 
  def validate(self):
22292 
    return
22293 
 
22294 
 
22295 
  def __repr__(self):
22296 
    L = ['%s=%r' % (key, value)
22297 
      for key, value in self.__dict__.iteritems()]
22298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22299 
 
22300 
  def __eq__(self, other):
22301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22302 
 
22303 
  def __ne__(self, other):
22304 
    return not (self == other)
22305 
 
22306 
class getSlippedSippingDateOrders_result:
22307 
  """
22308 
  Attributes:
22309 
   - success
22310 
   - ex
22311 
  """
22312 
 
22313 
  thrift_spec = (
22314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22316 
  )
22317 
 
22318 
  def __init__(self, success=None, ex=None,):
22319 
    self.success = success
22320 
    self.ex = ex
22321 
 
22322 
  def read(self, iprot):
22323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22325 
      return
22326 
    iprot.readStructBegin()
22327 
    while True:
22328 
      (fname, ftype, fid) = iprot.readFieldBegin()
22329 
      if ftype == TType.STOP:
22330 
        break
22331 
      if fid == 0:
22332 
        if ftype == TType.LIST:
22333 
          self.success = []
6188 rajveer 22334 
          (_etype534, _size531) = iprot.readListBegin()
22335 
          for _i535 in xrange(_size531):
22336 
            _elem536 = Order()
22337 
            _elem536.read(iprot)
22338 
            self.success.append(_elem536)
4607 rajveer 22339 
          iprot.readListEnd()
22340 
        else:
22341 
          iprot.skip(ftype)
22342 
      elif fid == 1:
22343 
        if ftype == TType.STRUCT:
22344 
          self.ex = TransactionServiceException()
22345 
          self.ex.read(iprot)
22346 
        else:
22347 
          iprot.skip(ftype)
22348 
      else:
22349 
        iprot.skip(ftype)
22350 
      iprot.readFieldEnd()
22351 
    iprot.readStructEnd()
22352 
 
22353 
  def write(self, oprot):
22354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22356 
      return
22357 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22358 
    if self.success is not None:
22359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22361 
      for iter537 in self.success:
22362 
        iter537.write(oprot)
4607 rajveer 22363 
      oprot.writeListEnd()
22364 
      oprot.writeFieldEnd()
22365 
    if self.ex is not None:
22366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22367 
      self.ex.write(oprot)
22368 
      oprot.writeFieldEnd()
22369 
    oprot.writeFieldStop()
22370 
    oprot.writeStructEnd()
22371 
 
22372 
  def validate(self):
22373 
    return
22374 
 
22375 
 
22376 
  def __repr__(self):
22377 
    L = ['%s=%r' % (key, value)
22378 
      for key, value in self.__dict__.iteritems()]
22379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22380 
 
22381 
  def __eq__(self, other):
22382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22383 
 
22384 
  def __ne__(self, other):
22385 
    return not (self == other)
22386 
 
4709 rajveer 22387 
class getCancelledOrders_args:
22388 
  """
22389 
  Attributes:
22390 
   - cancelDateFrom
22391 
   - cancelDateTo
22392 
  """
22393 
 
22394 
  thrift_spec = (
22395 
    None, # 0
22396 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22397 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22398 
  )
22399 
 
22400 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22401 
    self.cancelDateFrom = cancelDateFrom
22402 
    self.cancelDateTo = cancelDateTo
22403 
 
22404 
  def read(self, iprot):
22405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22407 
      return
22408 
    iprot.readStructBegin()
22409 
    while True:
22410 
      (fname, ftype, fid) = iprot.readFieldBegin()
22411 
      if ftype == TType.STOP:
22412 
        break
22413 
      if fid == 1:
22414 
        if ftype == TType.I64:
22415 
          self.cancelDateFrom = iprot.readI64();
22416 
        else:
22417 
          iprot.skip(ftype)
22418 
      elif fid == 2:
22419 
        if ftype == TType.I64:
22420 
          self.cancelDateTo = iprot.readI64();
22421 
        else:
22422 
          iprot.skip(ftype)
22423 
      else:
22424 
        iprot.skip(ftype)
22425 
      iprot.readFieldEnd()
22426 
    iprot.readStructEnd()
22427 
 
22428 
  def write(self, oprot):
22429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22431 
      return
22432 
    oprot.writeStructBegin('getCancelledOrders_args')
22433 
    if self.cancelDateFrom is not None:
22434 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22435 
      oprot.writeI64(self.cancelDateFrom)
22436 
      oprot.writeFieldEnd()
22437 
    if self.cancelDateTo is not None:
22438 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22439 
      oprot.writeI64(self.cancelDateTo)
22440 
      oprot.writeFieldEnd()
22441 
    oprot.writeFieldStop()
22442 
    oprot.writeStructEnd()
22443 
 
22444 
  def validate(self):
22445 
    return
22446 
 
22447 
 
22448 
  def __repr__(self):
22449 
    L = ['%s=%r' % (key, value)
22450 
      for key, value in self.__dict__.iteritems()]
22451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22452 
 
22453 
  def __eq__(self, other):
22454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22455 
 
22456 
  def __ne__(self, other):
22457 
    return not (self == other)
22458 
 
22459 
class getCancelledOrders_result:
22460 
  """
22461 
  Attributes:
22462 
   - success
22463 
   - ex
22464 
  """
22465 
 
22466 
  thrift_spec = (
22467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22469 
  )
22470 
 
22471 
  def __init__(self, success=None, ex=None,):
22472 
    self.success = success
22473 
    self.ex = ex
22474 
 
22475 
  def read(self, iprot):
22476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22478 
      return
22479 
    iprot.readStructBegin()
22480 
    while True:
22481 
      (fname, ftype, fid) = iprot.readFieldBegin()
22482 
      if ftype == TType.STOP:
22483 
        break
22484 
      if fid == 0:
22485 
        if ftype == TType.LIST:
22486 
          self.success = []
6188 rajveer 22487 
          (_etype541, _size538) = iprot.readListBegin()
22488 
          for _i542 in xrange(_size538):
22489 
            _elem543 = Order()
22490 
            _elem543.read(iprot)
22491 
            self.success.append(_elem543)
4709 rajveer 22492 
          iprot.readListEnd()
22493 
        else:
22494 
          iprot.skip(ftype)
22495 
      elif fid == 1:
22496 
        if ftype == TType.STRUCT:
22497 
          self.ex = TransactionServiceException()
22498 
          self.ex.read(iprot)
22499 
        else:
22500 
          iprot.skip(ftype)
22501 
      else:
22502 
        iprot.skip(ftype)
22503 
      iprot.readFieldEnd()
22504 
    iprot.readStructEnd()
22505 
 
22506 
  def write(self, oprot):
22507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22509 
      return
22510 
    oprot.writeStructBegin('getCancelledOrders_result')
22511 
    if self.success is not None:
22512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22513 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22514 
      for iter544 in self.success:
22515 
        iter544.write(oprot)
4709 rajveer 22516 
      oprot.writeListEnd()
22517 
      oprot.writeFieldEnd()
22518 
    if self.ex is not None:
22519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22520 
      self.ex.write(oprot)
22521 
      oprot.writeFieldEnd()
22522 
    oprot.writeFieldStop()
22523 
    oprot.writeStructEnd()
22524 
 
22525 
  def validate(self):
22526 
    return
22527 
 
22528 
 
22529 
  def __repr__(self):
22530 
    L = ['%s=%r' % (key, value)
22531 
      for key, value in self.__dict__.iteritems()]
22532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22533 
 
22534 
  def __eq__(self, other):
22535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22536 
 
22537 
  def __ne__(self, other):
22538 
    return not (self == other)
22539 
 
4600 varun.gupt 22540 
class saveBluedartSettlements_args:
22541 
  """
22542 
  Attributes:
22543 
   - mapAWBAndAmount
22544 
  """
22545 
 
22546 
  thrift_spec = (
22547 
    None, # 0
22548 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22549 
  )
22550 
 
22551 
  def __init__(self, mapAWBAndAmount=None,):
22552 
    self.mapAWBAndAmount = mapAWBAndAmount
22553 
 
22554 
  def read(self, iprot):
22555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22557 
      return
22558 
    iprot.readStructBegin()
22559 
    while True:
22560 
      (fname, ftype, fid) = iprot.readFieldBegin()
22561 
      if ftype == TType.STOP:
22562 
        break
22563 
      if fid == 1:
22564 
        if ftype == TType.MAP:
22565 
          self.mapAWBAndAmount = {}
6188 rajveer 22566 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22567 
          for _i549 in xrange(_size545):
22568 
            _key550 = iprot.readI64();
22569 
            _val551 = iprot.readDouble();
22570 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22571 
          iprot.readMapEnd()
22572 
        else:
22573 
          iprot.skip(ftype)
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22584 
    if self.mapAWBAndAmount is not None:
22585 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22586 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22587 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22588 
        oprot.writeI64(kiter552)
22589 
        oprot.writeDouble(viter553)
4600 varun.gupt 22590 
      oprot.writeMapEnd()
22591 
      oprot.writeFieldEnd()
22592 
    oprot.writeFieldStop()
22593 
    oprot.writeStructEnd()
22594 
 
22595 
  def validate(self):
22596 
    return
22597 
 
22598 
 
22599 
  def __repr__(self):
22600 
    L = ['%s=%r' % (key, value)
22601 
      for key, value in self.__dict__.iteritems()]
22602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22603 
 
22604 
  def __eq__(self, other):
22605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22606 
 
22607 
  def __ne__(self, other):
22608 
    return not (self == other)
22609 
 
22610 
class saveBluedartSettlements_result:
22611 
  """
22612 
  Attributes:
22613 
   - ex
22614 
  """
22615 
 
22616 
  thrift_spec = (
22617 
    None, # 0
22618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22619 
  )
22620 
 
22621 
  def __init__(self, ex=None,):
22622 
    self.ex = ex
22623 
 
22624 
  def read(self, iprot):
22625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22627 
      return
22628 
    iprot.readStructBegin()
22629 
    while True:
22630 
      (fname, ftype, fid) = iprot.readFieldBegin()
22631 
      if ftype == TType.STOP:
22632 
        break
22633 
      if fid == 1:
22634 
        if ftype == TType.STRUCT:
22635 
          self.ex = TransactionServiceException()
22636 
          self.ex.read(iprot)
22637 
        else:
22638 
          iprot.skip(ftype)
22639 
      else:
22640 
        iprot.skip(ftype)
22641 
      iprot.readFieldEnd()
22642 
    iprot.readStructEnd()
22643 
 
22644 
  def write(self, oprot):
22645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22647 
      return
22648 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22649 
    if self.ex is not None:
22650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22651 
      self.ex.write(oprot)
22652 
      oprot.writeFieldEnd()
22653 
    oprot.writeFieldStop()
22654 
    oprot.writeStructEnd()
22655 
 
22656 
  def validate(self):
22657 
    return
22658 
 
22659 
 
22660 
  def __repr__(self):
22661 
    L = ['%s=%r' % (key, value)
22662 
      for key, value in self.__dict__.iteritems()]
22663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22664 
 
22665 
  def __eq__(self, other):
22666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22667 
 
22668 
  def __ne__(self, other):
22669 
    return not (self == other)
22670 
 
22671 
class savePaymentSettlements_args:
22672 
  """
22673 
  Attributes:
22674 
   - settlementDate
22675 
   - paymentGatewayId
4905 varun.gupt 22676 
   - referenceId
4600 varun.gupt 22677 
   - serviceTax
22678 
   - otherCharges
22679 
   - netCollection
22680 
  """
22681 
 
22682 
  thrift_spec = (
22683 
    None, # 0
22684 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22685 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22686 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22687 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22688 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22689 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22690 
  )
22691 
 
4905 varun.gupt 22692 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22693 
    self.settlementDate = settlementDate
22694 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22695 
    self.referenceId = referenceId
4600 varun.gupt 22696 
    self.serviceTax = serviceTax
22697 
    self.otherCharges = otherCharges
22698 
    self.netCollection = netCollection
22699 
 
22700 
  def read(self, iprot):
22701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22703 
      return
22704 
    iprot.readStructBegin()
22705 
    while True:
22706 
      (fname, ftype, fid) = iprot.readFieldBegin()
22707 
      if ftype == TType.STOP:
22708 
        break
22709 
      if fid == 1:
22710 
        if ftype == TType.I64:
22711 
          self.settlementDate = iprot.readI64();
22712 
        else:
22713 
          iprot.skip(ftype)
22714 
      elif fid == 2:
22715 
        if ftype == TType.I64:
22716 
          self.paymentGatewayId = iprot.readI64();
22717 
        else:
22718 
          iprot.skip(ftype)
22719 
      elif fid == 3:
22720 
        if ftype == TType.I64:
4905 varun.gupt 22721 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22722 
        else:
22723 
          iprot.skip(ftype)
22724 
      elif fid == 4:
22725 
        if ftype == TType.DOUBLE:
22726 
          self.serviceTax = iprot.readDouble();
22727 
        else:
22728 
          iprot.skip(ftype)
22729 
      elif fid == 5:
22730 
        if ftype == TType.DOUBLE:
22731 
          self.otherCharges = iprot.readDouble();
22732 
        else:
22733 
          iprot.skip(ftype)
22734 
      elif fid == 6:
22735 
        if ftype == TType.DOUBLE:
22736 
          self.netCollection = iprot.readDouble();
22737 
        else:
22738 
          iprot.skip(ftype)
22739 
      else:
22740 
        iprot.skip(ftype)
22741 
      iprot.readFieldEnd()
22742 
    iprot.readStructEnd()
22743 
 
22744 
  def write(self, oprot):
22745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22747 
      return
22748 
    oprot.writeStructBegin('savePaymentSettlements_args')
22749 
    if self.settlementDate is not None:
22750 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22751 
      oprot.writeI64(self.settlementDate)
22752 
      oprot.writeFieldEnd()
22753 
    if self.paymentGatewayId is not None:
22754 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22755 
      oprot.writeI64(self.paymentGatewayId)
22756 
      oprot.writeFieldEnd()
4905 varun.gupt 22757 
    if self.referenceId is not None:
22758 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22759 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22760 
      oprot.writeFieldEnd()
22761 
    if self.serviceTax is not None:
22762 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22763 
      oprot.writeDouble(self.serviceTax)
22764 
      oprot.writeFieldEnd()
22765 
    if self.otherCharges is not None:
22766 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22767 
      oprot.writeDouble(self.otherCharges)
22768 
      oprot.writeFieldEnd()
22769 
    if self.netCollection is not None:
22770 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22771 
      oprot.writeDouble(self.netCollection)
22772 
      oprot.writeFieldEnd()
22773 
    oprot.writeFieldStop()
22774 
    oprot.writeStructEnd()
22775 
 
22776 
  def validate(self):
22777 
    return
22778 
 
22779 
 
22780 
  def __repr__(self):
22781 
    L = ['%s=%r' % (key, value)
22782 
      for key, value in self.__dict__.iteritems()]
22783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22784 
 
22785 
  def __eq__(self, other):
22786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22787 
 
22788 
  def __ne__(self, other):
22789 
    return not (self == other)
22790 
 
22791 
class savePaymentSettlements_result:
22792 
  """
22793 
  Attributes:
22794 
   - ex
22795 
  """
22796 
 
22797 
  thrift_spec = (
22798 
    None, # 0
22799 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22800 
  )
22801 
 
22802 
  def __init__(self, ex=None,):
22803 
    self.ex = ex
22804 
 
22805 
  def read(self, iprot):
22806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22808 
      return
22809 
    iprot.readStructBegin()
22810 
    while True:
22811 
      (fname, ftype, fid) = iprot.readFieldBegin()
22812 
      if ftype == TType.STOP:
22813 
        break
22814 
      if fid == 1:
22815 
        if ftype == TType.STRUCT:
22816 
          self.ex = TransactionServiceException()
22817 
          self.ex.read(iprot)
22818 
        else:
22819 
          iprot.skip(ftype)
22820 
      else:
22821 
        iprot.skip(ftype)
22822 
      iprot.readFieldEnd()
22823 
    iprot.readStructEnd()
22824 
 
22825 
  def write(self, oprot):
22826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22828 
      return
22829 
    oprot.writeStructBegin('savePaymentSettlements_result')
22830 
    if self.ex is not None:
22831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22832 
      self.ex.write(oprot)
22833 
      oprot.writeFieldEnd()
22834 
    oprot.writeFieldStop()
22835 
    oprot.writeStructEnd()
22836 
 
22837 
  def validate(self):
22838 
    return
22839 
 
22840 
 
22841 
  def __repr__(self):
22842 
    L = ['%s=%r' % (key, value)
22843 
      for key, value in self.__dict__.iteritems()]
22844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22845 
 
22846 
  def __eq__(self, other):
22847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22848 
 
22849 
  def __ne__(self, other):
22850 
    return not (self == other)
22851 
 
22852 
class saveEBSSettlementSummary_args:
22853 
  """
22854 
  Attributes:
22855 
   - settlementId
22856 
   - settlementDate
22857 
   - transactionDateFrom
22858 
   - transactionDateTo
22859 
   - amount
22860 
  """
22861 
 
22862 
  thrift_spec = (
22863 
    None, # 0
22864 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22865 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22866 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22867 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22868 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22869 
  )
22870 
 
22871 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22872 
    self.settlementId = settlementId
22873 
    self.settlementDate = settlementDate
22874 
    self.transactionDateFrom = transactionDateFrom
22875 
    self.transactionDateTo = transactionDateTo
22876 
    self.amount = amount
22877 
 
22878 
  def read(self, iprot):
22879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22881 
      return
22882 
    iprot.readStructBegin()
22883 
    while True:
22884 
      (fname, ftype, fid) = iprot.readFieldBegin()
22885 
      if ftype == TType.STOP:
22886 
        break
22887 
      if fid == 1:
22888 
        if ftype == TType.I64:
22889 
          self.settlementId = iprot.readI64();
22890 
        else:
22891 
          iprot.skip(ftype)
22892 
      elif fid == 2:
22893 
        if ftype == TType.I64:
22894 
          self.settlementDate = iprot.readI64();
22895 
        else:
22896 
          iprot.skip(ftype)
22897 
      elif fid == 3:
22898 
        if ftype == TType.I64:
22899 
          self.transactionDateFrom = iprot.readI64();
22900 
        else:
22901 
          iprot.skip(ftype)
22902 
      elif fid == 4:
22903 
        if ftype == TType.I64:
22904 
          self.transactionDateTo = iprot.readI64();
22905 
        else:
22906 
          iprot.skip(ftype)
22907 
      elif fid == 5:
22908 
        if ftype == TType.DOUBLE:
22909 
          self.amount = iprot.readDouble();
22910 
        else:
22911 
          iprot.skip(ftype)
22912 
      else:
22913 
        iprot.skip(ftype)
22914 
      iprot.readFieldEnd()
22915 
    iprot.readStructEnd()
22916 
 
22917 
  def write(self, oprot):
22918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22920 
      return
22921 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22922 
    if self.settlementId is not None:
22923 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22924 
      oprot.writeI64(self.settlementId)
22925 
      oprot.writeFieldEnd()
22926 
    if self.settlementDate is not None:
22927 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22928 
      oprot.writeI64(self.settlementDate)
22929 
      oprot.writeFieldEnd()
22930 
    if self.transactionDateFrom is not None:
22931 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22932 
      oprot.writeI64(self.transactionDateFrom)
22933 
      oprot.writeFieldEnd()
22934 
    if self.transactionDateTo is not None:
22935 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22936 
      oprot.writeI64(self.transactionDateTo)
22937 
      oprot.writeFieldEnd()
22938 
    if self.amount is not None:
22939 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22940 
      oprot.writeDouble(self.amount)
22941 
      oprot.writeFieldEnd()
22942 
    oprot.writeFieldStop()
22943 
    oprot.writeStructEnd()
22944 
 
22945 
  def validate(self):
22946 
    return
22947 
 
22948 
 
22949 
  def __repr__(self):
22950 
    L = ['%s=%r' % (key, value)
22951 
      for key, value in self.__dict__.iteritems()]
22952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22953 
 
22954 
  def __eq__(self, other):
22955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22956 
 
22957 
  def __ne__(self, other):
22958 
    return not (self == other)
22959 
 
22960 
class saveEBSSettlementSummary_result:
22961 
  """
22962 
  Attributes:
22963 
   - ex
22964 
  """
22965 
 
22966 
  thrift_spec = (
22967 
    None, # 0
22968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22969 
  )
22970 
 
22971 
  def __init__(self, ex=None,):
22972 
    self.ex = ex
22973 
 
22974 
  def read(self, iprot):
22975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22977 
      return
22978 
    iprot.readStructBegin()
22979 
    while True:
22980 
      (fname, ftype, fid) = iprot.readFieldBegin()
22981 
      if ftype == TType.STOP:
22982 
        break
22983 
      if fid == 1:
22984 
        if ftype == TType.STRUCT:
22985 
          self.ex = TransactionServiceException()
22986 
          self.ex.read(iprot)
22987 
        else:
22988 
          iprot.skip(ftype)
22989 
      else:
22990 
        iprot.skip(ftype)
22991 
      iprot.readFieldEnd()
22992 
    iprot.readStructEnd()
22993 
 
22994 
  def write(self, oprot):
22995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22997 
      return
22998 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22999 
    if self.ex is not None:
23000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23001 
      self.ex.write(oprot)
23002 
      oprot.writeFieldEnd()
23003 
    oprot.writeFieldStop()
23004 
    oprot.writeStructEnd()
23005 
 
23006 
  def validate(self):
23007 
    return
23008 
 
23009 
 
23010 
  def __repr__(self):
23011 
    L = ['%s=%r' % (key, value)
23012 
      for key, value in self.__dict__.iteritems()]
23013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23014 
 
23015 
  def __eq__(self, other):
23016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23017 
 
23018 
  def __ne__(self, other):
23019 
    return not (self == other)
23020 
 
5386 phani.kuma 23021 
class getSettlementForPrepaid_args:
4600 varun.gupt 23022 
  """
23023 
  Attributes:
5189 varun.gupt 23024 
   - referenceId
23025 
   - isRefund
4600 varun.gupt 23026 
  """
23027 
 
23028 
  thrift_spec = (
23029 
    None, # 0
5189 varun.gupt 23030 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23031 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23032 
  )
23033 
 
5386 phani.kuma 23034 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23035 
    self.referenceId = referenceId
23036 
    self.isRefund = isRefund
4600 varun.gupt 23037 
 
23038 
  def read(self, iprot):
23039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23041 
      return
23042 
    iprot.readStructBegin()
23043 
    while True:
23044 
      (fname, ftype, fid) = iprot.readFieldBegin()
23045 
      if ftype == TType.STOP:
23046 
        break
23047 
      if fid == 1:
23048 
        if ftype == TType.I64:
5189 varun.gupt 23049 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23050 
        else:
23051 
          iprot.skip(ftype)
5189 varun.gupt 23052 
      elif fid == 2:
23053 
        if ftype == TType.BOOL:
23054 
          self.isRefund = iprot.readBool();
23055 
        else:
23056 
          iprot.skip(ftype)
4600 varun.gupt 23057 
      else:
23058 
        iprot.skip(ftype)
23059 
      iprot.readFieldEnd()
23060 
    iprot.readStructEnd()
23061 
 
23062 
  def write(self, oprot):
23063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23065 
      return
5386 phani.kuma 23066 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23067 
    if self.referenceId is not None:
23068 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23069 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23070 
      oprot.writeFieldEnd()
5386 phani.kuma 23071 
    if self.isRefund is not None:
23072 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23073 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23074 
      oprot.writeFieldEnd()
5386 phani.kuma 23075 
    oprot.writeFieldStop()
23076 
    oprot.writeStructEnd()
23077 
 
23078 
  def validate(self):
23079 
    return
23080 
 
23081 
 
23082 
  def __repr__(self):
23083 
    L = ['%s=%r' % (key, value)
23084 
      for key, value in self.__dict__.iteritems()]
23085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23086 
 
23087 
  def __eq__(self, other):
23088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23089 
 
23090 
  def __ne__(self, other):
23091 
    return not (self == other)
23092 
 
23093 
class getSettlementForPrepaid_result:
23094 
  """
23095 
  Attributes:
23096 
   - success
23097 
   - ex
23098 
  """
23099 
 
23100 
  thrift_spec = (
23101 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23103 
  )
23104 
 
23105 
  def __init__(self, success=None, ex=None,):
23106 
    self.success = success
23107 
    self.ex = ex
23108 
 
23109 
  def read(self, iprot):
23110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23112 
      return
23113 
    iprot.readStructBegin()
23114 
    while True:
23115 
      (fname, ftype, fid) = iprot.readFieldBegin()
23116 
      if ftype == TType.STOP:
23117 
        break
23118 
      if fid == 0:
23119 
        if ftype == TType.STRUCT:
23120 
          self.success = PaymentSettlement()
23121 
          self.success.read(iprot)
23122 
        else:
23123 
          iprot.skip(ftype)
23124 
      elif fid == 1:
23125 
        if ftype == TType.STRUCT:
23126 
          self.ex = TransactionServiceException()
23127 
          self.ex.read(iprot)
23128 
        else:
23129 
          iprot.skip(ftype)
23130 
      else:
23131 
        iprot.skip(ftype)
23132 
      iprot.readFieldEnd()
23133 
    iprot.readStructEnd()
23134 
 
23135 
  def write(self, oprot):
23136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23138 
      return
23139 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23140 
    if self.success is not None:
23141 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23142 
      self.success.write(oprot)
23143 
      oprot.writeFieldEnd()
23144 
    if self.ex is not None:
23145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23146 
      self.ex.write(oprot)
23147 
      oprot.writeFieldEnd()
23148 
    oprot.writeFieldStop()
23149 
    oprot.writeStructEnd()
23150 
 
23151 
  def validate(self):
23152 
    return
23153 
 
23154 
 
23155 
  def __repr__(self):
23156 
    L = ['%s=%r' % (key, value)
23157 
      for key, value in self.__dict__.iteritems()]
23158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23159 
 
23160 
  def __eq__(self, other):
23161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23162 
 
23163 
  def __ne__(self, other):
23164 
    return not (self == other)
23165 
 
23166 
class getSettlementForCod_args:
23167 
  """
23168 
  Attributes:
23169 
   - orderId
23170 
   - isRefund
23171 
  """
23172 
 
23173 
  thrift_spec = (
23174 
    None, # 0
23175 
    (1, TType.I64, 'orderId', None, None, ), # 1
23176 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23177 
  )
23178 
 
23179 
  def __init__(self, orderId=None, isRefund=None,):
23180 
    self.orderId = orderId
23181 
    self.isRefund = isRefund
23182 
 
23183 
  def read(self, iprot):
23184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23186 
      return
23187 
    iprot.readStructBegin()
23188 
    while True:
23189 
      (fname, ftype, fid) = iprot.readFieldBegin()
23190 
      if ftype == TType.STOP:
23191 
        break
23192 
      if fid == 1:
23193 
        if ftype == TType.I64:
23194 
          self.orderId = iprot.readI64();
23195 
        else:
23196 
          iprot.skip(ftype)
23197 
      elif fid == 2:
23198 
        if ftype == TType.BOOL:
23199 
          self.isRefund = iprot.readBool();
23200 
        else:
23201 
          iprot.skip(ftype)
23202 
      else:
23203 
        iprot.skip(ftype)
23204 
      iprot.readFieldEnd()
23205 
    iprot.readStructEnd()
23206 
 
23207 
  def write(self, oprot):
23208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23210 
      return
23211 
    oprot.writeStructBegin('getSettlementForCod_args')
23212 
    if self.orderId is not None:
23213 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23214 
      oprot.writeI64(self.orderId)
23215 
      oprot.writeFieldEnd()
5189 varun.gupt 23216 
    if self.isRefund is not None:
5386 phani.kuma 23217 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23218 
      oprot.writeBool(self.isRefund)
23219 
      oprot.writeFieldEnd()
4600 varun.gupt 23220 
    oprot.writeFieldStop()
23221 
    oprot.writeStructEnd()
23222 
 
23223 
  def validate(self):
23224 
    return
23225 
 
23226 
 
23227 
  def __repr__(self):
23228 
    L = ['%s=%r' % (key, value)
23229 
      for key, value in self.__dict__.iteritems()]
23230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23231 
 
23232 
  def __eq__(self, other):
23233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23234 
 
23235 
  def __ne__(self, other):
23236 
    return not (self == other)
23237 
 
5386 phani.kuma 23238 
class getSettlementForCod_result:
4600 varun.gupt 23239 
  """
23240 
  Attributes:
23241 
   - success
23242 
   - ex
23243 
  """
23244 
 
23245 
  thrift_spec = (
23246 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23248 
  )
23249 
 
23250 
  def __init__(self, success=None, ex=None,):
23251 
    self.success = success
23252 
    self.ex = ex
23253 
 
23254 
  def read(self, iprot):
23255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23257 
      return
23258 
    iprot.readStructBegin()
23259 
    while True:
23260 
      (fname, ftype, fid) = iprot.readFieldBegin()
23261 
      if ftype == TType.STOP:
23262 
        break
23263 
      if fid == 0:
23264 
        if ftype == TType.STRUCT:
23265 
          self.success = PaymentSettlement()
23266 
          self.success.read(iprot)
23267 
        else:
23268 
          iprot.skip(ftype)
23269 
      elif fid == 1:
23270 
        if ftype == TType.STRUCT:
23271 
          self.ex = TransactionServiceException()
23272 
          self.ex.read(iprot)
23273 
        else:
23274 
          iprot.skip(ftype)
23275 
      else:
23276 
        iprot.skip(ftype)
23277 
      iprot.readFieldEnd()
23278 
    iprot.readStructEnd()
23279 
 
23280 
  def write(self, oprot):
23281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23283 
      return
5386 phani.kuma 23284 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23285 
    if self.success is not None:
23286 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23287 
      self.success.write(oprot)
23288 
      oprot.writeFieldEnd()
23289 
    if self.ex is not None:
23290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23291 
      self.ex.write(oprot)
23292 
      oprot.writeFieldEnd()
23293 
    oprot.writeFieldStop()
23294 
    oprot.writeStructEnd()
23295 
 
23296 
  def validate(self):
23297 
    return
23298 
 
23299 
 
23300 
  def __repr__(self):
23301 
    L = ['%s=%r' % (key, value)
23302 
      for key, value in self.__dict__.iteritems()]
23303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23304 
 
23305 
  def __eq__(self, other):
23306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23307 
 
23308 
  def __ne__(self, other):
23309 
    return not (self == other)
23310 
 
23311 
class getEBSSettlementSummaries_args:
23312 
 
23313 
  thrift_spec = (
23314 
  )
23315 
 
23316 
  def read(self, iprot):
23317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23319 
      return
23320 
    iprot.readStructBegin()
23321 
    while True:
23322 
      (fname, ftype, fid) = iprot.readFieldBegin()
23323 
      if ftype == TType.STOP:
23324 
        break
23325 
      else:
23326 
        iprot.skip(ftype)
23327 
      iprot.readFieldEnd()
23328 
    iprot.readStructEnd()
23329 
 
23330 
  def write(self, oprot):
23331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23333 
      return
23334 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23335 
    oprot.writeFieldStop()
23336 
    oprot.writeStructEnd()
23337 
 
23338 
  def validate(self):
23339 
    return
23340 
 
23341 
 
23342 
  def __repr__(self):
23343 
    L = ['%s=%r' % (key, value)
23344 
      for key, value in self.__dict__.iteritems()]
23345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23346 
 
23347 
  def __eq__(self, other):
23348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23349 
 
23350 
  def __ne__(self, other):
23351 
    return not (self == other)
23352 
 
23353 
class getEBSSettlementSummaries_result:
23354 
  """
23355 
  Attributes:
23356 
   - success
23357 
   - ex
23358 
  """
23359 
 
23360 
  thrift_spec = (
23361 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23363 
  )
23364 
 
23365 
  def __init__(self, success=None, ex=None,):
23366 
    self.success = success
23367 
    self.ex = ex
23368 
 
23369 
  def read(self, iprot):
23370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23372 
      return
23373 
    iprot.readStructBegin()
23374 
    while True:
23375 
      (fname, ftype, fid) = iprot.readFieldBegin()
23376 
      if ftype == TType.STOP:
23377 
        break
23378 
      if fid == 0:
23379 
        if ftype == TType.MAP:
23380 
          self.success = {}
6188 rajveer 23381 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23382 
          for _i558 in xrange(_size554):
23383 
            _key559 = iprot.readI64();
23384 
            _val560 = iprot.readString();
23385 
            self.success[_key559] = _val560
4600 varun.gupt 23386 
          iprot.readMapEnd()
23387 
        else:
23388 
          iprot.skip(ftype)
23389 
      elif fid == 1:
23390 
        if ftype == TType.STRUCT:
23391 
          self.ex = TransactionServiceException()
23392 
          self.ex.read(iprot)
23393 
        else:
23394 
          iprot.skip(ftype)
23395 
      else:
23396 
        iprot.skip(ftype)
23397 
      iprot.readFieldEnd()
23398 
    iprot.readStructEnd()
23399 
 
23400 
  def write(self, oprot):
23401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23403 
      return
23404 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23405 
    if self.success is not None:
23406 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23407 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23408 
      for kiter561,viter562 in self.success.items():
23409 
        oprot.writeI64(kiter561)
23410 
        oprot.writeString(viter562)
4600 varun.gupt 23411 
      oprot.writeMapEnd()
23412 
      oprot.writeFieldEnd()
23413 
    if self.ex is not None:
23414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23415 
      self.ex.write(oprot)
23416 
      oprot.writeFieldEnd()
23417 
    oprot.writeFieldStop()
23418 
    oprot.writeStructEnd()
23419 
 
23420 
  def validate(self):
23421 
    return
23422 
 
23423 
 
23424 
  def __repr__(self):
23425 
    L = ['%s=%r' % (key, value)
23426 
      for key, value in self.__dict__.iteritems()]
23427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23428 
 
23429 
  def __eq__(self, other):
23430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23431 
 
23432 
  def __ne__(self, other):
23433 
    return not (self == other)
23434 
 
23435 
class markEBSSettlementUploaded_args:
23436 
  """
23437 
  Attributes:
23438 
   - settlementId
23439 
  """
23440 
 
23441 
  thrift_spec = (
23442 
    None, # 0
23443 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23444 
  )
23445 
 
23446 
  def __init__(self, settlementId=None,):
23447 
    self.settlementId = settlementId
23448 
 
23449 
  def read(self, iprot):
23450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23452 
      return
23453 
    iprot.readStructBegin()
23454 
    while True:
23455 
      (fname, ftype, fid) = iprot.readFieldBegin()
23456 
      if ftype == TType.STOP:
23457 
        break
23458 
      if fid == 1:
23459 
        if ftype == TType.I64:
23460 
          self.settlementId = iprot.readI64();
23461 
        else:
23462 
          iprot.skip(ftype)
23463 
      else:
23464 
        iprot.skip(ftype)
23465 
      iprot.readFieldEnd()
23466 
    iprot.readStructEnd()
23467 
 
23468 
  def write(self, oprot):
23469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23471 
      return
23472 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23473 
    if self.settlementId is not None:
23474 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23475 
      oprot.writeI64(self.settlementId)
23476 
      oprot.writeFieldEnd()
23477 
    oprot.writeFieldStop()
23478 
    oprot.writeStructEnd()
23479 
 
23480 
  def validate(self):
23481 
    return
23482 
 
23483 
 
23484 
  def __repr__(self):
23485 
    L = ['%s=%r' % (key, value)
23486 
      for key, value in self.__dict__.iteritems()]
23487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23488 
 
23489 
  def __eq__(self, other):
23490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23491 
 
23492 
  def __ne__(self, other):
23493 
    return not (self == other)
23494 
 
23495 
class markEBSSettlementUploaded_result:
23496 
  """
23497 
  Attributes:
23498 
   - ex
23499 
  """
23500 
 
23501 
  thrift_spec = (
23502 
    None, # 0
23503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23504 
  )
23505 
 
23506 
  def __init__(self, ex=None,):
23507 
    self.ex = ex
23508 
 
23509 
  def read(self, iprot):
23510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23512 
      return
23513 
    iprot.readStructBegin()
23514 
    while True:
23515 
      (fname, ftype, fid) = iprot.readFieldBegin()
23516 
      if ftype == TType.STOP:
23517 
        break
23518 
      if fid == 1:
23519 
        if ftype == TType.STRUCT:
23520 
          self.ex = TransactionServiceException()
23521 
          self.ex.read(iprot)
23522 
        else:
23523 
          iprot.skip(ftype)
23524 
      else:
23525 
        iprot.skip(ftype)
23526 
      iprot.readFieldEnd()
23527 
    iprot.readStructEnd()
23528 
 
23529 
  def write(self, oprot):
23530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23532 
      return
23533 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23534 
    if self.ex is not None:
23535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23536 
      self.ex.write(oprot)
23537 
      oprot.writeFieldEnd()
23538 
    oprot.writeFieldStop()
23539 
    oprot.writeStructEnd()
23540 
 
23541 
  def validate(self):
23542 
    return
23543 
 
23544 
 
23545 
  def __repr__(self):
23546 
    L = ['%s=%r' % (key, value)
23547 
      for key, value in self.__dict__.iteritems()]
23548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23549 
 
23550 
  def __eq__(self, other):
23551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23552 
 
23553 
  def __ne__(self, other):
23554 
    return not (self == other)
23555 
 
23556 
class getEBSSettlementDate_args:
23557 
  """
23558 
  Attributes:
23559 
   - settlementId
23560 
  """
23561 
 
23562 
  thrift_spec = (
23563 
    None, # 0
23564 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23565 
  )
23566 
 
23567 
  def __init__(self, settlementId=None,):
23568 
    self.settlementId = settlementId
23569 
 
23570 
  def read(self, iprot):
23571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23573 
      return
23574 
    iprot.readStructBegin()
23575 
    while True:
23576 
      (fname, ftype, fid) = iprot.readFieldBegin()
23577 
      if ftype == TType.STOP:
23578 
        break
23579 
      if fid == 1:
23580 
        if ftype == TType.I64:
23581 
          self.settlementId = iprot.readI64();
23582 
        else:
23583 
          iprot.skip(ftype)
23584 
      else:
23585 
        iprot.skip(ftype)
23586 
      iprot.readFieldEnd()
23587 
    iprot.readStructEnd()
23588 
 
23589 
  def write(self, oprot):
23590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23592 
      return
23593 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23594 
    if self.settlementId is not None:
23595 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23596 
      oprot.writeI64(self.settlementId)
23597 
      oprot.writeFieldEnd()
23598 
    oprot.writeFieldStop()
23599 
    oprot.writeStructEnd()
23600 
 
23601 
  def validate(self):
23602 
    return
23603 
 
23604 
 
23605 
  def __repr__(self):
23606 
    L = ['%s=%r' % (key, value)
23607 
      for key, value in self.__dict__.iteritems()]
23608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23609 
 
23610 
  def __eq__(self, other):
23611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23612 
 
23613 
  def __ne__(self, other):
23614 
    return not (self == other)
23615 
 
23616 
class getEBSSettlementDate_result:
23617 
  """
23618 
  Attributes:
23619 
   - success
23620 
   - ex
23621 
  """
23622 
 
23623 
  thrift_spec = (
23624 
    (0, TType.I64, 'success', None, None, ), # 0
23625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23626 
  )
23627 
 
23628 
  def __init__(self, success=None, ex=None,):
23629 
    self.success = success
23630 
    self.ex = ex
23631 
 
23632 
  def read(self, iprot):
23633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23635 
      return
23636 
    iprot.readStructBegin()
23637 
    while True:
23638 
      (fname, ftype, fid) = iprot.readFieldBegin()
23639 
      if ftype == TType.STOP:
23640 
        break
23641 
      if fid == 0:
23642 
        if ftype == TType.I64:
23643 
          self.success = iprot.readI64();
23644 
        else:
23645 
          iprot.skip(ftype)
23646 
      elif fid == 1:
23647 
        if ftype == TType.STRUCT:
23648 
          self.ex = TransactionServiceException()
23649 
          self.ex.read(iprot)
23650 
        else:
23651 
          iprot.skip(ftype)
23652 
      else:
23653 
        iprot.skip(ftype)
23654 
      iprot.readFieldEnd()
23655 
    iprot.readStructEnd()
23656 
 
23657 
  def write(self, oprot):
23658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23660 
      return
23661 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23662 
    if self.success is not None:
23663 
      oprot.writeFieldBegin('success', TType.I64, 0)
23664 
      oprot.writeI64(self.success)
23665 
      oprot.writeFieldEnd()
23666 
    if self.ex is not None:
23667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23668 
      self.ex.write(oprot)
23669 
      oprot.writeFieldEnd()
23670 
    oprot.writeFieldStop()
23671 
    oprot.writeStructEnd()
23672 
 
23673 
  def validate(self):
23674 
    return
23675 
 
23676 
 
23677 
  def __repr__(self):
23678 
    L = ['%s=%r' % (key, value)
23679 
      for key, value in self.__dict__.iteritems()]
23680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23681 
 
23682 
  def __eq__(self, other):
23683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23684 
 
23685 
  def __ne__(self, other):
23686 
    return not (self == other)
4715 varun.gupt 23687 
 
23688 
class getSettlementsByDate_args:
23689 
  """
23690 
  Attributes:
23691 
   - settlementDateFrom
23692 
   - settlementDateTo
23693 
   - isRefund
23694 
  """
23695 
 
23696 
  thrift_spec = (
23697 
    None, # 0
23698 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23699 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23700 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23701 
  )
23702 
 
23703 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23704 
    self.settlementDateFrom = settlementDateFrom
23705 
    self.settlementDateTo = settlementDateTo
23706 
    self.isRefund = isRefund
23707 
 
23708 
  def read(self, iprot):
23709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23711 
      return
23712 
    iprot.readStructBegin()
23713 
    while True:
23714 
      (fname, ftype, fid) = iprot.readFieldBegin()
23715 
      if ftype == TType.STOP:
23716 
        break
23717 
      if fid == 1:
23718 
        if ftype == TType.I64:
23719 
          self.settlementDateFrom = iprot.readI64();
23720 
        else:
23721 
          iprot.skip(ftype)
23722 
      elif fid == 2:
23723 
        if ftype == TType.I64:
23724 
          self.settlementDateTo = iprot.readI64();
23725 
        else:
23726 
          iprot.skip(ftype)
23727 
      elif fid == 3:
23728 
        if ftype == TType.BOOL:
23729 
          self.isRefund = iprot.readBool();
23730 
        else:
23731 
          iprot.skip(ftype)
23732 
      else:
23733 
        iprot.skip(ftype)
23734 
      iprot.readFieldEnd()
23735 
    iprot.readStructEnd()
23736 
 
23737 
  def write(self, oprot):
23738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23740 
      return
23741 
    oprot.writeStructBegin('getSettlementsByDate_args')
23742 
    if self.settlementDateFrom is not None:
23743 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23744 
      oprot.writeI64(self.settlementDateFrom)
23745 
      oprot.writeFieldEnd()
23746 
    if self.settlementDateTo is not None:
23747 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23748 
      oprot.writeI64(self.settlementDateTo)
23749 
      oprot.writeFieldEnd()
23750 
    if self.isRefund is not None:
23751 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23752 
      oprot.writeBool(self.isRefund)
23753 
      oprot.writeFieldEnd()
23754 
    oprot.writeFieldStop()
23755 
    oprot.writeStructEnd()
23756 
 
23757 
  def validate(self):
23758 
    return
23759 
 
23760 
 
23761 
  def __repr__(self):
23762 
    L = ['%s=%r' % (key, value)
23763 
      for key, value in self.__dict__.iteritems()]
23764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23765 
 
23766 
  def __eq__(self, other):
23767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23768 
 
23769 
  def __ne__(self, other):
23770 
    return not (self == other)
23771 
 
23772 
class getSettlementsByDate_result:
23773 
  """
23774 
  Attributes:
23775 
   - success
23776 
   - ex
23777 
  """
23778 
 
23779 
  thrift_spec = (
23780 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23782 
  )
23783 
 
23784 
  def __init__(self, success=None, ex=None,):
23785 
    self.success = success
23786 
    self.ex = ex
23787 
 
23788 
  def read(self, iprot):
23789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23791 
      return
23792 
    iprot.readStructBegin()
23793 
    while True:
23794 
      (fname, ftype, fid) = iprot.readFieldBegin()
23795 
      if ftype == TType.STOP:
23796 
        break
23797 
      if fid == 0:
23798 
        if ftype == TType.LIST:
23799 
          self.success = []
6188 rajveer 23800 
          (_etype566, _size563) = iprot.readListBegin()
23801 
          for _i567 in xrange(_size563):
23802 
            _elem568 = PaymentSettlement()
23803 
            _elem568.read(iprot)
23804 
            self.success.append(_elem568)
4715 varun.gupt 23805 
          iprot.readListEnd()
23806 
        else:
23807 
          iprot.skip(ftype)
23808 
      elif fid == 1:
23809 
        if ftype == TType.STRUCT:
23810 
          self.ex = TransactionServiceException()
23811 
          self.ex.read(iprot)
23812 
        else:
23813 
          iprot.skip(ftype)
23814 
      else:
23815 
        iprot.skip(ftype)
23816 
      iprot.readFieldEnd()
23817 
    iprot.readStructEnd()
23818 
 
23819 
  def write(self, oprot):
23820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23822 
      return
23823 
    oprot.writeStructBegin('getSettlementsByDate_result')
23824 
    if self.success is not None:
23825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23826 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23827 
      for iter569 in self.success:
23828 
        iter569.write(oprot)
4715 varun.gupt 23829 
      oprot.writeListEnd()
23830 
      oprot.writeFieldEnd()
23831 
    if self.ex is not None:
23832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23833 
      self.ex.write(oprot)
23834 
      oprot.writeFieldEnd()
23835 
    oprot.writeFieldStop()
23836 
    oprot.writeStructEnd()
23837 
 
23838 
  def validate(self):
23839 
    return
23840 
 
23841 
 
23842 
  def __repr__(self):
23843 
    L = ['%s=%r' % (key, value)
23844 
      for key, value in self.__dict__.iteritems()]
23845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23846 
 
23847 
  def __eq__(self, other):
23848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23849 
 
23850 
  def __ne__(self, other):
23851 
    return not (self == other)
23852 
 
23853 
class getReshippedOrderIds_args:
23854 
  """
23855 
  Attributes:
23856 
   - orderIds
23857 
  """
23858 
 
23859 
  thrift_spec = (
23860 
    None, # 0
23861 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23862 
  )
23863 
 
23864 
  def __init__(self, orderIds=None,):
23865 
    self.orderIds = orderIds
23866 
 
23867 
  def read(self, iprot):
23868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23870 
      return
23871 
    iprot.readStructBegin()
23872 
    while True:
23873 
      (fname, ftype, fid) = iprot.readFieldBegin()
23874 
      if ftype == TType.STOP:
23875 
        break
23876 
      if fid == 1:
23877 
        if ftype == TType.LIST:
23878 
          self.orderIds = []
6188 rajveer 23879 
          (_etype573, _size570) = iprot.readListBegin()
23880 
          for _i574 in xrange(_size570):
23881 
            _elem575 = iprot.readI64();
23882 
            self.orderIds.append(_elem575)
4715 varun.gupt 23883 
          iprot.readListEnd()
23884 
        else:
23885 
          iprot.skip(ftype)
23886 
      else:
23887 
        iprot.skip(ftype)
23888 
      iprot.readFieldEnd()
23889 
    iprot.readStructEnd()
23890 
 
23891 
  def write(self, oprot):
23892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23894 
      return
23895 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23896 
    if self.orderIds is not None:
23897 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23898 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23899 
      for iter576 in self.orderIds:
23900 
        oprot.writeI64(iter576)
4715 varun.gupt 23901 
      oprot.writeListEnd()
23902 
      oprot.writeFieldEnd()
23903 
    oprot.writeFieldStop()
23904 
    oprot.writeStructEnd()
23905 
 
23906 
  def validate(self):
23907 
    return
23908 
 
23909 
 
23910 
  def __repr__(self):
23911 
    L = ['%s=%r' % (key, value)
23912 
      for key, value in self.__dict__.iteritems()]
23913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23914 
 
23915 
  def __eq__(self, other):
23916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23917 
 
23918 
  def __ne__(self, other):
23919 
    return not (self == other)
23920 
 
23921 
class getReshippedOrderIds_result:
23922 
  """
23923 
  Attributes:
23924 
   - success
23925 
   - ex
23926 
  """
23927 
 
23928 
  thrift_spec = (
23929 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23931 
  )
23932 
 
23933 
  def __init__(self, success=None, ex=None,):
23934 
    self.success = success
23935 
    self.ex = ex
23936 
 
23937 
  def read(self, iprot):
23938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23940 
      return
23941 
    iprot.readStructBegin()
23942 
    while True:
23943 
      (fname, ftype, fid) = iprot.readFieldBegin()
23944 
      if ftype == TType.STOP:
23945 
        break
23946 
      if fid == 0:
23947 
        if ftype == TType.LIST:
23948 
          self.success = []
6188 rajveer 23949 
          (_etype580, _size577) = iprot.readListBegin()
23950 
          for _i581 in xrange(_size577):
23951 
            _elem582 = iprot.readI64();
23952 
            self.success.append(_elem582)
4715 varun.gupt 23953 
          iprot.readListEnd()
23954 
        else:
23955 
          iprot.skip(ftype)
23956 
      elif fid == 1:
23957 
        if ftype == TType.STRUCT:
23958 
          self.ex = TransactionServiceException()
23959 
          self.ex.read(iprot)
23960 
        else:
23961 
          iprot.skip(ftype)
23962 
      else:
23963 
        iprot.skip(ftype)
23964 
      iprot.readFieldEnd()
23965 
    iprot.readStructEnd()
23966 
 
23967 
  def write(self, oprot):
23968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23970 
      return
23971 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23972 
    if self.success is not None:
23973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23974 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 23975 
      for iter583 in self.success:
23976 
        oprot.writeI64(iter583)
4715 varun.gupt 23977 
      oprot.writeListEnd()
23978 
      oprot.writeFieldEnd()
23979 
    if self.ex is not None:
23980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23981 
      self.ex.write(oprot)
23982 
      oprot.writeFieldEnd()
23983 
    oprot.writeFieldStop()
23984 
    oprot.writeStructEnd()
23985 
 
23986 
  def validate(self):
23987 
    return
23988 
 
23989 
 
23990 
  def __repr__(self):
23991 
    L = ['%s=%r' % (key, value)
23992 
      for key, value in self.__dict__.iteritems()]
23993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23994 
 
23995 
  def __eq__(self, other):
23996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23997 
 
23998 
  def __ne__(self, other):
23999 
    return not (self == other)
4757 mandeep.dh 24000 
 
5481 phani.kuma 24001 
class getBilledOrders_args:
4875 varun.gupt 24002 
  """
24003 
  Attributes:
24004 
   - vendorId
5481 phani.kuma 24005 
   - onlyVendorNotPaid
24006 
   - billingDateFrom
24007 
   - billingDateTo
4875 varun.gupt 24008 
  """
24009 
 
24010 
  thrift_spec = (
24011 
    None, # 0
24012 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24013 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24014 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24015 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24016 
  )
24017 
 
5481 phani.kuma 24018 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24019 
    self.vendorId = vendorId
5481 phani.kuma 24020 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24021 
    self.billingDateFrom = billingDateFrom
24022 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24023 
 
24024 
  def read(self, iprot):
24025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24027 
      return
24028 
    iprot.readStructBegin()
24029 
    while True:
24030 
      (fname, ftype, fid) = iprot.readFieldBegin()
24031 
      if ftype == TType.STOP:
24032 
        break
24033 
      if fid == 1:
24034 
        if ftype == TType.I64:
24035 
          self.vendorId = iprot.readI64();
24036 
        else:
24037 
          iprot.skip(ftype)
5481 phani.kuma 24038 
      elif fid == 2:
24039 
        if ftype == TType.BOOL:
24040 
          self.onlyVendorNotPaid = iprot.readBool();
24041 
        else:
24042 
          iprot.skip(ftype)
24043 
      elif fid == 3:
24044 
        if ftype == TType.I64:
24045 
          self.billingDateFrom = iprot.readI64();
24046 
        else:
24047 
          iprot.skip(ftype)
24048 
      elif fid == 4:
24049 
        if ftype == TType.I64:
24050 
          self.billingDateTo = iprot.readI64();
24051 
        else:
24052 
          iprot.skip(ftype)
4875 varun.gupt 24053 
      else:
24054 
        iprot.skip(ftype)
24055 
      iprot.readFieldEnd()
24056 
    iprot.readStructEnd()
24057 
 
24058 
  def write(self, oprot):
24059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24061 
      return
5481 phani.kuma 24062 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24063 
    if self.vendorId is not None:
24064 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24065 
      oprot.writeI64(self.vendorId)
24066 
      oprot.writeFieldEnd()
5481 phani.kuma 24067 
    if self.onlyVendorNotPaid is not None:
24068 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24069 
      oprot.writeBool(self.onlyVendorNotPaid)
24070 
      oprot.writeFieldEnd()
24071 
    if self.billingDateFrom is not None:
24072 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24073 
      oprot.writeI64(self.billingDateFrom)
24074 
      oprot.writeFieldEnd()
24075 
    if self.billingDateTo is not None:
24076 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24077 
      oprot.writeI64(self.billingDateTo)
24078 
      oprot.writeFieldEnd()
4875 varun.gupt 24079 
    oprot.writeFieldStop()
24080 
    oprot.writeStructEnd()
24081 
 
24082 
  def validate(self):
24083 
    return
24084 
 
24085 
 
24086 
  def __repr__(self):
24087 
    L = ['%s=%r' % (key, value)
24088 
      for key, value in self.__dict__.iteritems()]
24089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24090 
 
24091 
  def __eq__(self, other):
24092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24093 
 
24094 
  def __ne__(self, other):
24095 
    return not (self == other)
24096 
 
5481 phani.kuma 24097 
class getBilledOrders_result:
4875 varun.gupt 24098 
  """
24099 
  Attributes:
24100 
   - success
24101 
   - ex
24102 
  """
24103 
 
24104 
  thrift_spec = (
24105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24107 
  )
24108 
 
24109 
  def __init__(self, success=None, ex=None,):
24110 
    self.success = success
24111 
    self.ex = ex
24112 
 
24113 
  def read(self, iprot):
24114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24116 
      return
24117 
    iprot.readStructBegin()
24118 
    while True:
24119 
      (fname, ftype, fid) = iprot.readFieldBegin()
24120 
      if ftype == TType.STOP:
24121 
        break
24122 
      if fid == 0:
24123 
        if ftype == TType.LIST:
24124 
          self.success = []
6188 rajveer 24125 
          (_etype587, _size584) = iprot.readListBegin()
24126 
          for _i588 in xrange(_size584):
24127 
            _elem589 = Order()
24128 
            _elem589.read(iprot)
24129 
            self.success.append(_elem589)
4875 varun.gupt 24130 
          iprot.readListEnd()
24131 
        else:
24132 
          iprot.skip(ftype)
24133 
      elif fid == 1:
24134 
        if ftype == TType.STRUCT:
24135 
          self.ex = TransactionServiceException()
24136 
          self.ex.read(iprot)
24137 
        else:
24138 
          iprot.skip(ftype)
24139 
      else:
24140 
        iprot.skip(ftype)
24141 
      iprot.readFieldEnd()
24142 
    iprot.readStructEnd()
24143 
 
24144 
  def write(self, oprot):
24145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24147 
      return
5481 phani.kuma 24148 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24149 
    if self.success is not None:
24150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24152 
      for iter590 in self.success:
24153 
        iter590.write(oprot)
4875 varun.gupt 24154 
      oprot.writeListEnd()
24155 
      oprot.writeFieldEnd()
24156 
    if self.ex is not None:
24157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24158 
      self.ex.write(oprot)
24159 
      oprot.writeFieldEnd()
24160 
    oprot.writeFieldStop()
24161 
    oprot.writeStructEnd()
24162 
 
24163 
  def validate(self):
24164 
    return
24165 
 
24166 
 
24167 
  def __repr__(self):
24168 
    L = ['%s=%r' % (key, value)
24169 
      for key, value in self.__dict__.iteritems()]
24170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24171 
 
24172 
  def __eq__(self, other):
24173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24174 
 
24175 
  def __ne__(self, other):
24176 
    return not (self == other)
5031 varun.gupt 24177 
 
24178 
class getStatusDistributionOfOrders_args:
24179 
  """
24180 
  Attributes:
24181 
   - startDate
24182 
   - endDate
24183 
  """
24184 
 
24185 
  thrift_spec = (
24186 
    None, # 0
24187 
    (1, TType.I64, 'startDate', None, None, ), # 1
24188 
    (2, TType.I64, 'endDate', None, None, ), # 2
24189 
  )
24190 
 
24191 
  def __init__(self, startDate=None, endDate=None,):
24192 
    self.startDate = startDate
24193 
    self.endDate = endDate
24194 
 
24195 
  def read(self, iprot):
24196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24198 
      return
24199 
    iprot.readStructBegin()
24200 
    while True:
24201 
      (fname, ftype, fid) = iprot.readFieldBegin()
24202 
      if ftype == TType.STOP:
24203 
        break
24204 
      if fid == 1:
24205 
        if ftype == TType.I64:
24206 
          self.startDate = iprot.readI64();
24207 
        else:
24208 
          iprot.skip(ftype)
24209 
      elif fid == 2:
24210 
        if ftype == TType.I64:
24211 
          self.endDate = iprot.readI64();
24212 
        else:
24213 
          iprot.skip(ftype)
24214 
      else:
24215 
        iprot.skip(ftype)
24216 
      iprot.readFieldEnd()
24217 
    iprot.readStructEnd()
24218 
 
24219 
  def write(self, oprot):
24220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24222 
      return
24223 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24224 
    if self.startDate is not None:
24225 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24226 
      oprot.writeI64(self.startDate)
24227 
      oprot.writeFieldEnd()
24228 
    if self.endDate is not None:
24229 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24230 
      oprot.writeI64(self.endDate)
24231 
      oprot.writeFieldEnd()
24232 
    oprot.writeFieldStop()
24233 
    oprot.writeStructEnd()
24234 
 
24235 
  def validate(self):
24236 
    return
24237 
 
24238 
 
24239 
  def __repr__(self):
24240 
    L = ['%s=%r' % (key, value)
24241 
      for key, value in self.__dict__.iteritems()]
24242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24243 
 
24244 
  def __eq__(self, other):
24245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24246 
 
24247 
  def __ne__(self, other):
24248 
    return not (self == other)
24249 
 
24250 
class getStatusDistributionOfOrders_result:
24251 
  """
24252 
  Attributes:
24253 
   - success
24254 
   - ex
24255 
  """
24256 
 
24257 
  thrift_spec = (
24258 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24260 
  )
24261 
 
24262 
  def __init__(self, success=None, ex=None,):
24263 
    self.success = success
24264 
    self.ex = ex
24265 
 
24266 
  def read(self, iprot):
24267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24269 
      return
24270 
    iprot.readStructBegin()
24271 
    while True:
24272 
      (fname, ftype, fid) = iprot.readFieldBegin()
24273 
      if ftype == TType.STOP:
24274 
        break
24275 
      if fid == 0:
24276 
        if ftype == TType.MAP:
24277 
          self.success = {}
6188 rajveer 24278 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24279 
          for _i595 in xrange(_size591):
24280 
            _key596 = iprot.readI64();
24281 
            _val597 = iprot.readI64();
24282 
            self.success[_key596] = _val597
5031 varun.gupt 24283 
          iprot.readMapEnd()
24284 
        else:
24285 
          iprot.skip(ftype)
24286 
      elif fid == 1:
24287 
        if ftype == TType.STRUCT:
24288 
          self.ex = TransactionServiceException()
24289 
          self.ex.read(iprot)
24290 
        else:
24291 
          iprot.skip(ftype)
24292 
      else:
24293 
        iprot.skip(ftype)
24294 
      iprot.readFieldEnd()
24295 
    iprot.readStructEnd()
24296 
 
24297 
  def write(self, oprot):
24298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24300 
      return
24301 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24302 
    if self.success is not None:
24303 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24304 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24305 
      for kiter598,viter599 in self.success.items():
24306 
        oprot.writeI64(kiter598)
24307 
        oprot.writeI64(viter599)
5031 varun.gupt 24308 
      oprot.writeMapEnd()
24309 
      oprot.writeFieldEnd()
24310 
    if self.ex is not None:
24311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24312 
      self.ex.write(oprot)
24313 
      oprot.writeFieldEnd()
24314 
    oprot.writeFieldStop()
24315 
    oprot.writeStructEnd()
24316 
 
24317 
  def validate(self):
24318 
    return
24319 
 
24320 
 
24321 
  def __repr__(self):
24322 
    L = ['%s=%r' % (key, value)
24323 
      for key, value in self.__dict__.iteritems()]
24324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24325 
 
24326 
  def __eq__(self, other):
24327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24328 
 
24329 
  def __ne__(self, other):
24330 
    return not (self == other)
5067 varun.gupt 24331 
 
24332 
class getOrderIdsForStatus_args:
24333 
  """
24334 
  Attributes:
24335 
   - status
24336 
   - startDatetime
24337 
   - endDatetime
24338 
  """
24339 
 
24340 
  thrift_spec = (
24341 
    None, # 0
24342 
    (1, TType.I64, 'status', None, None, ), # 1
24343 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24344 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24345 
  )
24346 
 
24347 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24348 
    self.status = status
24349 
    self.startDatetime = startDatetime
24350 
    self.endDatetime = endDatetime
24351 
 
24352 
  def read(self, iprot):
24353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24355 
      return
24356 
    iprot.readStructBegin()
24357 
    while True:
24358 
      (fname, ftype, fid) = iprot.readFieldBegin()
24359 
      if ftype == TType.STOP:
24360 
        break
24361 
      if fid == 1:
24362 
        if ftype == TType.I64:
24363 
          self.status = iprot.readI64();
24364 
        else:
24365 
          iprot.skip(ftype)
24366 
      elif fid == 2:
24367 
        if ftype == TType.I64:
24368 
          self.startDatetime = iprot.readI64();
24369 
        else:
24370 
          iprot.skip(ftype)
24371 
      elif fid == 3:
24372 
        if ftype == TType.I64:
24373 
          self.endDatetime = iprot.readI64();
24374 
        else:
24375 
          iprot.skip(ftype)
24376 
      else:
24377 
        iprot.skip(ftype)
24378 
      iprot.readFieldEnd()
24379 
    iprot.readStructEnd()
24380 
 
24381 
  def write(self, oprot):
24382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24384 
      return
24385 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24386 
    if self.status is not None:
24387 
      oprot.writeFieldBegin('status', TType.I64, 1)
24388 
      oprot.writeI64(self.status)
24389 
      oprot.writeFieldEnd()
24390 
    if self.startDatetime is not None:
24391 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24392 
      oprot.writeI64(self.startDatetime)
24393 
      oprot.writeFieldEnd()
24394 
    if self.endDatetime is not None:
24395 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24396 
      oprot.writeI64(self.endDatetime)
24397 
      oprot.writeFieldEnd()
24398 
    oprot.writeFieldStop()
24399 
    oprot.writeStructEnd()
24400 
 
24401 
  def validate(self):
24402 
    return
24403 
 
24404 
 
24405 
  def __repr__(self):
24406 
    L = ['%s=%r' % (key, value)
24407 
      for key, value in self.__dict__.iteritems()]
24408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24409 
 
24410 
  def __eq__(self, other):
24411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24412 
 
24413 
  def __ne__(self, other):
24414 
    return not (self == other)
24415 
 
24416 
class getOrderIdsForStatus_result:
24417 
  """
24418 
  Attributes:
24419 
   - success
24420 
   - ex
24421 
  """
24422 
 
24423 
  thrift_spec = (
24424 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24426 
  )
24427 
 
24428 
  def __init__(self, success=None, ex=None,):
24429 
    self.success = success
24430 
    self.ex = ex
24431 
 
24432 
  def read(self, iprot):
24433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24435 
      return
24436 
    iprot.readStructBegin()
24437 
    while True:
24438 
      (fname, ftype, fid) = iprot.readFieldBegin()
24439 
      if ftype == TType.STOP:
24440 
        break
24441 
      if fid == 0:
24442 
        if ftype == TType.LIST:
24443 
          self.success = []
6188 rajveer 24444 
          (_etype603, _size600) = iprot.readListBegin()
24445 
          for _i604 in xrange(_size600):
24446 
            _elem605 = iprot.readI64();
24447 
            self.success.append(_elem605)
5067 varun.gupt 24448 
          iprot.readListEnd()
24449 
        else:
24450 
          iprot.skip(ftype)
24451 
      elif fid == 1:
24452 
        if ftype == TType.STRUCT:
24453 
          self.ex = TransactionServiceException()
24454 
          self.ex.read(iprot)
24455 
        else:
24456 
          iprot.skip(ftype)
24457 
      else:
24458 
        iprot.skip(ftype)
24459 
      iprot.readFieldEnd()
24460 
    iprot.readStructEnd()
24461 
 
24462 
  def write(self, oprot):
24463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24465 
      return
24466 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24467 
    if self.success is not None:
24468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24469 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24470 
      for iter606 in self.success:
24471 
        oprot.writeI64(iter606)
5067 varun.gupt 24472 
      oprot.writeListEnd()
24473 
      oprot.writeFieldEnd()
24474 
    if self.ex is not None:
24475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24476 
      self.ex.write(oprot)
24477 
      oprot.writeFieldEnd()
24478 
    oprot.writeFieldStop()
24479 
    oprot.writeStructEnd()
24480 
 
24481 
  def validate(self):
24482 
    return
24483 
 
24484 
 
24485 
  def __repr__(self):
24486 
    L = ['%s=%r' % (key, value)
24487 
      for key, value in self.__dict__.iteritems()]
24488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24489 
 
24490 
  def __eq__(self, other):
24491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24492 
 
24493 
  def __ne__(self, other):
24494 
    return not (self == other)
5099 varun.gupt 24495 
 
5348 anupam.sin 24496 
class updateCODAgent_args:
24497 
  """
24498 
  Attributes:
24499 
   - agent
24500 
   - orderId
24501 
  """
24502 
 
24503 
  thrift_spec = (
24504 
    None, # 0
24505 
    (1, TType.STRING, 'agent', None, None, ), # 1
24506 
    (2, TType.I64, 'orderId', None, None, ), # 2
24507 
  )
24508 
 
24509 
  def __init__(self, agent=None, orderId=None,):
24510 
    self.agent = agent
24511 
    self.orderId = orderId
24512 
 
24513 
  def read(self, iprot):
24514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24516 
      return
24517 
    iprot.readStructBegin()
24518 
    while True:
24519 
      (fname, ftype, fid) = iprot.readFieldBegin()
24520 
      if ftype == TType.STOP:
24521 
        break
24522 
      if fid == 1:
24523 
        if ftype == TType.STRING:
24524 
          self.agent = iprot.readString();
24525 
        else:
24526 
          iprot.skip(ftype)
24527 
      elif fid == 2:
24528 
        if ftype == TType.I64:
24529 
          self.orderId = iprot.readI64();
24530 
        else:
24531 
          iprot.skip(ftype)
24532 
      else:
24533 
        iprot.skip(ftype)
24534 
      iprot.readFieldEnd()
24535 
    iprot.readStructEnd()
24536 
 
24537 
  def write(self, oprot):
24538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24540 
      return
24541 
    oprot.writeStructBegin('updateCODAgent_args')
24542 
    if self.agent is not None:
24543 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24544 
      oprot.writeString(self.agent)
24545 
      oprot.writeFieldEnd()
24546 
    if self.orderId is not None:
24547 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24548 
      oprot.writeI64(self.orderId)
24549 
      oprot.writeFieldEnd()
24550 
    oprot.writeFieldStop()
24551 
    oprot.writeStructEnd()
24552 
 
24553 
  def validate(self):
24554 
    return
24555 
 
24556 
 
24557 
  def __repr__(self):
24558 
    L = ['%s=%r' % (key, value)
24559 
      for key, value in self.__dict__.iteritems()]
24560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24561 
 
24562 
  def __eq__(self, other):
24563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24564 
 
24565 
  def __ne__(self, other):
24566 
    return not (self == other)
24567 
 
24568 
class updateCODAgent_result:
24569 
  """
24570 
  Attributes:
24571 
   - ex
24572 
  """
24573 
 
24574 
  thrift_spec = (
24575 
    None, # 0
24576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24577 
  )
24578 
 
24579 
  def __init__(self, ex=None,):
24580 
    self.ex = ex
24581 
 
24582 
  def read(self, iprot):
24583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24585 
      return
24586 
    iprot.readStructBegin()
24587 
    while True:
24588 
      (fname, ftype, fid) = iprot.readFieldBegin()
24589 
      if ftype == TType.STOP:
24590 
        break
24591 
      if fid == 1:
24592 
        if ftype == TType.STRUCT:
24593 
          self.ex = TransactionServiceException()
24594 
          self.ex.read(iprot)
24595 
        else:
24596 
          iprot.skip(ftype)
24597 
      else:
24598 
        iprot.skip(ftype)
24599 
      iprot.readFieldEnd()
24600 
    iprot.readStructEnd()
24601 
 
24602 
  def write(self, oprot):
24603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24605 
      return
24606 
    oprot.writeStructBegin('updateCODAgent_result')
24607 
    if self.ex is not None:
24608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24609 
      self.ex.write(oprot)
24610 
      oprot.writeFieldEnd()
24611 
    oprot.writeFieldStop()
24612 
    oprot.writeStructEnd()
24613 
 
24614 
  def validate(self):
24615 
    return
24616 
 
24617 
 
24618 
  def __repr__(self):
24619 
    L = ['%s=%r' % (key, value)
24620 
      for key, value in self.__dict__.iteritems()]
24621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24622 
 
24623 
  def __eq__(self, other):
24624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24625 
 
24626 
  def __ne__(self, other):
24627 
    return not (self == other)
24628 
 
5099 varun.gupt 24629 
class updateOrderAsPaidToVendor_args:
24630 
  """
24631 
  Attributes:
24632 
   - orderId
24633 
  """
24634 
 
24635 
  thrift_spec = (
24636 
    None, # 0
24637 
    (1, TType.I64, 'orderId', None, None, ), # 1
24638 
  )
24639 
 
24640 
  def __init__(self, orderId=None,):
24641 
    self.orderId = orderId
24642 
 
24643 
  def read(self, iprot):
24644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24646 
      return
24647 
    iprot.readStructBegin()
24648 
    while True:
24649 
      (fname, ftype, fid) = iprot.readFieldBegin()
24650 
      if ftype == TType.STOP:
24651 
        break
24652 
      if fid == 1:
24653 
        if ftype == TType.I64:
24654 
          self.orderId = iprot.readI64();
24655 
        else:
24656 
          iprot.skip(ftype)
24657 
      else:
24658 
        iprot.skip(ftype)
24659 
      iprot.readFieldEnd()
24660 
    iprot.readStructEnd()
24661 
 
24662 
  def write(self, oprot):
24663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24665 
      return
24666 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24667 
    if self.orderId is not None:
24668 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24669 
      oprot.writeI64(self.orderId)
24670 
      oprot.writeFieldEnd()
24671 
    oprot.writeFieldStop()
24672 
    oprot.writeStructEnd()
24673 
 
24674 
  def validate(self):
24675 
    return
24676 
 
24677 
 
24678 
  def __repr__(self):
24679 
    L = ['%s=%r' % (key, value)
24680 
      for key, value in self.__dict__.iteritems()]
24681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24682 
 
24683 
  def __eq__(self, other):
24684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24685 
 
24686 
  def __ne__(self, other):
24687 
    return not (self == other)
24688 
 
24689 
class updateOrderAsPaidToVendor_result:
24690 
  """
24691 
  Attributes:
24692 
   - ex
24693 
  """
24694 
 
24695 
  thrift_spec = (
24696 
    None, # 0
24697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24698 
  )
24699 
 
24700 
  def __init__(self, ex=None,):
24701 
    self.ex = ex
24702 
 
24703 
  def read(self, iprot):
24704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24706 
      return
24707 
    iprot.readStructBegin()
24708 
    while True:
24709 
      (fname, ftype, fid) = iprot.readFieldBegin()
24710 
      if ftype == TType.STOP:
24711 
        break
24712 
      if fid == 1:
24713 
        if ftype == TType.STRUCT:
24714 
          self.ex = TransactionServiceException()
24715 
          self.ex.read(iprot)
24716 
        else:
24717 
          iprot.skip(ftype)
24718 
      else:
24719 
        iprot.skip(ftype)
24720 
      iprot.readFieldEnd()
24721 
    iprot.readStructEnd()
24722 
 
24723 
  def write(self, oprot):
24724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24726 
      return
24727 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24728 
    if self.ex is not None:
24729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24730 
      self.ex.write(oprot)
24731 
      oprot.writeFieldEnd()
24732 
    oprot.writeFieldStop()
24733 
    oprot.writeStructEnd()
24734 
 
24735 
  def validate(self):
24736 
    return
24737 
 
24738 
 
24739 
  def __repr__(self):
24740 
    L = ['%s=%r' % (key, value)
24741 
      for key, value in self.__dict__.iteritems()]
24742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24743 
 
24744 
  def __eq__(self, other):
24745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24746 
 
24747 
  def __ne__(self, other):
24748 
    return not (self == other)
5208 varun.gupt 24749 
 
5386 phani.kuma 24750 
class updateOrderOnlyAsPaidToVendor_args:
24751 
  """
24752 
  Attributes:
24753 
   - orderId
24754 
  """
24755 
 
24756 
  thrift_spec = (
24757 
    None, # 0
24758 
    (1, TType.I64, 'orderId', None, None, ), # 1
24759 
  )
24760 
 
24761 
  def __init__(self, orderId=None,):
24762 
    self.orderId = orderId
24763 
 
24764 
  def read(self, iprot):
24765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24767 
      return
24768 
    iprot.readStructBegin()
24769 
    while True:
24770 
      (fname, ftype, fid) = iprot.readFieldBegin()
24771 
      if ftype == TType.STOP:
24772 
        break
24773 
      if fid == 1:
24774 
        if ftype == TType.I64:
24775 
          self.orderId = iprot.readI64();
24776 
        else:
24777 
          iprot.skip(ftype)
24778 
      else:
24779 
        iprot.skip(ftype)
24780 
      iprot.readFieldEnd()
24781 
    iprot.readStructEnd()
24782 
 
24783 
  def write(self, oprot):
24784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24786 
      return
24787 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24788 
    if self.orderId is not None:
24789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24790 
      oprot.writeI64(self.orderId)
24791 
      oprot.writeFieldEnd()
24792 
    oprot.writeFieldStop()
24793 
    oprot.writeStructEnd()
24794 
 
24795 
  def validate(self):
24796 
    return
24797 
 
24798 
 
24799 
  def __repr__(self):
24800 
    L = ['%s=%r' % (key, value)
24801 
      for key, value in self.__dict__.iteritems()]
24802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24803 
 
24804 
  def __eq__(self, other):
24805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24806 
 
24807 
  def __ne__(self, other):
24808 
    return not (self == other)
24809 
 
24810 
class updateOrderOnlyAsPaidToVendor_result:
24811 
  """
24812 
  Attributes:
24813 
   - ex
24814 
  """
24815 
 
24816 
  thrift_spec = (
24817 
    None, # 0
24818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24819 
  )
24820 
 
24821 
  def __init__(self, ex=None,):
24822 
    self.ex = ex
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 
      if fid == 1:
24834 
        if ftype == TType.STRUCT:
24835 
          self.ex = TransactionServiceException()
24836 
          self.ex.read(iprot)
24837 
        else:
24838 
          iprot.skip(ftype)
24839 
      else:
24840 
        iprot.skip(ftype)
24841 
      iprot.readFieldEnd()
24842 
    iprot.readStructEnd()
24843 
 
24844 
  def write(self, oprot):
24845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24847 
      return
24848 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24849 
    if self.ex is not None:
24850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24851 
      self.ex.write(oprot)
24852 
      oprot.writeFieldEnd()
24853 
    oprot.writeFieldStop()
24854 
    oprot.writeStructEnd()
24855 
 
24856 
  def validate(self):
24857 
    return
24858 
 
24859 
 
24860 
  def __repr__(self):
24861 
    L = ['%s=%r' % (key, value)
24862 
      for key, value in self.__dict__.iteritems()]
24863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24864 
 
24865 
  def __eq__(self, other):
24866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24867 
 
24868 
  def __ne__(self, other):
24869 
    return not (self == other)
24870 
 
5208 varun.gupt 24871 
class getRefundedOrdersMarkedPaid_args:
24872 
 
24873 
  thrift_spec = (
24874 
  )
24875 
 
24876 
  def read(self, iprot):
24877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24879 
      return
24880 
    iprot.readStructBegin()
24881 
    while True:
24882 
      (fname, ftype, fid) = iprot.readFieldBegin()
24883 
      if ftype == TType.STOP:
24884 
        break
24885 
      else:
24886 
        iprot.skip(ftype)
24887 
      iprot.readFieldEnd()
24888 
    iprot.readStructEnd()
24889 
 
24890 
  def write(self, oprot):
24891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24893 
      return
24894 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24895 
    oprot.writeFieldStop()
24896 
    oprot.writeStructEnd()
24897 
 
24898 
  def validate(self):
24899 
    return
24900 
 
24901 
 
24902 
  def __repr__(self):
24903 
    L = ['%s=%r' % (key, value)
24904 
      for key, value in self.__dict__.iteritems()]
24905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24906 
 
24907 
  def __eq__(self, other):
24908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24909 
 
24910 
  def __ne__(self, other):
24911 
    return not (self == other)
24912 
 
24913 
class getRefundedOrdersMarkedPaid_result:
24914 
  """
24915 
  Attributes:
24916 
   - success
24917 
   - ex
24918 
  """
24919 
 
24920 
  thrift_spec = (
24921 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24923 
  )
24924 
 
24925 
  def __init__(self, success=None, ex=None,):
24926 
    self.success = success
24927 
    self.ex = ex
24928 
 
24929 
  def read(self, iprot):
24930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24932 
      return
24933 
    iprot.readStructBegin()
24934 
    while True:
24935 
      (fname, ftype, fid) = iprot.readFieldBegin()
24936 
      if ftype == TType.STOP:
24937 
        break
24938 
      if fid == 0:
24939 
        if ftype == TType.LIST:
24940 
          self.success = []
6188 rajveer 24941 
          (_etype610, _size607) = iprot.readListBegin()
24942 
          for _i611 in xrange(_size607):
24943 
            _elem612 = Order()
24944 
            _elem612.read(iprot)
24945 
            self.success.append(_elem612)
5208 varun.gupt 24946 
          iprot.readListEnd()
24947 
        else:
24948 
          iprot.skip(ftype)
24949 
      elif fid == 1:
24950 
        if ftype == TType.STRUCT:
24951 
          self.ex = TransactionServiceException()
24952 
          self.ex.read(iprot)
24953 
        else:
24954 
          iprot.skip(ftype)
24955 
      else:
24956 
        iprot.skip(ftype)
24957 
      iprot.readFieldEnd()
24958 
    iprot.readStructEnd()
24959 
 
24960 
  def write(self, oprot):
24961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24963 
      return
24964 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24965 
    if self.success is not None:
24966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24967 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24968 
      for iter613 in self.success:
24969 
        iter613.write(oprot)
5208 varun.gupt 24970 
      oprot.writeListEnd()
24971 
      oprot.writeFieldEnd()
24972 
    if self.ex is not None:
24973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24974 
      self.ex.write(oprot)
24975 
      oprot.writeFieldEnd()
24976 
    oprot.writeFieldStop()
24977 
    oprot.writeStructEnd()
24978 
 
24979 
  def validate(self):
24980 
    return
24981 
 
24982 
 
24983 
  def __repr__(self):
24984 
    L = ['%s=%r' % (key, value)
24985 
      for key, value in self.__dict__.iteritems()]
24986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24987 
 
24988 
  def __eq__(self, other):
24989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24990 
 
24991 
  def __ne__(self, other):
24992 
    return not (self == other)
5447 anupam.sin 24993 
 
24994 
class getAllVerificationAgents_args:
24995 
  """
24996 
  Attributes:
24997 
   - minOrderId
24998 
   - maxOrderId
24999 
  """
25000 
 
25001 
  thrift_spec = (
25002 
    None, # 0
25003 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25004 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25005 
  )
25006 
 
25007 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25008 
    self.minOrderId = minOrderId
25009 
    self.maxOrderId = maxOrderId
25010 
 
25011 
  def read(self, iprot):
25012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25014 
      return
25015 
    iprot.readStructBegin()
25016 
    while True:
25017 
      (fname, ftype, fid) = iprot.readFieldBegin()
25018 
      if ftype == TType.STOP:
25019 
        break
25020 
      if fid == 1:
25021 
        if ftype == TType.I64:
25022 
          self.minOrderId = iprot.readI64();
25023 
        else:
25024 
          iprot.skip(ftype)
25025 
      elif fid == 2:
25026 
        if ftype == TType.I64:
25027 
          self.maxOrderId = iprot.readI64();
25028 
        else:
25029 
          iprot.skip(ftype)
25030 
      else:
25031 
        iprot.skip(ftype)
25032 
      iprot.readFieldEnd()
25033 
    iprot.readStructEnd()
25034 
 
25035 
  def write(self, oprot):
25036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25038 
      return
25039 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25040 
    if self.minOrderId is not None:
25041 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25042 
      oprot.writeI64(self.minOrderId)
25043 
      oprot.writeFieldEnd()
25044 
    if self.maxOrderId is not None:
25045 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25046 
      oprot.writeI64(self.maxOrderId)
25047 
      oprot.writeFieldEnd()
25048 
    oprot.writeFieldStop()
25049 
    oprot.writeStructEnd()
25050 
 
25051 
  def validate(self):
25052 
    return
25053 
 
25054 
 
25055 
  def __repr__(self):
25056 
    L = ['%s=%r' % (key, value)
25057 
      for key, value in self.__dict__.iteritems()]
25058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25059 
 
25060 
  def __eq__(self, other):
25061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25062 
 
25063 
  def __ne__(self, other):
25064 
    return not (self == other)
25065 
 
25066 
class getAllVerificationAgents_result:
25067 
  """
25068 
  Attributes:
25069 
   - success
25070 
  """
25071 
 
25072 
  thrift_spec = (
25073 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25074 
  )
25075 
 
25076 
  def __init__(self, success=None,):
25077 
    self.success = success
25078 
 
25079 
  def read(self, iprot):
25080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25082 
      return
25083 
    iprot.readStructBegin()
25084 
    while True:
25085 
      (fname, ftype, fid) = iprot.readFieldBegin()
25086 
      if ftype == TType.STOP:
25087 
        break
25088 
      if fid == 0:
25089 
        if ftype == TType.LIST:
25090 
          self.success = []
6188 rajveer 25091 
          (_etype617, _size614) = iprot.readListBegin()
25092 
          for _i618 in xrange(_size614):
25093 
            _elem619 = CODVerificationAgent()
25094 
            _elem619.read(iprot)
25095 
            self.success.append(_elem619)
5447 anupam.sin 25096 
          iprot.readListEnd()
25097 
        else:
25098 
          iprot.skip(ftype)
25099 
      else:
25100 
        iprot.skip(ftype)
25101 
      iprot.readFieldEnd()
25102 
    iprot.readStructEnd()
25103 
 
25104 
  def write(self, oprot):
25105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25107 
      return
25108 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25109 
    if self.success is not None:
25110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25112 
      for iter620 in self.success:
25113 
        iter620.write(oprot)
5447 anupam.sin 25114 
      oprot.writeListEnd()
25115 
      oprot.writeFieldEnd()
25116 
    oprot.writeFieldStop()
25117 
    oprot.writeStructEnd()
25118 
 
25119 
  def validate(self):
25120 
    return
25121 
 
25122 
 
25123 
  def __repr__(self):
25124 
    L = ['%s=%r' % (key, value)
25125 
      for key, value in self.__dict__.iteritems()]
25126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25127 
 
25128 
  def __eq__(self, other):
25129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25130 
 
25131 
  def __ne__(self, other):
25132 
    return not (self == other)
5527 anupam.sin 25133 
 
25134 
class getAllAttributesForOrderId_args:
25135 
  """
25136 
  Attributes:
25137 
   - orderId
25138 
  """
25139 
 
25140 
  thrift_spec = (
25141 
    None, # 0
25142 
    (1, TType.I64, 'orderId', None, None, ), # 1
25143 
  )
25144 
 
25145 
  def __init__(self, orderId=None,):
25146 
    self.orderId = orderId
25147 
 
25148 
  def read(self, iprot):
25149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25151 
      return
25152 
    iprot.readStructBegin()
25153 
    while True:
25154 
      (fname, ftype, fid) = iprot.readFieldBegin()
25155 
      if ftype == TType.STOP:
25156 
        break
25157 
      if fid == 1:
25158 
        if ftype == TType.I64:
25159 
          self.orderId = iprot.readI64();
25160 
        else:
25161 
          iprot.skip(ftype)
25162 
      else:
25163 
        iprot.skip(ftype)
25164 
      iprot.readFieldEnd()
25165 
    iprot.readStructEnd()
25166 
 
25167 
  def write(self, oprot):
25168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25170 
      return
25171 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25172 
    if self.orderId is not None:
25173 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25174 
      oprot.writeI64(self.orderId)
25175 
      oprot.writeFieldEnd()
25176 
    oprot.writeFieldStop()
25177 
    oprot.writeStructEnd()
25178 
 
25179 
  def validate(self):
25180 
    return
25181 
 
25182 
 
25183 
  def __repr__(self):
25184 
    L = ['%s=%r' % (key, value)
25185 
      for key, value in self.__dict__.iteritems()]
25186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25187 
 
25188 
  def __eq__(self, other):
25189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25190 
 
25191 
  def __ne__(self, other):
25192 
    return not (self == other)
25193 
 
25194 
class getAllAttributesForOrderId_result:
25195 
  """
25196 
  Attributes:
25197 
   - success
25198 
  """
25199 
 
25200 
  thrift_spec = (
25201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25202 
  )
25203 
 
25204 
  def __init__(self, success=None,):
25205 
    self.success = success
25206 
 
25207 
  def read(self, iprot):
25208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25210 
      return
25211 
    iprot.readStructBegin()
25212 
    while True:
25213 
      (fname, ftype, fid) = iprot.readFieldBegin()
25214 
      if ftype == TType.STOP:
25215 
        break
25216 
      if fid == 0:
25217 
        if ftype == TType.LIST:
25218 
          self.success = []
6188 rajveer 25219 
          (_etype624, _size621) = iprot.readListBegin()
25220 
          for _i625 in xrange(_size621):
25221 
            _elem626 = Attribute()
25222 
            _elem626.read(iprot)
25223 
            self.success.append(_elem626)
5527 anupam.sin 25224 
          iprot.readListEnd()
25225 
        else:
25226 
          iprot.skip(ftype)
25227 
      else:
25228 
        iprot.skip(ftype)
25229 
      iprot.readFieldEnd()
25230 
    iprot.readStructEnd()
25231 
 
25232 
  def write(self, oprot):
25233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25235 
      return
25236 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25237 
    if self.success is not None:
25238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25240 
      for iter627 in self.success:
25241 
        iter627.write(oprot)
5527 anupam.sin 25242 
      oprot.writeListEnd()
25243 
      oprot.writeFieldEnd()
25244 
    oprot.writeFieldStop()
25245 
    oprot.writeStructEnd()
25246 
 
25247 
  def validate(self):
25248 
    return
25249 
 
25250 
 
25251 
  def __repr__(self):
25252 
    L = ['%s=%r' % (key, value)
25253 
      for key, value in self.__dict__.iteritems()]
25254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25255 
 
25256 
  def __eq__(self, other):
25257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25258 
 
25259 
  def __ne__(self, other):
25260 
    return not (self == other)
25261 
 
5676 rajveer 25262 
class setOrderAttributes_args:
25263 
  """
25264 
  Attributes:
25265 
   - orderId
25266 
   - attributes
25267 
  """
25268 
 
25269 
  thrift_spec = None
25270 
  def __init__(self, orderId=None, attributes=None,):
25271 
    self.orderId = orderId
25272 
    self.attributes = attributes
25273 
 
25274 
  def read(self, iprot):
25275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25277 
      return
25278 
    iprot.readStructBegin()
25279 
    while True:
25280 
      (fname, ftype, fid) = iprot.readFieldBegin()
25281 
      if ftype == TType.STOP:
25282 
        break
25283 
      if fid == 1:
25284 
        if ftype == TType.I64:
25285 
          self.orderId = iprot.readI64();
25286 
        else:
25287 
          iprot.skip(ftype)
25288 
      elif fid == -1:
25289 
        if ftype == TType.LIST:
25290 
          self.attributes = []
6188 rajveer 25291 
          (_etype631, _size628) = iprot.readListBegin()
25292 
          for _i632 in xrange(_size628):
25293 
            _elem633 = Attribute()
25294 
            _elem633.read(iprot)
25295 
            self.attributes.append(_elem633)
5676 rajveer 25296 
          iprot.readListEnd()
25297 
        else:
25298 
          iprot.skip(ftype)
25299 
      else:
25300 
        iprot.skip(ftype)
25301 
      iprot.readFieldEnd()
25302 
    iprot.readStructEnd()
25303 
 
25304 
  def write(self, oprot):
25305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25307 
      return
25308 
    oprot.writeStructBegin('setOrderAttributes_args')
25309 
    if self.attributes is not None:
25310 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25311 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25312 
      for iter634 in self.attributes:
25313 
        iter634.write(oprot)
5676 rajveer 25314 
      oprot.writeListEnd()
25315 
      oprot.writeFieldEnd()
25316 
    if self.orderId is not None:
25317 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25318 
      oprot.writeI64(self.orderId)
25319 
      oprot.writeFieldEnd()
25320 
    oprot.writeFieldStop()
25321 
    oprot.writeStructEnd()
25322 
 
25323 
  def validate(self):
25324 
    return
25325 
 
25326 
 
25327 
  def __repr__(self):
25328 
    L = ['%s=%r' % (key, value)
25329 
      for key, value in self.__dict__.iteritems()]
25330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25331 
 
25332 
  def __eq__(self, other):
25333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25334 
 
25335 
  def __ne__(self, other):
25336 
    return not (self == other)
25337 
 
25338 
class setOrderAttributes_result:
25339 
 
25340 
  thrift_spec = (
25341 
  )
25342 
 
25343 
  def read(self, iprot):
25344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25346 
      return
25347 
    iprot.readStructBegin()
25348 
    while True:
25349 
      (fname, ftype, fid) = iprot.readFieldBegin()
25350 
      if ftype == TType.STOP:
25351 
        break
25352 
      else:
25353 
        iprot.skip(ftype)
25354 
      iprot.readFieldEnd()
25355 
    iprot.readStructEnd()
25356 
 
25357 
  def write(self, oprot):
25358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25360 
      return
25361 
    oprot.writeStructBegin('setOrderAttributes_result')
25362 
    oprot.writeFieldStop()
25363 
    oprot.writeStructEnd()
25364 
 
25365 
  def validate(self):
25366 
    return
25367 
 
25368 
 
25369 
  def __repr__(self):
25370 
    L = ['%s=%r' % (key, value)
25371 
      for key, value in self.__dict__.iteritems()]
25372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25373 
 
25374 
  def __eq__(self, other):
25375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25376 
 
25377 
  def __ne__(self, other):
25378 
    return not (self == other)
25379 
 
5527 anupam.sin 25380 
class setOrderAttributeForTransaction_args:
25381 
  """
25382 
  Attributes:
25383 
   - transactionId
25384 
   - attribute
25385 
  """
25386 
 
25387 
  thrift_spec = None
25388 
  def __init__(self, transactionId=None, attribute=None,):
25389 
    self.transactionId = transactionId
25390 
    self.attribute = attribute
25391 
 
25392 
  def read(self, iprot):
25393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25395 
      return
25396 
    iprot.readStructBegin()
25397 
    while True:
25398 
      (fname, ftype, fid) = iprot.readFieldBegin()
25399 
      if ftype == TType.STOP:
25400 
        break
25401 
      if fid == 1:
25402 
        if ftype == TType.I64:
25403 
          self.transactionId = iprot.readI64();
25404 
        else:
25405 
          iprot.skip(ftype)
25406 
      elif fid == -1:
25407 
        if ftype == TType.STRUCT:
25408 
          self.attribute = Attribute()
25409 
          self.attribute.read(iprot)
25410 
        else:
25411 
          iprot.skip(ftype)
25412 
      else:
25413 
        iprot.skip(ftype)
25414 
      iprot.readFieldEnd()
25415 
    iprot.readStructEnd()
25416 
 
25417 
  def write(self, oprot):
25418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25420 
      return
25421 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25422 
    if self.attribute is not None:
25423 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25424 
      self.attribute.write(oprot)
25425 
      oprot.writeFieldEnd()
25426 
    if self.transactionId is not None:
25427 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25428 
      oprot.writeI64(self.transactionId)
25429 
      oprot.writeFieldEnd()
25430 
    oprot.writeFieldStop()
25431 
    oprot.writeStructEnd()
25432 
 
25433 
  def validate(self):
25434 
    return
25435 
 
25436 
 
25437 
  def __repr__(self):
25438 
    L = ['%s=%r' % (key, value)
25439 
      for key, value in self.__dict__.iteritems()]
25440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25441 
 
25442 
  def __eq__(self, other):
25443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25444 
 
25445 
  def __ne__(self, other):
25446 
    return not (self == other)
25447 
 
25448 
class setOrderAttributeForTransaction_result:
25449 
 
25450 
  thrift_spec = (
25451 
  )
25452 
 
25453 
  def read(self, iprot):
25454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25456 
      return
25457 
    iprot.readStructBegin()
25458 
    while True:
25459 
      (fname, ftype, fid) = iprot.readFieldBegin()
25460 
      if ftype == TType.STOP:
25461 
        break
25462 
      else:
25463 
        iprot.skip(ftype)
25464 
      iprot.readFieldEnd()
25465 
    iprot.readStructEnd()
25466 
 
25467 
  def write(self, oprot):
25468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25470 
      return
25471 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25472 
    oprot.writeFieldStop()
25473 
    oprot.writeStructEnd()
25474 
 
25475 
  def validate(self):
25476 
    return
25477 
 
25478 
 
25479 
  def __repr__(self):
25480 
    L = ['%s=%r' % (key, value)
25481 
      for key, value in self.__dict__.iteritems()]
25482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25483 
 
25484 
  def __eq__(self, other):
25485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25486 
 
25487 
  def __ne__(self, other):
25488 
    return not (self == other)
5553 rajveer 25489 
 
25490 
class getReceivePendingOrders_args:
25491 
  """
25492 
  Attributes:
25493 
   - storeId
25494 
  """
25495 
 
25496 
  thrift_spec = (
25497 
    None, # 0
25498 
    (1, TType.I64, 'storeId', None, None, ), # 1
25499 
  )
25500 
 
25501 
  def __init__(self, storeId=None,):
25502 
    self.storeId = storeId
25503 
 
25504 
  def read(self, iprot):
25505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25507 
      return
25508 
    iprot.readStructBegin()
25509 
    while True:
25510 
      (fname, ftype, fid) = iprot.readFieldBegin()
25511 
      if ftype == TType.STOP:
25512 
        break
25513 
      if fid == 1:
25514 
        if ftype == TType.I64:
25515 
          self.storeId = iprot.readI64();
25516 
        else:
25517 
          iprot.skip(ftype)
25518 
      else:
25519 
        iprot.skip(ftype)
25520 
      iprot.readFieldEnd()
25521 
    iprot.readStructEnd()
25522 
 
25523 
  def write(self, oprot):
25524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25526 
      return
25527 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25528 
    if self.storeId is not None:
25529 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25530 
      oprot.writeI64(self.storeId)
25531 
      oprot.writeFieldEnd()
25532 
    oprot.writeFieldStop()
25533 
    oprot.writeStructEnd()
25534 
 
25535 
  def validate(self):
25536 
    return
25537 
 
25538 
 
25539 
  def __repr__(self):
25540 
    L = ['%s=%r' % (key, value)
25541 
      for key, value in self.__dict__.iteritems()]
25542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25543 
 
25544 
  def __eq__(self, other):
25545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25546 
 
25547 
  def __ne__(self, other):
25548 
    return not (self == other)
25549 
 
25550 
class getReceivePendingOrders_result:
25551 
  """
25552 
  Attributes:
25553 
   - success
25554 
  """
25555 
 
25556 
  thrift_spec = (
25557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25558 
  )
25559 
 
25560 
  def __init__(self, success=None,):
25561 
    self.success = success
25562 
 
25563 
  def read(self, iprot):
25564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25566 
      return
25567 
    iprot.readStructBegin()
25568 
    while True:
25569 
      (fname, ftype, fid) = iprot.readFieldBegin()
25570 
      if ftype == TType.STOP:
25571 
        break
25572 
      if fid == 0:
25573 
        if ftype == TType.LIST:
25574 
          self.success = []
6188 rajveer 25575 
          (_etype638, _size635) = iprot.readListBegin()
25576 
          for _i639 in xrange(_size635):
25577 
            _elem640 = Order()
25578 
            _elem640.read(iprot)
25579 
            self.success.append(_elem640)
5553 rajveer 25580 
          iprot.readListEnd()
25581 
        else:
25582 
          iprot.skip(ftype)
25583 
      else:
25584 
        iprot.skip(ftype)
25585 
      iprot.readFieldEnd()
25586 
    iprot.readStructEnd()
25587 
 
25588 
  def write(self, oprot):
25589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25591 
      return
25592 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25593 
    if self.success is not None:
25594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25596 
      for iter641 in self.success:
25597 
        iter641.write(oprot)
5553 rajveer 25598 
      oprot.writeListEnd()
25599 
      oprot.writeFieldEnd()
25600 
    oprot.writeFieldStop()
25601 
    oprot.writeStructEnd()
25602 
 
25603 
  def validate(self):
25604 
    return
25605 
 
25606 
 
25607 
  def __repr__(self):
25608 
    L = ['%s=%r' % (key, value)
25609 
      for key, value in self.__dict__.iteritems()]
25610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25611 
 
25612 
  def __eq__(self, other):
25613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25614 
 
25615 
  def __ne__(self, other):
25616 
    return not (self == other)
25617 
 
25618 
class getReceivedAtStoreOrders_args:
25619 
  """
25620 
  Attributes:
25621 
   - storeId
25622 
  """
25623 
 
25624 
  thrift_spec = (
25625 
    None, # 0
25626 
    (1, TType.I64, 'storeId', None, None, ), # 1
25627 
  )
25628 
 
25629 
  def __init__(self, storeId=None,):
25630 
    self.storeId = storeId
25631 
 
25632 
  def read(self, iprot):
25633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25635 
      return
25636 
    iprot.readStructBegin()
25637 
    while True:
25638 
      (fname, ftype, fid) = iprot.readFieldBegin()
25639 
      if ftype == TType.STOP:
25640 
        break
25641 
      if fid == 1:
25642 
        if ftype == TType.I64:
25643 
          self.storeId = iprot.readI64();
25644 
        else:
25645 
          iprot.skip(ftype)
25646 
      else:
25647 
        iprot.skip(ftype)
25648 
      iprot.readFieldEnd()
25649 
    iprot.readStructEnd()
25650 
 
25651 
  def write(self, oprot):
25652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25654 
      return
25655 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25656 
    if self.storeId is not None:
25657 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25658 
      oprot.writeI64(self.storeId)
25659 
      oprot.writeFieldEnd()
25660 
    oprot.writeFieldStop()
25661 
    oprot.writeStructEnd()
25662 
 
25663 
  def validate(self):
25664 
    return
25665 
 
25666 
 
25667 
  def __repr__(self):
25668 
    L = ['%s=%r' % (key, value)
25669 
      for key, value in self.__dict__.iteritems()]
25670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25671 
 
25672 
  def __eq__(self, other):
25673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25674 
 
25675 
  def __ne__(self, other):
25676 
    return not (self == other)
25677 
 
25678 
class getReceivedAtStoreOrders_result:
25679 
  """
25680 
  Attributes:
25681 
   - success
25682 
  """
25683 
 
25684 
  thrift_spec = (
25685 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25686 
  )
25687 
 
25688 
  def __init__(self, success=None,):
25689 
    self.success = success
25690 
 
25691 
  def read(self, iprot):
25692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25694 
      return
25695 
    iprot.readStructBegin()
25696 
    while True:
25697 
      (fname, ftype, fid) = iprot.readFieldBegin()
25698 
      if ftype == TType.STOP:
25699 
        break
25700 
      if fid == 0:
25701 
        if ftype == TType.LIST:
25702 
          self.success = []
6188 rajveer 25703 
          (_etype645, _size642) = iprot.readListBegin()
25704 
          for _i646 in xrange(_size642):
25705 
            _elem647 = Order()
25706 
            _elem647.read(iprot)
25707 
            self.success.append(_elem647)
5553 rajveer 25708 
          iprot.readListEnd()
25709 
        else:
25710 
          iprot.skip(ftype)
25711 
      else:
25712 
        iprot.skip(ftype)
25713 
      iprot.readFieldEnd()
25714 
    iprot.readStructEnd()
25715 
 
25716 
  def write(self, oprot):
25717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25719 
      return
25720 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25721 
    if self.success is not None:
25722 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25723 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25724 
      for iter648 in self.success:
25725 
        iter648.write(oprot)
5553 rajveer 25726 
      oprot.writeListEnd()
25727 
      oprot.writeFieldEnd()
25728 
    oprot.writeFieldStop()
25729 
    oprot.writeStructEnd()
25730 
 
25731 
  def validate(self):
25732 
    return
25733 
 
25734 
 
25735 
  def __repr__(self):
25736 
    L = ['%s=%r' % (key, value)
25737 
      for key, value in self.__dict__.iteritems()]
25738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25739 
 
25740 
  def __eq__(self, other):
25741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25742 
 
25743 
  def __ne__(self, other):
25744 
    return not (self == other)
5593 mandeep.dh 25745 
 
5713 rajveer 25746 
class getOrdersCollectionAtStore_args:
25747 
  """
25748 
  Attributes:
25749 
   - storeId
25750 
   - fromDate
25751 
   - toDate
25752 
   - onlyCod
25753 
  """
25754 
 
25755 
  thrift_spec = (
25756 
    None, # 0
25757 
    (1, TType.I64, 'storeId', None, None, ), # 1
25758 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25759 
    (3, TType.I64, 'toDate', None, None, ), # 3
25760 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25761 
  )
25762 
 
25763 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25764 
    self.storeId = storeId
25765 
    self.fromDate = fromDate
25766 
    self.toDate = toDate
25767 
    self.onlyCod = onlyCod
25768 
 
25769 
  def read(self, iprot):
25770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25772 
      return
25773 
    iprot.readStructBegin()
25774 
    while True:
25775 
      (fname, ftype, fid) = iprot.readFieldBegin()
25776 
      if ftype == TType.STOP:
25777 
        break
25778 
      if fid == 1:
25779 
        if ftype == TType.I64:
25780 
          self.storeId = iprot.readI64();
25781 
        else:
25782 
          iprot.skip(ftype)
25783 
      elif fid == 2:
25784 
        if ftype == TType.I64:
25785 
          self.fromDate = iprot.readI64();
25786 
        else:
25787 
          iprot.skip(ftype)
25788 
      elif fid == 3:
25789 
        if ftype == TType.I64:
25790 
          self.toDate = iprot.readI64();
25791 
        else:
25792 
          iprot.skip(ftype)
25793 
      elif fid == 4:
25794 
        if ftype == TType.BOOL:
25795 
          self.onlyCod = iprot.readBool();
25796 
        else:
25797 
          iprot.skip(ftype)
25798 
      else:
25799 
        iprot.skip(ftype)
25800 
      iprot.readFieldEnd()
25801 
    iprot.readStructEnd()
25802 
 
25803 
  def write(self, oprot):
25804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25806 
      return
25807 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25808 
    if self.storeId is not None:
25809 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25810 
      oprot.writeI64(self.storeId)
25811 
      oprot.writeFieldEnd()
25812 
    if self.fromDate is not None:
25813 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25814 
      oprot.writeI64(self.fromDate)
25815 
      oprot.writeFieldEnd()
25816 
    if self.toDate is not None:
25817 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25818 
      oprot.writeI64(self.toDate)
25819 
      oprot.writeFieldEnd()
25820 
    if self.onlyCod is not None:
25821 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25822 
      oprot.writeBool(self.onlyCod)
25823 
      oprot.writeFieldEnd()
25824 
    oprot.writeFieldStop()
25825 
    oprot.writeStructEnd()
25826 
 
25827 
  def validate(self):
25828 
    return
25829 
 
25830 
 
25831 
  def __repr__(self):
25832 
    L = ['%s=%r' % (key, value)
25833 
      for key, value in self.__dict__.iteritems()]
25834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25835 
 
25836 
  def __eq__(self, other):
25837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25838 
 
25839 
  def __ne__(self, other):
25840 
    return not (self == other)
25841 
 
25842 
class getOrdersCollectionAtStore_result:
25843 
  """
25844 
  Attributes:
25845 
   - success
25846 
  """
25847 
 
25848 
  thrift_spec = (
25849 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25850 
  )
25851 
 
25852 
  def __init__(self, success=None,):
25853 
    self.success = success
25854 
 
25855 
  def read(self, iprot):
25856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25858 
      return
25859 
    iprot.readStructBegin()
25860 
    while True:
25861 
      (fname, ftype, fid) = iprot.readFieldBegin()
25862 
      if ftype == TType.STOP:
25863 
        break
25864 
      if fid == 0:
25865 
        if ftype == TType.LIST:
25866 
          self.success = []
6188 rajveer 25867 
          (_etype652, _size649) = iprot.readListBegin()
25868 
          for _i653 in xrange(_size649):
25869 
            _elem654 = Order()
25870 
            _elem654.read(iprot)
25871 
            self.success.append(_elem654)
5713 rajveer 25872 
          iprot.readListEnd()
25873 
        else:
25874 
          iprot.skip(ftype)
25875 
      else:
25876 
        iprot.skip(ftype)
25877 
      iprot.readFieldEnd()
25878 
    iprot.readStructEnd()
25879 
 
25880 
  def write(self, oprot):
25881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25883 
      return
25884 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25885 
    if self.success is not None:
25886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25887 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25888 
      for iter655 in self.success:
25889 
        iter655.write(oprot)
5713 rajveer 25890 
      oprot.writeListEnd()
25891 
      oprot.writeFieldEnd()
25892 
    oprot.writeFieldStop()
25893 
    oprot.writeStructEnd()
25894 
 
25895 
  def validate(self):
25896 
    return
25897 
 
25898 
 
25899 
  def __repr__(self):
25900 
    L = ['%s=%r' % (key, value)
25901 
      for key, value in self.__dict__.iteritems()]
25902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25903 
 
25904 
  def __eq__(self, other):
25905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25906 
 
25907 
  def __ne__(self, other):
25908 
    return not (self == other)
25909 
 
5833 rajveer 25910 
class getOrderAttributeValue_args:
25911 
  """
25912 
  Attributes:
25913 
   - orderId
25914 
   - attributeName
25915 
  """
25916 
 
25917 
  thrift_spec = None
25918 
  def __init__(self, orderId=None, attributeName=None,):
25919 
    self.orderId = orderId
25920 
    self.attributeName = attributeName
25921 
 
25922 
  def read(self, iprot):
25923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25925 
      return
25926 
    iprot.readStructBegin()
25927 
    while True:
25928 
      (fname, ftype, fid) = iprot.readFieldBegin()
25929 
      if ftype == TType.STOP:
25930 
        break
25931 
      if fid == 1:
25932 
        if ftype == TType.I64:
25933 
          self.orderId = iprot.readI64();
25934 
        else:
25935 
          iprot.skip(ftype)
25936 
      elif fid == -1:
25937 
        if ftype == TType.STRING:
25938 
          self.attributeName = iprot.readString();
25939 
        else:
25940 
          iprot.skip(ftype)
25941 
      else:
25942 
        iprot.skip(ftype)
25943 
      iprot.readFieldEnd()
25944 
    iprot.readStructEnd()
25945 
 
25946 
  def write(self, oprot):
25947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25949 
      return
25950 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25951 
    if self.attributeName is not None:
25952 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25953 
      oprot.writeString(self.attributeName)
25954 
      oprot.writeFieldEnd()
25955 
    if self.orderId is not None:
25956 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25957 
      oprot.writeI64(self.orderId)
25958 
      oprot.writeFieldEnd()
25959 
    oprot.writeFieldStop()
25960 
    oprot.writeStructEnd()
25961 
 
25962 
  def validate(self):
25963 
    return
25964 
 
25965 
 
25966 
  def __repr__(self):
25967 
    L = ['%s=%r' % (key, value)
25968 
      for key, value in self.__dict__.iteritems()]
25969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25970 
 
25971 
  def __eq__(self, other):
25972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25973 
 
25974 
  def __ne__(self, other):
25975 
    return not (self == other)
25976 
 
25977 
class getOrderAttributeValue_result:
25978 
  """
25979 
  Attributes:
25980 
   - success
25981 
  """
25982 
 
25983 
  thrift_spec = (
25984 
    (0, TType.STRING, 'success', None, None, ), # 0
25985 
  )
25986 
 
25987 
  def __init__(self, success=None,):
25988 
    self.success = success
25989 
 
25990 
  def read(self, iprot):
25991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25993 
      return
25994 
    iprot.readStructBegin()
25995 
    while True:
25996 
      (fname, ftype, fid) = iprot.readFieldBegin()
25997 
      if ftype == TType.STOP:
25998 
        break
25999 
      if fid == 0:
26000 
        if ftype == TType.STRING:
26001 
          self.success = iprot.readString();
26002 
        else:
26003 
          iprot.skip(ftype)
26004 
      else:
26005 
        iprot.skip(ftype)
26006 
      iprot.readFieldEnd()
26007 
    iprot.readStructEnd()
26008 
 
26009 
  def write(self, oprot):
26010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26012 
      return
26013 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26014 
    if self.success is not None:
26015 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26016 
      oprot.writeString(self.success)
26017 
      oprot.writeFieldEnd()
26018 
    oprot.writeFieldStop()
26019 
    oprot.writeStructEnd()
26020 
 
26021 
  def validate(self):
26022 
    return
26023 
 
26024 
 
26025 
  def __repr__(self):
26026 
    L = ['%s=%r' % (key, value)
26027 
      for key, value in self.__dict__.iteritems()]
26028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26029 
 
26030 
  def __eq__(self, other):
26031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26032 
 
26033 
  def __ne__(self, other):
26034 
    return not (self == other)
26035 
 
6019 rajveer 26036 
class changeJacketNumber_args:
26037 
  """
26038 
  Attributes:
26039 
   - orderId
26040 
   - jacketNumber
26041 
  """
26042 
 
26043 
  thrift_spec = (
26044 
    None, # 0
26045 
    (1, TType.I64, 'orderId', None, None, ), # 1
26046 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26047 
  )
26048 
 
26049 
  def __init__(self, orderId=None, jacketNumber=None,):
26050 
    self.orderId = orderId
26051 
    self.jacketNumber = jacketNumber
26052 
 
26053 
  def read(self, iprot):
26054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26056 
      return
26057 
    iprot.readStructBegin()
26058 
    while True:
26059 
      (fname, ftype, fid) = iprot.readFieldBegin()
26060 
      if ftype == TType.STOP:
26061 
        break
26062 
      if fid == 1:
26063 
        if ftype == TType.I64:
26064 
          self.orderId = iprot.readI64();
26065 
        else:
26066 
          iprot.skip(ftype)
26067 
      elif fid == 2:
26068 
        if ftype == TType.I64:
26069 
          self.jacketNumber = iprot.readI64();
26070 
        else:
26071 
          iprot.skip(ftype)
26072 
      else:
26073 
        iprot.skip(ftype)
26074 
      iprot.readFieldEnd()
26075 
    iprot.readStructEnd()
26076 
 
26077 
  def write(self, oprot):
26078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26080 
      return
26081 
    oprot.writeStructBegin('changeJacketNumber_args')
26082 
    if self.orderId is not None:
26083 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26084 
      oprot.writeI64(self.orderId)
26085 
      oprot.writeFieldEnd()
26086 
    if self.jacketNumber is not None:
26087 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26088 
      oprot.writeI64(self.jacketNumber)
26089 
      oprot.writeFieldEnd()
26090 
    oprot.writeFieldStop()
26091 
    oprot.writeStructEnd()
26092 
 
26093 
  def validate(self):
26094 
    return
26095 
 
26096 
 
26097 
  def __repr__(self):
26098 
    L = ['%s=%r' % (key, value)
26099 
      for key, value in self.__dict__.iteritems()]
26100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26101 
 
26102 
  def __eq__(self, other):
26103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26104 
 
26105 
  def __ne__(self, other):
26106 
    return not (self == other)
26107 
 
26108 
class changeJacketNumber_result:
26109 
  """
26110 
  Attributes:
26111 
   - success
26112 
  """
26113 
 
26114 
  thrift_spec = (
26115 
    (0, TType.BOOL, 'success', None, None, ), # 0
26116 
  )
26117 
 
26118 
  def __init__(self, success=None,):
26119 
    self.success = success
26120 
 
26121 
  def read(self, iprot):
26122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26124 
      return
26125 
    iprot.readStructBegin()
26126 
    while True:
26127 
      (fname, ftype, fid) = iprot.readFieldBegin()
26128 
      if ftype == TType.STOP:
26129 
        break
26130 
      if fid == 0:
26131 
        if ftype == TType.BOOL:
26132 
          self.success = iprot.readBool();
26133 
        else:
26134 
          iprot.skip(ftype)
26135 
      else:
26136 
        iprot.skip(ftype)
26137 
      iprot.readFieldEnd()
26138 
    iprot.readStructEnd()
26139 
 
26140 
  def write(self, oprot):
26141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26143 
      return
26144 
    oprot.writeStructBegin('changeJacketNumber_result')
26145 
    if self.success is not None:
26146 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26147 
      oprot.writeBool(self.success)
26148 
      oprot.writeFieldEnd()
26149 
    oprot.writeFieldStop()
26150 
    oprot.writeStructEnd()
26151 
 
26152 
  def validate(self):
26153 
    return
26154 
 
26155 
 
26156 
  def __repr__(self):
26157 
    L = ['%s=%r' % (key, value)
26158 
      for key, value in self.__dict__.iteritems()]
26159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26160 
 
26161 
  def __eq__(self, other):
26162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26163 
 
26164 
  def __ne__(self, other):
26165 
    return not (self == other)
26166 
 
26167 
class markOrderAsRtoInTransit_args:
26168 
  """
26169 
  Attributes:
26170 
   - orderId
26171 
  """
26172 
 
26173 
  thrift_spec = (
26174 
    None, # 0
26175 
    (1, TType.I64, 'orderId', None, None, ), # 1
26176 
  )
26177 
 
26178 
  def __init__(self, orderId=None,):
26179 
    self.orderId = orderId
26180 
 
26181 
  def read(self, iprot):
26182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26184 
      return
26185 
    iprot.readStructBegin()
26186 
    while True:
26187 
      (fname, ftype, fid) = iprot.readFieldBegin()
26188 
      if ftype == TType.STOP:
26189 
        break
26190 
      if fid == 1:
26191 
        if ftype == TType.I64:
26192 
          self.orderId = iprot.readI64();
26193 
        else:
26194 
          iprot.skip(ftype)
26195 
      else:
26196 
        iprot.skip(ftype)
26197 
      iprot.readFieldEnd()
26198 
    iprot.readStructEnd()
26199 
 
26200 
  def write(self, oprot):
26201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26203 
      return
26204 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26205 
    if self.orderId is not None:
26206 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26207 
      oprot.writeI64(self.orderId)
26208 
      oprot.writeFieldEnd()
26209 
    oprot.writeFieldStop()
26210 
    oprot.writeStructEnd()
26211 
 
26212 
  def validate(self):
26213 
    return
26214 
 
26215 
 
26216 
  def __repr__(self):
26217 
    L = ['%s=%r' % (key, value)
26218 
      for key, value in self.__dict__.iteritems()]
26219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26220 
 
26221 
  def __eq__(self, other):
26222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26223 
 
26224 
  def __ne__(self, other):
26225 
    return not (self == other)
26226 
 
26227 
class markOrderAsRtoInTransit_result:
26228 
  """
26229 
  Attributes:
26230 
   - success
26231 
  """
26232 
 
26233 
  thrift_spec = (
26234 
    (0, TType.BOOL, 'success', None, None, ), # 0
26235 
  )
26236 
 
26237 
  def __init__(self, success=None,):
26238 
    self.success = success
26239 
 
26240 
  def read(self, iprot):
26241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26243 
      return
26244 
    iprot.readStructBegin()
26245 
    while True:
26246 
      (fname, ftype, fid) = iprot.readFieldBegin()
26247 
      if ftype == TType.STOP:
26248 
        break
26249 
      if fid == 0:
26250 
        if ftype == TType.BOOL:
26251 
          self.success = iprot.readBool();
26252 
        else:
26253 
          iprot.skip(ftype)
26254 
      else:
26255 
        iprot.skip(ftype)
26256 
      iprot.readFieldEnd()
26257 
    iprot.readStructEnd()
26258 
 
26259 
  def write(self, oprot):
26260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26262 
      return
26263 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26264 
    if self.success is not None:
26265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26266 
      oprot.writeBool(self.success)
26267 
      oprot.writeFieldEnd()
26268 
    oprot.writeFieldStop()
26269 
    oprot.writeStructEnd()
26270 
 
26271 
  def validate(self):
26272 
    return
26273 
 
26274 
 
26275 
  def __repr__(self):
26276 
    L = ['%s=%r' % (key, value)
26277 
      for key, value in self.__dict__.iteritems()]
26278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26279 
 
26280 
  def __eq__(self, other):
26281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26282 
 
26283 
  def __ne__(self, other):
26284 
    return not (self == other)
26285 
 
5593 mandeep.dh 26286 
class acceptOrderForItem_args:
26287 
  """
26288 
  Attributes:
26289 
   - itemId
26290 
   - quantity
26291 
   - fulfilmentWarehouseId
26292 
   - billingWarehouseId
26293 
  """
26294 
 
26295 
  thrift_spec = (
26296 
    None, # 0
26297 
    (1, TType.I64, 'itemId', None, None, ), # 1
26298 
    (2, TType.I64, 'quantity', None, None, ), # 2
26299 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26300 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26301 
  )
26302 
 
26303 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26304 
    self.itemId = itemId
26305 
    self.quantity = quantity
26306 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26307 
    self.billingWarehouseId = billingWarehouseId
26308 
 
26309 
  def read(self, iprot):
26310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26312 
      return
26313 
    iprot.readStructBegin()
26314 
    while True:
26315 
      (fname, ftype, fid) = iprot.readFieldBegin()
26316 
      if ftype == TType.STOP:
26317 
        break
26318 
      if fid == 1:
26319 
        if ftype == TType.I64:
26320 
          self.itemId = iprot.readI64();
26321 
        else:
26322 
          iprot.skip(ftype)
26323 
      elif fid == 2:
26324 
        if ftype == TType.I64:
26325 
          self.quantity = iprot.readI64();
26326 
        else:
26327 
          iprot.skip(ftype)
26328 
      elif fid == 3:
26329 
        if ftype == TType.I64:
26330 
          self.fulfilmentWarehouseId = iprot.readI64();
26331 
        else:
26332 
          iprot.skip(ftype)
26333 
      elif fid == 4:
26334 
        if ftype == TType.I64:
26335 
          self.billingWarehouseId = iprot.readI64();
26336 
        else:
26337 
          iprot.skip(ftype)
26338 
      else:
26339 
        iprot.skip(ftype)
26340 
      iprot.readFieldEnd()
26341 
    iprot.readStructEnd()
26342 
 
26343 
  def write(self, oprot):
26344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26346 
      return
26347 
    oprot.writeStructBegin('acceptOrderForItem_args')
26348 
    if self.itemId is not None:
26349 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26350 
      oprot.writeI64(self.itemId)
26351 
      oprot.writeFieldEnd()
26352 
    if self.quantity is not None:
26353 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26354 
      oprot.writeI64(self.quantity)
26355 
      oprot.writeFieldEnd()
26356 
    if self.fulfilmentWarehouseId is not None:
26357 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26358 
      oprot.writeI64(self.fulfilmentWarehouseId)
26359 
      oprot.writeFieldEnd()
26360 
    if self.billingWarehouseId is not None:
26361 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26362 
      oprot.writeI64(self.billingWarehouseId)
26363 
      oprot.writeFieldEnd()
26364 
    oprot.writeFieldStop()
26365 
    oprot.writeStructEnd()
26366 
 
26367 
  def validate(self):
26368 
    return
26369 
 
26370 
 
26371 
  def __repr__(self):
26372 
    L = ['%s=%r' % (key, value)
26373 
      for key, value in self.__dict__.iteritems()]
26374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26375 
 
26376 
  def __eq__(self, other):
26377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26378 
 
26379 
  def __ne__(self, other):
26380 
    return not (self == other)
26381 
 
26382 
class acceptOrderForItem_result:
26383 
 
26384 
  thrift_spec = (
26385 
  )
26386 
 
26387 
  def read(self, iprot):
26388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26390 
      return
26391 
    iprot.readStructBegin()
26392 
    while True:
26393 
      (fname, ftype, fid) = iprot.readFieldBegin()
26394 
      if ftype == TType.STOP:
26395 
        break
26396 
      else:
26397 
        iprot.skip(ftype)
26398 
      iprot.readFieldEnd()
26399 
    iprot.readStructEnd()
26400 
 
26401 
  def write(self, oprot):
26402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26404 
      return
26405 
    oprot.writeStructBegin('acceptOrderForItem_result')
26406 
    oprot.writeFieldStop()
26407 
    oprot.writeStructEnd()
26408 
 
26409 
  def validate(self):
26410 
    return
26411 
 
26412 
 
26413 
  def __repr__(self):
26414 
    L = ['%s=%r' % (key, value)
26415 
      for key, value in self.__dict__.iteritems()]
26416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26417 
 
26418 
  def __eq__(self, other):
26419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26420 
 
26421 
  def __ne__(self, other):
26422 
    return not (self == other)
6000 mandeep.dh 26423 
 
26424 
class createRechargeOrder_args:
26425 
  """
26426 
  Attributes:
26427 
   - rechargeOrder
26428 
  """
26429 
 
26430 
  thrift_spec = (
26431 
    None, # 0
26432 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26433 
  )
26434 
 
26435 
  def __init__(self, rechargeOrder=None,):
26436 
    self.rechargeOrder = rechargeOrder
26437 
 
26438 
  def read(self, iprot):
26439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26441 
      return
26442 
    iprot.readStructBegin()
26443 
    while True:
26444 
      (fname, ftype, fid) = iprot.readFieldBegin()
26445 
      if ftype == TType.STOP:
26446 
        break
26447 
      if fid == 1:
26448 
        if ftype == TType.STRUCT:
26449 
          self.rechargeOrder = RechargeOrder()
26450 
          self.rechargeOrder.read(iprot)
26451 
        else:
26452 
          iprot.skip(ftype)
26453 
      else:
26454 
        iprot.skip(ftype)
26455 
      iprot.readFieldEnd()
26456 
    iprot.readStructEnd()
26457 
 
26458 
  def write(self, oprot):
26459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26461 
      return
26462 
    oprot.writeStructBegin('createRechargeOrder_args')
26463 
    if self.rechargeOrder is not None:
26464 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26465 
      self.rechargeOrder.write(oprot)
26466 
      oprot.writeFieldEnd()
26467 
    oprot.writeFieldStop()
26468 
    oprot.writeStructEnd()
26469 
 
26470 
  def validate(self):
26471 
    return
26472 
 
26473 
 
26474 
  def __repr__(self):
26475 
    L = ['%s=%r' % (key, value)
26476 
      for key, value in self.__dict__.iteritems()]
26477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26478 
 
26479 
  def __eq__(self, other):
26480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26481 
 
26482 
  def __ne__(self, other):
26483 
    return not (self == other)
26484 
 
26485 
class createRechargeOrder_result:
26486 
  """
26487 
  Attributes:
26488 
   - success
26489 
   - ex
26490 
  """
26491 
 
26492 
  thrift_spec = (
26493 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26495 
  )
26496 
 
26497 
  def __init__(self, success=None, ex=None,):
26498 
    self.success = success
26499 
    self.ex = ex
26500 
 
26501 
  def read(self, iprot):
26502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26504 
      return
26505 
    iprot.readStructBegin()
26506 
    while True:
26507 
      (fname, ftype, fid) = iprot.readFieldBegin()
26508 
      if ftype == TType.STOP:
26509 
        break
26510 
      if fid == 0:
26511 
        if ftype == TType.STRUCT:
26512 
          self.success = RechargeOrder()
26513 
          self.success.read(iprot)
26514 
        else:
26515 
          iprot.skip(ftype)
26516 
      elif fid == 1:
26517 
        if ftype == TType.STRUCT:
26518 
          self.ex = TransactionServiceException()
26519 
          self.ex.read(iprot)
26520 
        else:
26521 
          iprot.skip(ftype)
26522 
      else:
26523 
        iprot.skip(ftype)
26524 
      iprot.readFieldEnd()
26525 
    iprot.readStructEnd()
26526 
 
26527 
  def write(self, oprot):
26528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26530 
      return
26531 
    oprot.writeStructBegin('createRechargeOrder_result')
26532 
    if self.success is not None:
26533 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26534 
      self.success.write(oprot)
26535 
      oprot.writeFieldEnd()
26536 
    if self.ex is not None:
26537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26538 
      self.ex.write(oprot)
26539 
      oprot.writeFieldEnd()
26540 
    oprot.writeFieldStop()
26541 
    oprot.writeStructEnd()
26542 
 
26543 
  def validate(self):
26544 
    return
26545 
 
26546 
 
26547 
  def __repr__(self):
26548 
    L = ['%s=%r' % (key, value)
26549 
      for key, value in self.__dict__.iteritems()]
26550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26551 
 
26552 
  def __eq__(self, other):
26553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26554 
 
26555 
  def __ne__(self, other):
26556 
    return not (self == other)
26557 
 
6031 rajveer 26558 
class getRechargeOrder_args:
26559 
  """
26560 
  Attributes:
26561 
   - rechargeRrderId
26562 
  """
26563 
 
26564 
  thrift_spec = (
26565 
    None, # 0
26566 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26567 
  )
26568 
 
26569 
  def __init__(self, rechargeRrderId=None,):
26570 
    self.rechargeRrderId = rechargeRrderId
26571 
 
26572 
  def read(self, iprot):
26573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26575 
      return
26576 
    iprot.readStructBegin()
26577 
    while True:
26578 
      (fname, ftype, fid) = iprot.readFieldBegin()
26579 
      if ftype == TType.STOP:
26580 
        break
26581 
      if fid == 1:
26582 
        if ftype == TType.I64:
26583 
          self.rechargeRrderId = iprot.readI64();
26584 
        else:
26585 
          iprot.skip(ftype)
26586 
      else:
26587 
        iprot.skip(ftype)
26588 
      iprot.readFieldEnd()
26589 
    iprot.readStructEnd()
26590 
 
26591 
  def write(self, oprot):
26592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26594 
      return
26595 
    oprot.writeStructBegin('getRechargeOrder_args')
26596 
    if self.rechargeRrderId is not None:
26597 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26598 
      oprot.writeI64(self.rechargeRrderId)
26599 
      oprot.writeFieldEnd()
26600 
    oprot.writeFieldStop()
26601 
    oprot.writeStructEnd()
26602 
 
26603 
  def validate(self):
26604 
    return
26605 
 
26606 
 
26607 
  def __repr__(self):
26608 
    L = ['%s=%r' % (key, value)
26609 
      for key, value in self.__dict__.iteritems()]
26610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26611 
 
26612 
  def __eq__(self, other):
26613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26614 
 
26615 
  def __ne__(self, other):
26616 
    return not (self == other)
26617 
 
26618 
class getRechargeOrder_result:
26619 
  """
26620 
  Attributes:
26621 
   - success
26622 
   - ex
26623 
  """
26624 
 
26625 
  thrift_spec = (
26626 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26628 
  )
26629 
 
26630 
  def __init__(self, success=None, ex=None,):
26631 
    self.success = success
26632 
    self.ex = ex
26633 
 
26634 
  def read(self, iprot):
26635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26637 
      return
26638 
    iprot.readStructBegin()
26639 
    while True:
26640 
      (fname, ftype, fid) = iprot.readFieldBegin()
26641 
      if ftype == TType.STOP:
26642 
        break
26643 
      if fid == 0:
26644 
        if ftype == TType.STRUCT:
26645 
          self.success = RechargeOrder()
26646 
          self.success.read(iprot)
26647 
        else:
26648 
          iprot.skip(ftype)
26649 
      elif fid == 1:
26650 
        if ftype == TType.STRUCT:
26651 
          self.ex = TransactionServiceException()
26652 
          self.ex.read(iprot)
26653 
        else:
26654 
          iprot.skip(ftype)
26655 
      else:
26656 
        iprot.skip(ftype)
26657 
      iprot.readFieldEnd()
26658 
    iprot.readStructEnd()
26659 
 
26660 
  def write(self, oprot):
26661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26663 
      return
26664 
    oprot.writeStructBegin('getRechargeOrder_result')
26665 
    if self.success is not None:
26666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26667 
      self.success.write(oprot)
26668 
      oprot.writeFieldEnd()
26669 
    if self.ex is not None:
26670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26671 
      self.ex.write(oprot)
26672 
      oprot.writeFieldEnd()
26673 
    oprot.writeFieldStop()
26674 
    oprot.writeStructEnd()
26675 
 
26676 
  def validate(self):
26677 
    return
26678 
 
26679 
 
26680 
  def __repr__(self):
26681 
    L = ['%s=%r' % (key, value)
26682 
      for key, value in self.__dict__.iteritems()]
26683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26684 
 
26685 
  def __eq__(self, other):
26686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26687 
 
26688 
  def __ne__(self, other):
26689 
    return not (self == other)
26690 
 
26691 
class getRechargeOrders_args:
26692 
  """
26693 
  Attributes:
26694 
   - userId
26695 
  """
26696 
 
26697 
  thrift_spec = (
26698 
    None, # 0
26699 
    (1, TType.I64, 'userId', None, None, ), # 1
26700 
  )
26701 
 
26702 
  def __init__(self, userId=None,):
26703 
    self.userId = userId
26704 
 
26705 
  def read(self, iprot):
26706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26708 
      return
26709 
    iprot.readStructBegin()
26710 
    while True:
26711 
      (fname, ftype, fid) = iprot.readFieldBegin()
26712 
      if ftype == TType.STOP:
26713 
        break
26714 
      if fid == 1:
26715 
        if ftype == TType.I64:
26716 
          self.userId = iprot.readI64();
26717 
        else:
26718 
          iprot.skip(ftype)
26719 
      else:
26720 
        iprot.skip(ftype)
26721 
      iprot.readFieldEnd()
26722 
    iprot.readStructEnd()
26723 
 
26724 
  def write(self, oprot):
26725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26727 
      return
26728 
    oprot.writeStructBegin('getRechargeOrders_args')
26729 
    if self.userId is not None:
26730 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26731 
      oprot.writeI64(self.userId)
26732 
      oprot.writeFieldEnd()
26733 
    oprot.writeFieldStop()
26734 
    oprot.writeStructEnd()
26735 
 
26736 
  def validate(self):
26737 
    return
26738 
 
26739 
 
26740 
  def __repr__(self):
26741 
    L = ['%s=%r' % (key, value)
26742 
      for key, value in self.__dict__.iteritems()]
26743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26744 
 
26745 
  def __eq__(self, other):
26746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26747 
 
26748 
  def __ne__(self, other):
26749 
    return not (self == other)
26750 
 
26751 
class getRechargeOrders_result:
26752 
  """
26753 
  Attributes:
26754 
   - success
26755 
  """
26756 
 
26757 
  thrift_spec = (
26758 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26759 
  )
26760 
 
26761 
  def __init__(self, success=None,):
26762 
    self.success = success
26763 
 
26764 
  def read(self, iprot):
26765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26767 
      return
26768 
    iprot.readStructBegin()
26769 
    while True:
26770 
      (fname, ftype, fid) = iprot.readFieldBegin()
26771 
      if ftype == TType.STOP:
26772 
        break
26773 
      if fid == 0:
26774 
        if ftype == TType.LIST:
26775 
          self.success = []
6188 rajveer 26776 
          (_etype659, _size656) = iprot.readListBegin()
26777 
          for _i660 in xrange(_size656):
26778 
            _elem661 = RechargeOrder()
26779 
            _elem661.read(iprot)
26780 
            self.success.append(_elem661)
6031 rajveer 26781 
          iprot.readListEnd()
26782 
        else:
26783 
          iprot.skip(ftype)
26784 
      else:
26785 
        iprot.skip(ftype)
26786 
      iprot.readFieldEnd()
26787 
    iprot.readStructEnd()
26788 
 
26789 
  def write(self, oprot):
26790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26792 
      return
26793 
    oprot.writeStructBegin('getRechargeOrders_result')
26794 
    if self.success is not None:
26795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26797 
      for iter662 in self.success:
26798 
        iter662.write(oprot)
6031 rajveer 26799 
      oprot.writeListEnd()
26800 
      oprot.writeFieldEnd()
26801 
    oprot.writeFieldStop()
26802 
    oprot.writeStructEnd()
26803 
 
26804 
  def validate(self):
26805 
    return
26806 
 
26807 
 
26808 
  def __repr__(self):
26809 
    L = ['%s=%r' % (key, value)
26810 
      for key, value in self.__dict__.iteritems()]
26811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26812 
 
26813 
  def __eq__(self, other):
26814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26815 
 
26816 
  def __ne__(self, other):
26817 
    return not (self == other)
26818 
 
6000 mandeep.dh 26819 
class updateRechargeOrderStatus_args:
26820 
  """
26821 
  Attributes:
26822 
   - rechargeOrderId
26823 
   - rechargeOrderStatus
26824 
  """
26825 
 
26826 
  thrift_spec = (
26827 
    None, # 0
26828 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26829 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26830 
  )
26831 
 
26832 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26833 
    self.rechargeOrderId = rechargeOrderId
26834 
    self.rechargeOrderStatus = rechargeOrderStatus
26835 
 
26836 
  def read(self, iprot):
26837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26839 
      return
26840 
    iprot.readStructBegin()
26841 
    while True:
26842 
      (fname, ftype, fid) = iprot.readFieldBegin()
26843 
      if ftype == TType.STOP:
26844 
        break
26845 
      if fid == 1:
26846 
        if ftype == TType.I64:
26847 
          self.rechargeOrderId = iprot.readI64();
26848 
        else:
26849 
          iprot.skip(ftype)
26850 
      elif fid == 2:
26851 
        if ftype == TType.I32:
26852 
          self.rechargeOrderStatus = iprot.readI32();
26853 
        else:
26854 
          iprot.skip(ftype)
26855 
      else:
26856 
        iprot.skip(ftype)
26857 
      iprot.readFieldEnd()
26858 
    iprot.readStructEnd()
26859 
 
26860 
  def write(self, oprot):
26861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26863 
      return
26864 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26865 
    if self.rechargeOrderId is not None:
26866 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26867 
      oprot.writeI64(self.rechargeOrderId)
26868 
      oprot.writeFieldEnd()
26869 
    if self.rechargeOrderStatus is not None:
26870 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26871 
      oprot.writeI32(self.rechargeOrderStatus)
26872 
      oprot.writeFieldEnd()
26873 
    oprot.writeFieldStop()
26874 
    oprot.writeStructEnd()
26875 
 
26876 
  def validate(self):
26877 
    return
26878 
 
26879 
 
26880 
  def __repr__(self):
26881 
    L = ['%s=%r' % (key, value)
26882 
      for key, value in self.__dict__.iteritems()]
26883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26884 
 
26885 
  def __eq__(self, other):
26886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26887 
 
26888 
  def __ne__(self, other):
26889 
    return not (self == other)
26890 
 
26891 
class updateRechargeOrderStatus_result:
26892 
  """
26893 
  Attributes:
6031 rajveer 26894 
   - success
6000 mandeep.dh 26895 
   - ex
26896 
  """
26897 
 
26898 
  thrift_spec = (
6031 rajveer 26899 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26901 
  )
26902 
 
6031 rajveer 26903 
  def __init__(self, success=None, ex=None,):
26904 
    self.success = success
6000 mandeep.dh 26905 
    self.ex = ex
26906 
 
26907 
  def read(self, iprot):
26908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26910 
      return
26911 
    iprot.readStructBegin()
26912 
    while True:
26913 
      (fname, ftype, fid) = iprot.readFieldBegin()
26914 
      if ftype == TType.STOP:
26915 
        break
6031 rajveer 26916 
      if fid == 0:
26917 
        if ftype == TType.BOOL:
26918 
          self.success = iprot.readBool();
26919 
        else:
26920 
          iprot.skip(ftype)
26921 
      elif fid == 1:
6000 mandeep.dh 26922 
        if ftype == TType.STRUCT:
26923 
          self.ex = TransactionServiceException()
26924 
          self.ex.read(iprot)
26925 
        else:
26926 
          iprot.skip(ftype)
26927 
      else:
26928 
        iprot.skip(ftype)
26929 
      iprot.readFieldEnd()
26930 
    iprot.readStructEnd()
26931 
 
26932 
  def write(self, oprot):
26933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26935 
      return
26936 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26937 
    if self.success is not None:
26938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26939 
      oprot.writeBool(self.success)
26940 
      oprot.writeFieldEnd()
6000 mandeep.dh 26941 
    if self.ex is not None:
26942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26943 
      self.ex.write(oprot)
26944 
      oprot.writeFieldEnd()
26945 
    oprot.writeFieldStop()
26946 
    oprot.writeStructEnd()
26947 
 
26948 
  def validate(self):
26949 
    return
26950 
 
26951 
 
26952 
  def __repr__(self):
26953 
    L = ['%s=%r' % (key, value)
26954 
      for key, value in self.__dict__.iteritems()]
26955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26956 
 
26957 
  def __eq__(self, other):
26958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26959 
 
26960 
  def __ne__(self, other):
26961 
    return not (self == other)
26962 
 
26963 
class activateRechargeTxn_args:
26964 
  """
26965 
  Attributes:
6031 rajveer 26966 
   - rechargeOrderId
6000 mandeep.dh 26967 
  """
26968 
 
26969 
  thrift_spec = (
26970 
    None, # 0
6031 rajveer 26971 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26972 
  )
26973 
 
6031 rajveer 26974 
  def __init__(self, rechargeOrderId=None,):
26975 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26976 
 
26977 
  def read(self, iprot):
26978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26980 
      return
26981 
    iprot.readStructBegin()
26982 
    while True:
26983 
      (fname, ftype, fid) = iprot.readFieldBegin()
26984 
      if ftype == TType.STOP:
26985 
        break
26986 
      if fid == 1:
6031 rajveer 26987 
        if ftype == TType.I64:
26988 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26989 
        else:
26990 
          iprot.skip(ftype)
26991 
      else:
26992 
        iprot.skip(ftype)
26993 
      iprot.readFieldEnd()
26994 
    iprot.readStructEnd()
26995 
 
26996 
  def write(self, oprot):
26997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26999 
      return
27000 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27001 
    if self.rechargeOrderId is not None:
27002 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27003 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27004 
      oprot.writeFieldEnd()
27005 
    oprot.writeFieldStop()
27006 
    oprot.writeStructEnd()
27007 
 
27008 
  def validate(self):
27009 
    return
27010 
 
27011 
 
27012 
  def __repr__(self):
27013 
    L = ['%s=%r' % (key, value)
27014 
      for key, value in self.__dict__.iteritems()]
27015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27016 
 
27017 
  def __eq__(self, other):
27018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27019 
 
27020 
  def __ne__(self, other):
27021 
    return not (self == other)
27022 
 
27023 
class activateRechargeTxn_result:
27024 
  """
27025 
  Attributes:
27026 
   - success
27027 
   - ex
27028 
  """
27029 
 
27030 
  thrift_spec = (
6031 rajveer 27031 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27033 
  )
27034 
 
27035 
  def __init__(self, success=None, ex=None,):
27036 
    self.success = success
27037 
    self.ex = ex
27038 
 
27039 
  def read(self, iprot):
27040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27042 
      return
27043 
    iprot.readStructBegin()
27044 
    while True:
27045 
      (fname, ftype, fid) = iprot.readFieldBegin()
27046 
      if ftype == TType.STOP:
27047 
        break
27048 
      if fid == 0:
6031 rajveer 27049 
        if ftype == TType.BOOL:
27050 
          self.success = iprot.readBool();
6000 mandeep.dh 27051 
        else:
27052 
          iprot.skip(ftype)
27053 
      elif fid == 1:
27054 
        if ftype == TType.STRUCT:
27055 
          self.ex = TransactionServiceException()
27056 
          self.ex.read(iprot)
27057 
        else:
27058 
          iprot.skip(ftype)
27059 
      else:
27060 
        iprot.skip(ftype)
27061 
      iprot.readFieldEnd()
27062 
    iprot.readStructEnd()
27063 
 
27064 
  def write(self, oprot):
27065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27067 
      return
27068 
    oprot.writeStructBegin('activateRechargeTxn_result')
27069 
    if self.success is not None:
6031 rajveer 27070 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27071 
      oprot.writeBool(self.success)
6000 mandeep.dh 27072 
      oprot.writeFieldEnd()
27073 
    if self.ex is not None:
27074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27075 
      self.ex.write(oprot)
27076 
      oprot.writeFieldEnd()
27077 
    oprot.writeFieldStop()
27078 
    oprot.writeStructEnd()
27079 
 
27080 
  def validate(self):
27081 
    return
27082 
 
27083 
 
27084 
  def __repr__(self):
27085 
    L = ['%s=%r' % (key, value)
27086 
      for key, value in self.__dict__.iteritems()]
27087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27088 
 
27089 
  def __eq__(self, other):
27090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27091 
 
27092 
  def __ne__(self, other):
27093 
    return not (self == other)
27094 
 
6031 rajveer 27095 
class getUserWallet_args:
6000 mandeep.dh 27096 
  """
27097 
  Attributes:
6031 rajveer 27098 
   - userId
6000 mandeep.dh 27099 
  """
27100 
 
27101 
  thrift_spec = (
27102 
    None, # 0
6031 rajveer 27103 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27104 
  )
27105 
 
6031 rajveer 27106 
  def __init__(self, userId=None,):
27107 
    self.userId = userId
6000 mandeep.dh 27108 
 
27109 
  def read(self, iprot):
27110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27112 
      return
27113 
    iprot.readStructBegin()
27114 
    while True:
27115 
      (fname, ftype, fid) = iprot.readFieldBegin()
27116 
      if ftype == TType.STOP:
27117 
        break
27118 
      if fid == 1:
27119 
        if ftype == TType.I64:
6031 rajveer 27120 
          self.userId = iprot.readI64();
6000 mandeep.dh 27121 
        else:
27122 
          iprot.skip(ftype)
27123 
      else:
27124 
        iprot.skip(ftype)
27125 
      iprot.readFieldEnd()
27126 
    iprot.readStructEnd()
27127 
 
27128 
  def write(self, oprot):
27129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27131 
      return
6031 rajveer 27132 
    oprot.writeStructBegin('getUserWallet_args')
27133 
    if self.userId is not None:
27134 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27135 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27136 
      oprot.writeFieldEnd()
27137 
    oprot.writeFieldStop()
27138 
    oprot.writeStructEnd()
27139 
 
27140 
  def validate(self):
27141 
    return
27142 
 
27143 
 
27144 
  def __repr__(self):
27145 
    L = ['%s=%r' % (key, value)
27146 
      for key, value in self.__dict__.iteritems()]
27147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27148 
 
27149 
  def __eq__(self, other):
27150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27151 
 
27152 
  def __ne__(self, other):
27153 
    return not (self == other)
27154 
 
6031 rajveer 27155 
class getUserWallet_result:
6000 mandeep.dh 27156 
  """
27157 
  Attributes:
27158 
   - success
27159 
  """
27160 
 
27161 
  thrift_spec = (
6031 rajveer 27162 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27163 
  )
27164 
 
27165 
  def __init__(self, success=None,):
27166 
    self.success = success
27167 
 
27168 
  def read(self, iprot):
27169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27171 
      return
27172 
    iprot.readStructBegin()
27173 
    while True:
27174 
      (fname, ftype, fid) = iprot.readFieldBegin()
27175 
      if ftype == TType.STOP:
27176 
        break
27177 
      if fid == 0:
6031 rajveer 27178 
        if ftype == TType.STRUCT:
27179 
          self.success = UserWallet()
27180 
          self.success.read(iprot)
6000 mandeep.dh 27181 
        else:
27182 
          iprot.skip(ftype)
27183 
      else:
27184 
        iprot.skip(ftype)
27185 
      iprot.readFieldEnd()
27186 
    iprot.readStructEnd()
27187 
 
27188 
  def write(self, oprot):
27189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27191 
      return
6031 rajveer 27192 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27193 
    if self.success is not None:
6031 rajveer 27194 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27195 
      self.success.write(oprot)
6000 mandeep.dh 27196 
      oprot.writeFieldEnd()
27197 
    oprot.writeFieldStop()
27198 
    oprot.writeStructEnd()
27199 
 
27200 
  def validate(self):
27201 
    return
27202 
 
27203 
 
27204 
  def __repr__(self):
27205 
    L = ['%s=%r' % (key, value)
27206 
      for key, value in self.__dict__.iteritems()]
27207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27208 
 
27209 
  def __eq__(self, other):
27210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27211 
 
27212 
  def __ne__(self, other):
27213 
    return not (self == other)
27214 
 
6031 rajveer 27215 
class getUserWalletHistory_args:
6000 mandeep.dh 27216 
  """
27217 
  Attributes:
6031 rajveer 27218 
   - userId
6000 mandeep.dh 27219 
  """
27220 
 
27221 
  thrift_spec = (
27222 
    None, # 0
6031 rajveer 27223 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27224 
  )
27225 
 
6031 rajveer 27226 
  def __init__(self, userId=None,):
27227 
    self.userId = userId
6000 mandeep.dh 27228 
 
27229 
  def read(self, iprot):
27230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27232 
      return
27233 
    iprot.readStructBegin()
27234 
    while True:
27235 
      (fname, ftype, fid) = iprot.readFieldBegin()
27236 
      if ftype == TType.STOP:
27237 
        break
27238 
      if fid == 1:
27239 
        if ftype == TType.I64:
6031 rajveer 27240 
          self.userId = iprot.readI64();
6000 mandeep.dh 27241 
        else:
27242 
          iprot.skip(ftype)
27243 
      else:
27244 
        iprot.skip(ftype)
27245 
      iprot.readFieldEnd()
27246 
    iprot.readStructEnd()
27247 
 
27248 
  def write(self, oprot):
27249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27251 
      return
6031 rajveer 27252 
    oprot.writeStructBegin('getUserWalletHistory_args')
27253 
    if self.userId is not None:
27254 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27255 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27256 
      oprot.writeFieldEnd()
27257 
    oprot.writeFieldStop()
27258 
    oprot.writeStructEnd()
27259 
 
27260 
  def validate(self):
27261 
    return
27262 
 
27263 
 
27264 
  def __repr__(self):
27265 
    L = ['%s=%r' % (key, value)
27266 
      for key, value in self.__dict__.iteritems()]
27267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27268 
 
27269 
  def __eq__(self, other):
27270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27271 
 
27272 
  def __ne__(self, other):
27273 
    return not (self == other)
27274 
 
6031 rajveer 27275 
class getUserWalletHistory_result:
6000 mandeep.dh 27276 
  """
27277 
  Attributes:
27278 
   - success
27279 
  """
27280 
 
27281 
  thrift_spec = (
6031 rajveer 27282 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27283 
  )
27284 
 
27285 
  def __init__(self, success=None,):
27286 
    self.success = success
27287 
 
27288 
  def read(self, iprot):
27289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27291 
      return
27292 
    iprot.readStructBegin()
27293 
    while True:
27294 
      (fname, ftype, fid) = iprot.readFieldBegin()
27295 
      if ftype == TType.STOP:
27296 
        break
27297 
      if fid == 0:
27298 
        if ftype == TType.LIST:
27299 
          self.success = []
6188 rajveer 27300 
          (_etype666, _size663) = iprot.readListBegin()
27301 
          for _i667 in xrange(_size663):
27302 
            _elem668 = UserWalletHistory()
27303 
            _elem668.read(iprot)
27304 
            self.success.append(_elem668)
6000 mandeep.dh 27305 
          iprot.readListEnd()
27306 
        else:
27307 
          iprot.skip(ftype)
27308 
      else:
27309 
        iprot.skip(ftype)
27310 
      iprot.readFieldEnd()
27311 
    iprot.readStructEnd()
27312 
 
27313 
  def write(self, oprot):
27314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27316 
      return
6031 rajveer 27317 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27318 
    if self.success is not None:
27319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27321 
      for iter669 in self.success:
27322 
        iter669.write(oprot)
6000 mandeep.dh 27323 
      oprot.writeListEnd()
27324 
      oprot.writeFieldEnd()
27325 
    oprot.writeFieldStop()
27326 
    oprot.writeStructEnd()
27327 
 
27328 
  def validate(self):
27329 
    return
27330 
 
27331 
 
27332 
  def __repr__(self):
27333 
    L = ['%s=%r' % (key, value)
27334 
      for key, value in self.__dict__.iteritems()]
27335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27336 
 
27337 
  def __eq__(self, other):
27338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27339 
 
27340 
  def __ne__(self, other):
27341 
    return not (self == other)
6048 rajveer 27342 
 
6050 anupam.sin 27343 
class getRechargeOrdersForTransaction_args:
27344 
  """
27345 
  Attributes:
27346 
   - txnId
27347 
  """
27348 
 
27349 
  thrift_spec = (
27350 
    None, # 0
27351 
    (1, TType.I64, 'txnId', None, None, ), # 1
27352 
  )
27353 
 
27354 
  def __init__(self, txnId=None,):
27355 
    self.txnId = txnId
27356 
 
27357 
  def read(self, iprot):
27358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27360 
      return
27361 
    iprot.readStructBegin()
27362 
    while True:
27363 
      (fname, ftype, fid) = iprot.readFieldBegin()
27364 
      if ftype == TType.STOP:
27365 
        break
27366 
      if fid == 1:
27367 
        if ftype == TType.I64:
27368 
          self.txnId = iprot.readI64();
27369 
        else:
27370 
          iprot.skip(ftype)
27371 
      else:
27372 
        iprot.skip(ftype)
27373 
      iprot.readFieldEnd()
27374 
    iprot.readStructEnd()
27375 
 
27376 
  def write(self, oprot):
27377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27379 
      return
27380 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27381 
    if self.txnId is not None:
27382 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27383 
      oprot.writeI64(self.txnId)
27384 
      oprot.writeFieldEnd()
27385 
    oprot.writeFieldStop()
27386 
    oprot.writeStructEnd()
27387 
 
27388 
  def validate(self):
27389 
    return
27390 
 
27391 
 
27392 
  def __repr__(self):
27393 
    L = ['%s=%r' % (key, value)
27394 
      for key, value in self.__dict__.iteritems()]
27395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27396 
 
27397 
  def __eq__(self, other):
27398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27399 
 
27400 
  def __ne__(self, other):
27401 
    return not (self == other)
27402 
 
27403 
class getRechargeOrdersForTransaction_result:
27404 
  """
27405 
  Attributes:
27406 
   - success
27407 
   - ex
27408 
  """
27409 
 
27410 
  thrift_spec = (
27411 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27413 
  )
27414 
 
27415 
  def __init__(self, success=None, ex=None,):
27416 
    self.success = success
27417 
    self.ex = ex
27418 
 
27419 
  def read(self, iprot):
27420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27422 
      return
27423 
    iprot.readStructBegin()
27424 
    while True:
27425 
      (fname, ftype, fid) = iprot.readFieldBegin()
27426 
      if ftype == TType.STOP:
27427 
        break
27428 
      if fid == 0:
27429 
        if ftype == TType.STRUCT:
27430 
          self.success = RechargeOrder()
27431 
          self.success.read(iprot)
27432 
        else:
27433 
          iprot.skip(ftype)
27434 
      elif fid == 1:
27435 
        if ftype == TType.STRUCT:
27436 
          self.ex = TransactionServiceException()
27437 
          self.ex.read(iprot)
27438 
        else:
27439 
          iprot.skip(ftype)
27440 
      else:
27441 
        iprot.skip(ftype)
27442 
      iprot.readFieldEnd()
27443 
    iprot.readStructEnd()
27444 
 
27445 
  def write(self, oprot):
27446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27448 
      return
27449 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27450 
    if self.success is not None:
27451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27452 
      self.success.write(oprot)
27453 
      oprot.writeFieldEnd()
27454 
    if self.ex is not None:
27455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27456 
      self.ex.write(oprot)
27457 
      oprot.writeFieldEnd()
27458 
    oprot.writeFieldStop()
27459 
    oprot.writeStructEnd()
27460 
 
27461 
  def validate(self):
27462 
    return
27463 
 
27464 
 
27465 
  def __repr__(self):
27466 
    L = ['%s=%r' % (key, value)
27467 
      for key, value in self.__dict__.iteritems()]
27468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27469 
 
27470 
  def __eq__(self, other):
27471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27472 
 
27473 
  def __ne__(self, other):
27474 
    return not (self == other)
27475 
 
6048 rajveer 27476 
class getServiceProviders_args:
27477 
  """
27478 
  Attributes:
27479 
   - rechargeType
6206 rajveer 27480 
   - onlyActive
6048 rajveer 27481 
  """
27482 
 
27483 
  thrift_spec = (
27484 
    None, # 0
27485 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27486 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27487 
  )
27488 
 
6206 rajveer 27489 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27490 
    self.rechargeType = rechargeType
6206 rajveer 27491 
    self.onlyActive = onlyActive
6048 rajveer 27492 
 
27493 
  def read(self, iprot):
27494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27496 
      return
27497 
    iprot.readStructBegin()
27498 
    while True:
27499 
      (fname, ftype, fid) = iprot.readFieldBegin()
27500 
      if ftype == TType.STOP:
27501 
        break
27502 
      if fid == 1:
27503 
        if ftype == TType.I32:
27504 
          self.rechargeType = iprot.readI32();
27505 
        else:
27506 
          iprot.skip(ftype)
6206 rajveer 27507 
      elif fid == 2:
27508 
        if ftype == TType.BOOL:
27509 
          self.onlyActive = iprot.readBool();
27510 
        else:
27511 
          iprot.skip(ftype)
6048 rajveer 27512 
      else:
27513 
        iprot.skip(ftype)
27514 
      iprot.readFieldEnd()
27515 
    iprot.readStructEnd()
27516 
 
27517 
  def write(self, oprot):
27518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27520 
      return
27521 
    oprot.writeStructBegin('getServiceProviders_args')
27522 
    if self.rechargeType is not None:
27523 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27524 
      oprot.writeI32(self.rechargeType)
27525 
      oprot.writeFieldEnd()
6206 rajveer 27526 
    if self.onlyActive is not None:
27527 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27528 
      oprot.writeBool(self.onlyActive)
27529 
      oprot.writeFieldEnd()
6048 rajveer 27530 
    oprot.writeFieldStop()
27531 
    oprot.writeStructEnd()
27532 
 
27533 
  def validate(self):
27534 
    return
27535 
 
27536 
 
27537 
  def __repr__(self):
27538 
    L = ['%s=%r' % (key, value)
27539 
      for key, value in self.__dict__.iteritems()]
27540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27541 
 
27542 
  def __eq__(self, other):
27543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27544 
 
27545 
  def __ne__(self, other):
27546 
    return not (self == other)
27547 
 
27548 
class getServiceProviders_result:
27549 
  """
27550 
  Attributes:
27551 
   - success
27552 
  """
27553 
 
27554 
  thrift_spec = (
27555 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27556 
  )
27557 
 
27558 
  def __init__(self, success=None,):
27559 
    self.success = success
27560 
 
27561 
  def read(self, iprot):
27562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27564 
      return
27565 
    iprot.readStructBegin()
27566 
    while True:
27567 
      (fname, ftype, fid) = iprot.readFieldBegin()
27568 
      if ftype == TType.STOP:
27569 
        break
27570 
      if fid == 0:
27571 
        if ftype == TType.MAP:
27572 
          self.success = {}
6188 rajveer 27573 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27574 
          for _i674 in xrange(_size670):
27575 
            _key675 = iprot.readI64();
27576 
            _val676 = iprot.readString();
27577 
            self.success[_key675] = _val676
6048 rajveer 27578 
          iprot.readMapEnd()
27579 
        else:
27580 
          iprot.skip(ftype)
27581 
      else:
27582 
        iprot.skip(ftype)
27583 
      iprot.readFieldEnd()
27584 
    iprot.readStructEnd()
27585 
 
27586 
  def write(self, oprot):
27587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27589 
      return
27590 
    oprot.writeStructBegin('getServiceProviders_result')
27591 
    if self.success is not None:
27592 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27593 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27594 
      for kiter677,viter678 in self.success.items():
27595 
        oprot.writeI64(kiter677)
27596 
        oprot.writeString(viter678)
6048 rajveer 27597 
      oprot.writeMapEnd()
27598 
      oprot.writeFieldEnd()
27599 
    oprot.writeFieldStop()
27600 
    oprot.writeStructEnd()
27601 
 
27602 
  def validate(self):
27603 
    return
27604 
 
27605 
 
27606 
  def __repr__(self):
27607 
    L = ['%s=%r' % (key, value)
27608 
      for key, value in self.__dict__.iteritems()]
27609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27610 
 
27611 
  def __eq__(self, other):
27612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27613 
 
27614 
  def __ne__(self, other):
27615 
    return not (self == other)
27616 
 
27617 
class getServiceProviderForDevice_args:
27618 
  """
27619 
  Attributes:
6049 rajveer 27620 
   - rechargeType
6048 rajveer 27621 
   - deviceNumber
27622 
  """
27623 
 
27624 
  thrift_spec = (
27625 
    None, # 0
6049 rajveer 27626 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27627 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27628 
  )
27629 
 
6049 rajveer 27630 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27631 
    self.rechargeType = rechargeType
6048 rajveer 27632 
    self.deviceNumber = deviceNumber
27633 
 
27634 
  def read(self, iprot):
27635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27637 
      return
27638 
    iprot.readStructBegin()
27639 
    while True:
27640 
      (fname, ftype, fid) = iprot.readFieldBegin()
27641 
      if ftype == TType.STOP:
27642 
        break
27643 
      if fid == 1:
6049 rajveer 27644 
        if ftype == TType.I32:
27645 
          self.rechargeType = iprot.readI32();
27646 
        else:
27647 
          iprot.skip(ftype)
27648 
      elif fid == 2:
6048 rajveer 27649 
        if ftype == TType.STRING:
27650 
          self.deviceNumber = iprot.readString();
27651 
        else:
27652 
          iprot.skip(ftype)
27653 
      else:
27654 
        iprot.skip(ftype)
27655 
      iprot.readFieldEnd()
27656 
    iprot.readStructEnd()
27657 
 
27658 
  def write(self, oprot):
27659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27661 
      return
27662 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27663 
    if self.rechargeType is not None:
27664 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27665 
      oprot.writeI32(self.rechargeType)
27666 
      oprot.writeFieldEnd()
6048 rajveer 27667 
    if self.deviceNumber is not None:
6049 rajveer 27668 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27669 
      oprot.writeString(self.deviceNumber)
27670 
      oprot.writeFieldEnd()
27671 
    oprot.writeFieldStop()
27672 
    oprot.writeStructEnd()
27673 
 
27674 
  def validate(self):
27675 
    return
27676 
 
27677 
 
27678 
  def __repr__(self):
27679 
    L = ['%s=%r' % (key, value)
27680 
      for key, value in self.__dict__.iteritems()]
27681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27682 
 
27683 
  def __eq__(self, other):
27684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27685 
 
27686 
  def __ne__(self, other):
27687 
    return not (self == other)
27688 
 
27689 
class getServiceProviderForDevice_result:
27690 
  """
27691 
  Attributes:
27692 
   - success
27693 
  """
27694 
 
27695 
  thrift_spec = (
27696 
    (0, TType.I64, 'success', None, None, ), # 0
27697 
  )
27698 
 
27699 
  def __init__(self, success=None,):
27700 
    self.success = success
27701 
 
27702 
  def read(self, iprot):
27703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27705 
      return
27706 
    iprot.readStructBegin()
27707 
    while True:
27708 
      (fname, ftype, fid) = iprot.readFieldBegin()
27709 
      if ftype == TType.STOP:
27710 
        break
27711 
      if fid == 0:
27712 
        if ftype == TType.I64:
27713 
          self.success = iprot.readI64();
27714 
        else:
27715 
          iprot.skip(ftype)
27716 
      else:
27717 
        iprot.skip(ftype)
27718 
      iprot.readFieldEnd()
27719 
    iprot.readStructEnd()
27720 
 
27721 
  def write(self, oprot):
27722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27724 
      return
27725 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27726 
    if self.success is not None:
27727 
      oprot.writeFieldBegin('success', TType.I64, 0)
27728 
      oprot.writeI64(self.success)
27729 
      oprot.writeFieldEnd()
27730 
    oprot.writeFieldStop()
27731 
    oprot.writeStructEnd()
27732 
 
27733 
  def validate(self):
27734 
    return
27735 
 
27736 
 
27737 
  def __repr__(self):
27738 
    L = ['%s=%r' % (key, value)
27739 
      for key, value in self.__dict__.iteritems()]
27740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27741 
 
27742 
  def __eq__(self, other):
27743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27744 
 
27745 
  def __ne__(self, other):
27746 
    return not (self == other)
6094 rajveer 27747 
 
6269 rajveer 27748 
class validateRecharge_args:
27749 
  """
27750 
  Attributes:
27751 
   - rechargeType
27752 
   - deviceNumber
27753 
  """
27754 
 
27755 
  thrift_spec = (
27756 
    None, # 0
27757 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27758 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
27759 
  )
27760 
 
27761 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27762 
    self.rechargeType = rechargeType
27763 
    self.deviceNumber = deviceNumber
27764 
 
27765 
  def read(self, iprot):
27766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27768 
      return
27769 
    iprot.readStructBegin()
27770 
    while True:
27771 
      (fname, ftype, fid) = iprot.readFieldBegin()
27772 
      if ftype == TType.STOP:
27773 
        break
27774 
      if fid == 1:
27775 
        if ftype == TType.I32:
27776 
          self.rechargeType = iprot.readI32();
27777 
        else:
27778 
          iprot.skip(ftype)
27779 
      elif fid == 2:
27780 
        if ftype == TType.STRING:
27781 
          self.deviceNumber = iprot.readString();
27782 
        else:
27783 
          iprot.skip(ftype)
27784 
      else:
27785 
        iprot.skip(ftype)
27786 
      iprot.readFieldEnd()
27787 
    iprot.readStructEnd()
27788 
 
27789 
  def write(self, oprot):
27790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27792 
      return
27793 
    oprot.writeStructBegin('validateRecharge_args')
27794 
    if self.rechargeType is not None:
27795 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27796 
      oprot.writeI32(self.rechargeType)
27797 
      oprot.writeFieldEnd()
27798 
    if self.deviceNumber is not None:
27799 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
27800 
      oprot.writeString(self.deviceNumber)
27801 
      oprot.writeFieldEnd()
27802 
    oprot.writeFieldStop()
27803 
    oprot.writeStructEnd()
27804 
 
27805 
  def validate(self):
27806 
    return
27807 
 
27808 
 
27809 
  def __repr__(self):
27810 
    L = ['%s=%r' % (key, value)
27811 
      for key, value in self.__dict__.iteritems()]
27812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27813 
 
27814 
  def __eq__(self, other):
27815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27816 
 
27817 
  def __ne__(self, other):
27818 
    return not (self == other)
27819 
 
27820 
class validateRecharge_result:
27821 
  """
27822 
  Attributes:
27823 
   - success
27824 
  """
27825 
 
27826 
  thrift_spec = (
27827 
    (0, TType.STRING, 'success', None, None, ), # 0
27828 
  )
27829 
 
27830 
  def __init__(self, success=None,):
27831 
    self.success = success
27832 
 
27833 
  def read(self, iprot):
27834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27836 
      return
27837 
    iprot.readStructBegin()
27838 
    while True:
27839 
      (fname, ftype, fid) = iprot.readFieldBegin()
27840 
      if ftype == TType.STOP:
27841 
        break
27842 
      if fid == 0:
27843 
        if ftype == TType.STRING:
27844 
          self.success = iprot.readString();
27845 
        else:
27846 
          iprot.skip(ftype)
27847 
      else:
27848 
        iprot.skip(ftype)
27849 
      iprot.readFieldEnd()
27850 
    iprot.readStructEnd()
27851 
 
27852 
  def write(self, oprot):
27853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27855 
      return
27856 
    oprot.writeStructBegin('validateRecharge_result')
27857 
    if self.success is not None:
27858 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27859 
      oprot.writeString(self.success)
27860 
      oprot.writeFieldEnd()
27861 
    oprot.writeFieldStop()
27862 
    oprot.writeStructEnd()
27863 
 
27864 
  def validate(self):
27865 
    return
27866 
 
27867 
 
27868 
  def __repr__(self):
27869 
    L = ['%s=%r' % (key, value)
27870 
      for key, value in self.__dict__.iteritems()]
27871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27872 
 
27873 
  def __eq__(self, other):
27874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27875 
 
27876 
  def __ne__(self, other):
27877 
    return not (self == other)
27878 
 
6094 rajveer 27879 
class getRechargeOrdersForDevice_args:
27880 
  """
27881 
  Attributes:
27882 
   - deviceNumber
27883 
  """
27884 
 
27885 
  thrift_spec = (
27886 
    None, # 0
27887 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27888 
  )
27889 
 
27890 
  def __init__(self, deviceNumber=None,):
27891 
    self.deviceNumber = deviceNumber
27892 
 
27893 
  def read(self, iprot):
27894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27896 
      return
27897 
    iprot.readStructBegin()
27898 
    while True:
27899 
      (fname, ftype, fid) = iprot.readFieldBegin()
27900 
      if ftype == TType.STOP:
27901 
        break
27902 
      if fid == 1:
27903 
        if ftype == TType.STRING:
27904 
          self.deviceNumber = iprot.readString();
27905 
        else:
27906 
          iprot.skip(ftype)
27907 
      else:
27908 
        iprot.skip(ftype)
27909 
      iprot.readFieldEnd()
27910 
    iprot.readStructEnd()
27911 
 
27912 
  def write(self, oprot):
27913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27915 
      return
27916 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27917 
    if self.deviceNumber is not None:
27918 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27919 
      oprot.writeString(self.deviceNumber)
27920 
      oprot.writeFieldEnd()
27921 
    oprot.writeFieldStop()
27922 
    oprot.writeStructEnd()
27923 
 
27924 
  def validate(self):
27925 
    return
27926 
 
27927 
 
27928 
  def __repr__(self):
27929 
    L = ['%s=%r' % (key, value)
27930 
      for key, value in self.__dict__.iteritems()]
27931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27932 
 
27933 
  def __eq__(self, other):
27934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27935 
 
27936 
  def __ne__(self, other):
27937 
    return not (self == other)
27938 
 
27939 
class getRechargeOrdersForDevice_result:
27940 
  """
27941 
  Attributes:
27942 
   - success
27943 
  """
27944 
 
27945 
  thrift_spec = (
27946 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27947 
  )
27948 
 
27949 
  def __init__(self, success=None,):
27950 
    self.success = success
27951 
 
27952 
  def read(self, iprot):
27953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27955 
      return
27956 
    iprot.readStructBegin()
27957 
    while True:
27958 
      (fname, ftype, fid) = iprot.readFieldBegin()
27959 
      if ftype == TType.STOP:
27960 
        break
27961 
      if fid == 0:
27962 
        if ftype == TType.LIST:
27963 
          self.success = []
6188 rajveer 27964 
          (_etype682, _size679) = iprot.readListBegin()
27965 
          for _i683 in xrange(_size679):
27966 
            _elem684 = RechargeOrder()
27967 
            _elem684.read(iprot)
27968 
            self.success.append(_elem684)
6094 rajveer 27969 
          iprot.readListEnd()
27970 
        else:
27971 
          iprot.skip(ftype)
27972 
      else:
27973 
        iprot.skip(ftype)
27974 
      iprot.readFieldEnd()
27975 
    iprot.readStructEnd()
27976 
 
27977 
  def write(self, oprot):
27978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27980 
      return
27981 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27982 
    if self.success is not None:
27983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27984 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27985 
      for iter685 in self.success:
27986 
        iter685.write(oprot)
6094 rajveer 27987 
      oprot.writeListEnd()
27988 
      oprot.writeFieldEnd()
27989 
    oprot.writeFieldStop()
27990 
    oprot.writeStructEnd()
27991 
 
27992 
  def validate(self):
27993 
    return
27994 
 
27995 
 
27996 
  def __repr__(self):
27997 
    L = ['%s=%r' % (key, value)
27998 
      for key, value in self.__dict__.iteritems()]
27999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28000 
 
28001 
  def __eq__(self, other):
28002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28003 
 
28004 
  def __ne__(self, other):
28005 
    return not (self == other)
28006 
 
28007 
class addAmountToWallet_args:
28008 
  """
28009 
  Attributes:
28010 
   - userId
28011 
   - orderId
28012 
   - amount
28013 
  """
28014 
 
28015 
  thrift_spec = (
28016 
    None, # 0
28017 
    (1, TType.I64, 'userId', None, None, ), # 1
28018 
    (2, TType.I64, 'orderId', None, None, ), # 2
28019 
    (3, TType.I64, 'amount', None, None, ), # 3
28020 
  )
28021 
 
28022 
  def __init__(self, userId=None, orderId=None, amount=None,):
28023 
    self.userId = userId
28024 
    self.orderId = orderId
28025 
    self.amount = amount
28026 
 
28027 
  def read(self, iprot):
28028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28030 
      return
28031 
    iprot.readStructBegin()
28032 
    while True:
28033 
      (fname, ftype, fid) = iprot.readFieldBegin()
28034 
      if ftype == TType.STOP:
28035 
        break
28036 
      if fid == 1:
28037 
        if ftype == TType.I64:
28038 
          self.userId = iprot.readI64();
28039 
        else:
28040 
          iprot.skip(ftype)
28041 
      elif fid == 2:
28042 
        if ftype == TType.I64:
28043 
          self.orderId = iprot.readI64();
28044 
        else:
28045 
          iprot.skip(ftype)
28046 
      elif fid == 3:
28047 
        if ftype == TType.I64:
28048 
          self.amount = iprot.readI64();
28049 
        else:
28050 
          iprot.skip(ftype)
28051 
      else:
28052 
        iprot.skip(ftype)
28053 
      iprot.readFieldEnd()
28054 
    iprot.readStructEnd()
28055 
 
28056 
  def write(self, oprot):
28057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28059 
      return
28060 
    oprot.writeStructBegin('addAmountToWallet_args')
28061 
    if self.userId is not None:
28062 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28063 
      oprot.writeI64(self.userId)
28064 
      oprot.writeFieldEnd()
28065 
    if self.orderId is not None:
28066 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28067 
      oprot.writeI64(self.orderId)
28068 
      oprot.writeFieldEnd()
28069 
    if self.amount is not None:
28070 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28071 
      oprot.writeI64(self.amount)
28072 
      oprot.writeFieldEnd()
28073 
    oprot.writeFieldStop()
28074 
    oprot.writeStructEnd()
28075 
 
28076 
  def validate(self):
28077 
    return
28078 
 
28079 
 
28080 
  def __repr__(self):
28081 
    L = ['%s=%r' % (key, value)
28082 
      for key, value in self.__dict__.iteritems()]
28083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28084 
 
28085 
  def __eq__(self, other):
28086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28087 
 
28088 
  def __ne__(self, other):
28089 
    return not (self == other)
28090 
 
28091 
class addAmountToWallet_result:
28092 
 
28093 
  thrift_spec = (
28094 
  )
28095 
 
28096 
  def read(self, iprot):
28097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28099 
      return
28100 
    iprot.readStructBegin()
28101 
    while True:
28102 
      (fname, ftype, fid) = iprot.readFieldBegin()
28103 
      if ftype == TType.STOP:
28104 
        break
28105 
      else:
28106 
        iprot.skip(ftype)
28107 
      iprot.readFieldEnd()
28108 
    iprot.readStructEnd()
28109 
 
28110 
  def write(self, oprot):
28111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28113 
      return
28114 
    oprot.writeStructBegin('addAmountToWallet_result')
28115 
    oprot.writeFieldStop()
28116 
    oprot.writeStructEnd()
28117 
 
28118 
  def validate(self):
28119 
    return
28120 
 
28121 
 
28122 
  def __repr__(self):
28123 
    L = ['%s=%r' % (key, value)
28124 
      for key, value in self.__dict__.iteritems()]
28125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28126 
 
28127 
  def __eq__(self, other):
28128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28129 
 
28130 
  def __ne__(self, other):
28131 
    return not (self == other)
6154 rajveer 28132 
 
6188 rajveer 28133 
class getRechargeStatistics_args:
28134 
 
28135 
  thrift_spec = (
28136 
  )
28137 
 
28138 
  def read(self, iprot):
28139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28141 
      return
28142 
    iprot.readStructBegin()
28143 
    while True:
28144 
      (fname, ftype, fid) = iprot.readFieldBegin()
28145 
      if ftype == TType.STOP:
28146 
        break
28147 
      else:
28148 
        iprot.skip(ftype)
28149 
      iprot.readFieldEnd()
28150 
    iprot.readStructEnd()
28151 
 
28152 
  def write(self, oprot):
28153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28155 
      return
28156 
    oprot.writeStructBegin('getRechargeStatistics_args')
28157 
    oprot.writeFieldStop()
28158 
    oprot.writeStructEnd()
28159 
 
28160 
  def validate(self):
28161 
    return
28162 
 
28163 
 
28164 
  def __repr__(self):
28165 
    L = ['%s=%r' % (key, value)
28166 
      for key, value in self.__dict__.iteritems()]
28167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28168 
 
28169 
  def __eq__(self, other):
28170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28171 
 
28172 
  def __ne__(self, other):
28173 
    return not (self == other)
28174 
 
28175 
class getRechargeStatistics_result:
28176 
  """
28177 
  Attributes:
28178 
   - success
28179 
  """
28180 
 
28181 
  thrift_spec = (
28182 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28183 
  )
28184 
 
28185 
  def __init__(self, success=None,):
28186 
    self.success = success
28187 
 
28188 
  def read(self, iprot):
28189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28191 
      return
28192 
    iprot.readStructBegin()
28193 
    while True:
28194 
      (fname, ftype, fid) = iprot.readFieldBegin()
28195 
      if ftype == TType.STOP:
28196 
        break
28197 
      if fid == 0:
28198 
        if ftype == TType.STRUCT:
28199 
          self.success = RechargeStatistics()
28200 
          self.success.read(iprot)
28201 
        else:
28202 
          iprot.skip(ftype)
28203 
      else:
28204 
        iprot.skip(ftype)
28205 
      iprot.readFieldEnd()
28206 
    iprot.readStructEnd()
28207 
 
28208 
  def write(self, oprot):
28209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28211 
      return
28212 
    oprot.writeStructBegin('getRechargeStatistics_result')
28213 
    if self.success is not None:
28214 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28215 
      self.success.write(oprot)
28216 
      oprot.writeFieldEnd()
28217 
    oprot.writeFieldStop()
28218 
    oprot.writeStructEnd()
28219 
 
28220 
  def validate(self):
28221 
    return
28222 
 
28223 
 
28224 
  def __repr__(self):
28225 
    L = ['%s=%r' % (key, value)
28226 
      for key, value in self.__dict__.iteritems()]
28227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28228 
 
28229 
  def __eq__(self, other):
28230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28231 
 
28232 
  def __ne__(self, other):
28233 
    return not (self == other)
28234 
 
6154 rajveer 28235 
class getRechargeOrdersForStatus_args:
28236 
  """
28237 
  Attributes:
28238 
   - status
28239 
  """
28240 
 
28241 
  thrift_spec = (
28242 
    None, # 0
28243 
    (1, TType.I64, 'status', None, None, ), # 1
28244 
  )
28245 
 
28246 
  def __init__(self, status=None,):
28247 
    self.status = status
28248 
 
28249 
  def read(self, iprot):
28250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28252 
      return
28253 
    iprot.readStructBegin()
28254 
    while True:
28255 
      (fname, ftype, fid) = iprot.readFieldBegin()
28256 
      if ftype == TType.STOP:
28257 
        break
28258 
      if fid == 1:
28259 
        if ftype == TType.I64:
28260 
          self.status = iprot.readI64();
28261 
        else:
28262 
          iprot.skip(ftype)
28263 
      else:
28264 
        iprot.skip(ftype)
28265 
      iprot.readFieldEnd()
28266 
    iprot.readStructEnd()
28267 
 
28268 
  def write(self, oprot):
28269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28271 
      return
28272 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28273 
    if self.status is not None:
28274 
      oprot.writeFieldBegin('status', TType.I64, 1)
28275 
      oprot.writeI64(self.status)
28276 
      oprot.writeFieldEnd()
28277 
    oprot.writeFieldStop()
28278 
    oprot.writeStructEnd()
28279 
 
28280 
  def validate(self):
28281 
    return
28282 
 
28283 
 
28284 
  def __repr__(self):
28285 
    L = ['%s=%r' % (key, value)
28286 
      for key, value in self.__dict__.iteritems()]
28287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28288 
 
28289 
  def __eq__(self, other):
28290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28291 
 
28292 
  def __ne__(self, other):
28293 
    return not (self == other)
28294 
 
28295 
class getRechargeOrdersForStatus_result:
28296 
  """
28297 
  Attributes:
28298 
   - success
28299 
  """
28300 
 
28301 
  thrift_spec = (
28302 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28303 
  )
28304 
 
28305 
  def __init__(self, success=None,):
28306 
    self.success = success
28307 
 
28308 
  def read(self, iprot):
28309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28311 
      return
28312 
    iprot.readStructBegin()
28313 
    while True:
28314 
      (fname, ftype, fid) = iprot.readFieldBegin()
28315 
      if ftype == TType.STOP:
28316 
        break
28317 
      if fid == 0:
28318 
        if ftype == TType.LIST:
28319 
          self.success = []
6188 rajveer 28320 
          (_etype689, _size686) = iprot.readListBegin()
28321 
          for _i690 in xrange(_size686):
28322 
            _elem691 = RechargeOrder()
28323 
            _elem691.read(iprot)
28324 
            self.success.append(_elem691)
6154 rajveer 28325 
          iprot.readListEnd()
28326 
        else:
28327 
          iprot.skip(ftype)
28328 
      else:
28329 
        iprot.skip(ftype)
28330 
      iprot.readFieldEnd()
28331 
    iprot.readStructEnd()
28332 
 
28333 
  def write(self, oprot):
28334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28336 
      return
28337 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28338 
    if self.success is not None:
28339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28341 
      for iter692 in self.success:
28342 
        iter692.write(oprot)
6154 rajveer 28343 
      oprot.writeListEnd()
28344 
      oprot.writeFieldEnd()
28345 
    oprot.writeFieldStop()
28346 
    oprot.writeStructEnd()
28347 
 
28348 
  def validate(self):
28349 
    return
28350 
 
28351 
 
28352 
  def __repr__(self):
28353 
    L = ['%s=%r' % (key, value)
28354 
      for key, value in self.__dict__.iteritems()]
28355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28356 
 
28357 
  def __eq__(self, other):
28358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28359 
 
28360 
  def __ne__(self, other):
28361 
    return not (self == other)
6159 rajveer 28362 
 
28363 
class getPlansForOperator_args:
28364 
  """
28365 
  Attributes:
28366 
   - operatorId
28367 
  """
28368 
 
28369 
  thrift_spec = (
28370 
    None, # 0
28371 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28372 
  )
28373 
 
28374 
  def __init__(self, operatorId=None,):
28375 
    self.operatorId = operatorId
28376 
 
28377 
  def read(self, iprot):
28378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28380 
      return
28381 
    iprot.readStructBegin()
28382 
    while True:
28383 
      (fname, ftype, fid) = iprot.readFieldBegin()
28384 
      if ftype == TType.STOP:
28385 
        break
28386 
      if fid == 1:
28387 
        if ftype == TType.I64:
28388 
          self.operatorId = iprot.readI64();
28389 
        else:
28390 
          iprot.skip(ftype)
28391 
      else:
28392 
        iprot.skip(ftype)
28393 
      iprot.readFieldEnd()
28394 
    iprot.readStructEnd()
28395 
 
28396 
  def write(self, oprot):
28397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28399 
      return
28400 
    oprot.writeStructBegin('getPlansForOperator_args')
28401 
    if self.operatorId is not None:
28402 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28403 
      oprot.writeI64(self.operatorId)
28404 
      oprot.writeFieldEnd()
28405 
    oprot.writeFieldStop()
28406 
    oprot.writeStructEnd()
28407 
 
28408 
  def validate(self):
28409 
    return
28410 
 
28411 
 
28412 
  def __repr__(self):
28413 
    L = ['%s=%r' % (key, value)
28414 
      for key, value in self.__dict__.iteritems()]
28415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28416 
 
28417 
  def __eq__(self, other):
28418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28419 
 
28420 
  def __ne__(self, other):
28421 
    return not (self == other)
28422 
 
28423 
class getPlansForOperator_result:
28424 
  """
28425 
  Attributes:
28426 
   - success
28427 
  """
28428 
 
28429 
  thrift_spec = (
28430 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28431 
  )
28432 
 
28433 
  def __init__(self, success=None,):
28434 
    self.success = success
28435 
 
28436 
  def read(self, iprot):
28437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28439 
      return
28440 
    iprot.readStructBegin()
28441 
    while True:
28442 
      (fname, ftype, fid) = iprot.readFieldBegin()
28443 
      if ftype == TType.STOP:
28444 
        break
28445 
      if fid == 0:
28446 
        if ftype == TType.LIST:
28447 
          self.success = []
6188 rajveer 28448 
          (_etype696, _size693) = iprot.readListBegin()
28449 
          for _i697 in xrange(_size693):
28450 
            _elem698 = RechargePlan()
28451 
            _elem698.read(iprot)
28452 
            self.success.append(_elem698)
6159 rajveer 28453 
          iprot.readListEnd()
28454 
        else:
28455 
          iprot.skip(ftype)
28456 
      else:
28457 
        iprot.skip(ftype)
28458 
      iprot.readFieldEnd()
28459 
    iprot.readStructEnd()
28460 
 
28461 
  def write(self, oprot):
28462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28464 
      return
28465 
    oprot.writeStructBegin('getPlansForOperator_result')
28466 
    if self.success is not None:
28467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28468 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28469 
      for iter699 in self.success:
28470 
        iter699.write(oprot)
6159 rajveer 28471 
      oprot.writeListEnd()
28472 
      oprot.writeFieldEnd()
28473 
    oprot.writeFieldStop()
28474 
    oprot.writeStructEnd()
28475 
 
28476 
  def validate(self):
28477 
    return
28478 
 
28479 
 
28480 
  def __repr__(self):
28481 
    L = ['%s=%r' % (key, value)
28482 
      for key, value in self.__dict__.iteritems()]
28483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28484 
 
28485 
  def __eq__(self, other):
28486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28487 
 
28488 
  def __ne__(self, other):
28489 
    return not (self == other)