Subversion Repositories SmartDukaan

Rev

Rev 6269 | Rev 6307 | 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 
 
6289 anupam.sin 1406 
  def getRechargeDenominations(self, operatorId, circleName, denominationType):
1407 
    """
1408 
    Returns denominations for a given operator and circle
6159 rajveer 1409 
 
6289 anupam.sin 1410 
    Parameters:
1411 
     - operatorId
1412 
     - circleName
1413 
     - denominationType
1414 
    """
1415 
    pass
1416 
 
1417 
 
3376 rajveer 1418 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1419 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1420 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1421 
 
1422 
  def createTransaction(self, transaction):
1423 
    """
1424 
    Parameters:
1425 
     - transaction
1426 
    """
1427 
    self.send_createTransaction(transaction)
132 ashish 1428 
    return self.recv_createTransaction()
94 ashish 1429 
 
1430 
  def send_createTransaction(self, transaction):
1431 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1432 
    args = createTransaction_args()
1433 
    args.transaction = transaction
1434 
    args.write(self._oprot)
1435 
    self._oprot.writeMessageEnd()
1436 
    self._oprot.trans.flush()
1437 
 
1438 
  def recv_createTransaction(self, ):
1439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1440 
    if mtype == TMessageType.EXCEPTION:
1441 
      x = TApplicationException()
1442 
      x.read(self._iprot)
1443 
      self._iprot.readMessageEnd()
1444 
      raise x
1445 
    result = createTransaction_result()
1446 
    result.read(self._iprot)
1447 
    self._iprot.readMessageEnd()
3431 rajveer 1448 
    if result.success is not None:
132 ashish 1449 
      return result.success
3431 rajveer 1450 
    if result.ex is not None:
94 ashish 1451 
      raise result.ex
132 ashish 1452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1453 
 
1454 
  def getTransaction(self, id):
1455 
    """
1456 
    Parameters:
1457 
     - id
1458 
    """
1459 
    self.send_getTransaction(id)
1460 
    return self.recv_getTransaction()
1461 
 
1462 
  def send_getTransaction(self, id):
1463 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1464 
    args = getTransaction_args()
1465 
    args.id = id
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_getTransaction(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = getTransaction_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
3431 rajveer 1480 
    if result.success is not None:
94 ashish 1481 
      return result.success
3431 rajveer 1482 
    if result.ex is not None:
94 ashish 1483 
      raise result.ex
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1485 
 
1486 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1487 
    """
1488 
    Parameters:
1489 
     - customerId
1490 
     - from_date
1491 
     - to_date
1492 
     - status
1493 
    """
1494 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1495 
    return self.recv_getTransactionsForCustomer()
1496 
 
1497 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1498 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1499 
    args = getTransactionsForCustomer_args()
1500 
    args.customerId = customerId
1501 
    args.from_date = from_date
1502 
    args.to_date = to_date
1503 
    args.status = status
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getTransactionsForCustomer(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getTransactionsForCustomer_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
3431 rajveer 1518 
    if result.success is not None:
94 ashish 1519 
      return result.success
3431 rajveer 1520 
    if result.ex is not None:
94 ashish 1521 
      raise result.ex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1523 
 
132 ashish 1524 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1525 
    """
1526 
    Parameters:
1527 
     - shoppingCartId
1528 
    """
1529 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1530 
    return self.recv_getTransactionsForShoppingCartId()
1531 
 
1532 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1533 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1534 
    args = getTransactionsForShoppingCartId_args()
1535 
    args.shoppingCartId = shoppingCartId
1536 
    args.write(self._oprot)
1537 
    self._oprot.writeMessageEnd()
1538 
    self._oprot.trans.flush()
1539 
 
1540 
  def recv_getTransactionsForShoppingCartId(self, ):
1541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1542 
    if mtype == TMessageType.EXCEPTION:
1543 
      x = TApplicationException()
1544 
      x.read(self._iprot)
1545 
      self._iprot.readMessageEnd()
1546 
      raise x
1547 
    result = getTransactionsForShoppingCartId_result()
1548 
    result.read(self._iprot)
1549 
    self._iprot.readMessageEnd()
3431 rajveer 1550 
    if result.success is not None:
132 ashish 1551 
      return result.success
3431 rajveer 1552 
    if result.ex is not None:
132 ashish 1553 
      raise result.ex
1554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1555 
 
94 ashish 1556 
  def getTransactionStatus(self, transactionId):
1557 
    """
1558 
    Parameters:
1559 
     - transactionId
1560 
    """
1561 
    self.send_getTransactionStatus(transactionId)
1562 
    return self.recv_getTransactionStatus()
1563 
 
1564 
  def send_getTransactionStatus(self, transactionId):
1565 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1566 
    args = getTransactionStatus_args()
1567 
    args.transactionId = transactionId
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getTransactionStatus(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getTransactionStatus_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
3431 rajveer 1582 
    if result.success is not None:
94 ashish 1583 
      return result.success
3431 rajveer 1584 
    if result.ex is not None:
94 ashish 1585 
      raise result.ex
1586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1587 
 
5527 anupam.sin 1588 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1589 
    """
1590 
    Parameters:
1591 
     - transactionId
1592 
     - status
1593 
     - description
5527 anupam.sin 1594 
     - pickUp
1595 
     - orderType
94 ashish 1596 
    """
5527 anupam.sin 1597 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1598 
    return self.recv_changeTransactionStatus()
1599 
 
5527 anupam.sin 1600 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1601 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1602 
    args = changeTransactionStatus_args()
1603 
    args.transactionId = transactionId
1604 
    args.status = status
1605 
    args.description = description
5527 anupam.sin 1606 
    args.pickUp = pickUp
1607 
    args.orderType = orderType
94 ashish 1608 
    args.write(self._oprot)
1609 
    self._oprot.writeMessageEnd()
1610 
    self._oprot.trans.flush()
1611 
 
1612 
  def recv_changeTransactionStatus(self, ):
1613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1614 
    if mtype == TMessageType.EXCEPTION:
1615 
      x = TApplicationException()
1616 
      x.read(self._iprot)
1617 
      self._iprot.readMessageEnd()
1618 
      raise x
1619 
    result = changeTransactionStatus_result()
1620 
    result.read(self._iprot)
1621 
    self._iprot.readMessageEnd()
3431 rajveer 1622 
    if result.success is not None:
94 ashish 1623 
      return result.success
3431 rajveer 1624 
    if result.ex is not None:
94 ashish 1625 
      raise result.ex
1626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1627 
 
1398 varun.gupt 1628 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1629 
    """
1630 
    Parameters:
1631 
     - transactionId
1632 
    """
1398 varun.gupt 1633 
    self.send_enqueueTransactionInfoEmail(transactionId)
1634 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1635 
 
1398 varun.gupt 1636 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1637 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1638 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1639 
    args.transactionId = transactionId
1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1398 varun.gupt 1644 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1398 varun.gupt 1651 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
3431 rajveer 1654 
    if result.success is not None:
1382 varun.gupt 1655 
      return result.success
3431 rajveer 1656 
    if result.ex is not None:
1382 varun.gupt 1657 
      raise result.ex
1398 varun.gupt 1658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1659 
 
4801 anupam.sin 1660 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1661 
    """
1662 
    Parameters:
4801 anupam.sin 1663 
     - statuses
483 rajveer 1664 
     - from_date
1665 
     - to_date
1666 
     - warehouse_id
94 ashish 1667 
    """
4801 anupam.sin 1668 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1669 
    return self.recv_getAllOrders()
94 ashish 1670 
 
4801 anupam.sin 1671 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1672 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1673 
    args = getAllOrders_args()
4801 anupam.sin 1674 
    args.statuses = statuses
483 rajveer 1675 
    args.from_date = from_date
1676 
    args.to_date = to_date
1677 
    args.warehouse_id = warehouse_id
94 ashish 1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
483 rajveer 1682 
  def recv_getAllOrders(self, ):
94 ashish 1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
483 rajveer 1689 
    result = getAllOrders_result()
94 ashish 1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
3431 rajveer 1692 
    if result.success is not None:
94 ashish 1693 
      return result.success
3431 rajveer 1694 
    if result.ex is not None:
94 ashish 1695 
      raise result.ex
483 rajveer 1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1697 
 
4133 chandransh 1698 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1699 
    """
1700 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1701 
    Pass the status as null and the limit as 0 to ignore them.
1702 
 
1703 
    Parameters:
1704 
     - statuses
1705 
     - offset
1706 
     - limit
1707 
     - warehouse_id
1708 
    """
1709 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1710 
    return self.recv_getOrdersInBatch()
1711 
 
1712 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1713 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1714 
    args = getOrdersInBatch_args()
1715 
    args.statuses = statuses
1716 
    args.offset = offset
1717 
    args.limit = limit
1718 
    args.warehouse_id = warehouse_id
1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1723 
  def recv_getOrdersInBatch(self, ):
1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1730 
    result = getOrdersInBatch_result()
1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
1733 
    if result.success is not None:
1734 
      return result.success
1735 
    if result.ex is not None:
1736 
      raise result.ex
1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1738 
 
1739 
  def getOrderCount(self, statuses, warehouseId):
1740 
    """
1741 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1742 
 
1743 
    Parameters:
1744 
     - statuses
1745 
     - warehouseId
1746 
    """
1747 
    self.send_getOrderCount(statuses, warehouseId)
1748 
    return self.recv_getOrderCount()
1749 
 
1750 
  def send_getOrderCount(self, statuses, warehouseId):
1751 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1752 
    args = getOrderCount_args()
1753 
    args.statuses = statuses
1754 
    args.warehouseId = warehouseId
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_getOrderCount(self, ):
1760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1761 
    if mtype == TMessageType.EXCEPTION:
1762 
      x = TApplicationException()
1763 
      x.read(self._iprot)
1764 
      self._iprot.readMessageEnd()
1765 
      raise x
1766 
    result = getOrderCount_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
1769 
    if result.success is not None:
1770 
      return result.success
1771 
    if result.ex is not None:
1772 
      raise result.ex
1773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1774 
 
999 varun.gupt 1775 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1776 
    """
1132 chandransh 1777 
    Returns orders within a range of their billing dates
3431 rajveer 1778 
 
999 varun.gupt 1779 
    Parameters:
1780 
     - status
1781 
     - start_billing_date
1782 
     - end_billing_date
1783 
     - warehouse_id
1784 
    """
1785 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1786 
    return self.recv_getOrdersByBillingDate()
1787 
 
1788 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1789 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1790 
    args = getOrdersByBillingDate_args()
1791 
    args.status = status
1792 
    args.start_billing_date = start_billing_date
1793 
    args.end_billing_date = end_billing_date
1794 
    args.warehouse_id = warehouse_id
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_getOrdersByBillingDate(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = getOrdersByBillingDate_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
3431 rajveer 1809 
    if result.success is not None:
999 varun.gupt 1810 
      return result.success
3431 rajveer 1811 
    if result.ex is not None:
999 varun.gupt 1812 
      raise result.ex
1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1814 
 
3451 chandransh 1815 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1816 
    """
1817 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1818 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1819 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1820 
 
3427 chandransh 1821 
    Parameters:
1822 
     - fromShippingDate
1823 
     - toShippingDate
1824 
     - providerId
1825 
     - warehouseId
3451 chandransh 1826 
     - cod
3427 chandransh 1827 
    """
3451 chandransh 1828 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1829 
    return self.recv_getOrdersByShippingDate()
1830 
 
3451 chandransh 1831 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1832 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1833 
    args = getOrdersByShippingDate_args()
1834 
    args.fromShippingDate = fromShippingDate
1835 
    args.toShippingDate = toShippingDate
1836 
    args.providerId = providerId
1837 
    args.warehouseId = warehouseId
3451 chandransh 1838 
    args.cod = cod
3427 chandransh 1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_getOrdersByShippingDate(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = getOrdersByShippingDate_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
3431 rajveer 1853 
    if result.success is not None:
3427 chandransh 1854 
      return result.success
3431 rajveer 1855 
    if result.ex is not None:
3427 chandransh 1856 
      raise result.ex
1857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1858 
 
1382 varun.gupt 1859 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1860 
    """
1861 
    Returns order ids for orders which can be returned
3431 rajveer 1862 
 
1382 varun.gupt 1863 
    Parameters:
1864 
     - customer_id
1865 
     - limit
1866 
    """
1867 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1868 
    return self.recv_getReturnableOrdersForCustomer()
1869 
 
1870 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1871 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1872 
    args = getReturnableOrdersForCustomer_args()
1873 
    args.customer_id = customer_id
1874 
    args.limit = limit
1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_getReturnableOrdersForCustomer(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = getReturnableOrdersForCustomer_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
1382 varun.gupt 1890 
      return result.success
3431 rajveer 1891 
    if result.ex is not None:
1382 varun.gupt 1892 
      raise result.ex
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1894 
 
1895 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1896 
    """
1897 
    Returns order ids for orders which can be cancelled
3431 rajveer 1898 
 
1382 varun.gupt 1899 
    Parameters:
1900 
     - customer_id
1901 
     - limit
1902 
    """
1903 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1904 
    return self.recv_getCancellableOrdersForCustomer()
1905 
 
1906 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1907 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1908 
    args = getCancellableOrdersForCustomer_args()
1909 
    args.customer_id = customer_id
1910 
    args.limit = limit
1911 
    args.write(self._oprot)
1912 
    self._oprot.writeMessageEnd()
1913 
    self._oprot.trans.flush()
1914 
 
1915 
  def recv_getCancellableOrdersForCustomer(self, ):
1916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1917 
    if mtype == TMessageType.EXCEPTION:
1918 
      x = TApplicationException()
1919 
      x.read(self._iprot)
1920 
      self._iprot.readMessageEnd()
1921 
      raise x
1922 
    result = getCancellableOrdersForCustomer_result()
1923 
    result.read(self._iprot)
1924 
    self._iprot.readMessageEnd()
3431 rajveer 1925 
    if result.success is not None:
1382 varun.gupt 1926 
      return result.success
3431 rajveer 1927 
    if result.ex is not None:
1382 varun.gupt 1928 
      raise result.ex
1929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1930 
 
483 rajveer 1931 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1932 
    """
1933 
    Parameters:
483 rajveer 1934 
     - orderId
1935 
     - status
1936 
     - description
94 ashish 1937 
    """
483 rajveer 1938 
    self.send_changeOrderStatus(orderId, status, description)
1939 
    return self.recv_changeOrderStatus()
94 ashish 1940 
 
483 rajveer 1941 
  def send_changeOrderStatus(self, orderId, status, description):
1942 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1943 
    args = changeOrderStatus_args()
1944 
    args.orderId = orderId
1945 
    args.status = status
1946 
    args.description = description
94 ashish 1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
483 rajveer 1951 
  def recv_changeOrderStatus(self, ):
94 ashish 1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
483 rajveer 1958 
    result = changeOrderStatus_result()
94 ashish 1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
3431 rajveer 1961 
    if result.success is not None:
94 ashish 1962 
      return result.success
3431 rajveer 1963 
    if result.ex is not None:
94 ashish 1964 
      raise result.ex
483 rajveer 1965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1966 
 
1528 ankur.sing 1967 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1968 
    """
1528 ankur.sing 1969 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1970 
    only user who owns the transaction can view its order details.
3431 rajveer 1971 
 
94 ashish 1972 
    Parameters:
1973 
     - transactionId
1528 ankur.sing 1974 
     - customerId
94 ashish 1975 
    """
1528 ankur.sing 1976 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1977 
    return self.recv_getOrdersForTransaction()
94 ashish 1978 
 
1528 ankur.sing 1979 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1980 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1981 
    args = getOrdersForTransaction_args()
94 ashish 1982 
    args.transactionId = transactionId
1528 ankur.sing 1983 
    args.customerId = customerId
94 ashish 1984 
    args.write(self._oprot)
1985 
    self._oprot.writeMessageEnd()
1986 
    self._oprot.trans.flush()
1987 
 
483 rajveer 1988 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1990 
    if mtype == TMessageType.EXCEPTION:
1991 
      x = TApplicationException()
1992 
      x.read(self._iprot)
1993 
      self._iprot.readMessageEnd()
1994 
      raise x
483 rajveer 1995 
    result = getOrdersForTransaction_result()
94 ashish 1996 
    result.read(self._iprot)
1997 
    self._iprot.readMessageEnd()
3431 rajveer 1998 
    if result.success is not None:
94 ashish 1999 
      return result.success
3431 rajveer 2000 
    if result.ex is not None:
94 ashish 2001 
      raise result.ex
483 rajveer 2002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2003 
 
3014 chandransh 2004 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2005 
    """
3014 chandransh 2006 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2007 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2008 
 
94 ashish 2009 
    Parameters:
483 rajveer 2010 
     - customerId
2011 
     - from_date
2012 
     - to_date
3014 chandransh 2013 
     - statuses
94 ashish 2014 
    """
3014 chandransh 2015 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2016 
    return self.recv_getOrdersForCustomer()
94 ashish 2017 
 
3014 chandransh 2018 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2019 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2020 
    args = getOrdersForCustomer_args()
2021 
    args.customerId = customerId
2022 
    args.from_date = from_date
2023 
    args.to_date = to_date
3014 chandransh 2024 
    args.statuses = statuses
94 ashish 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
483 rajveer 2029 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
483 rajveer 2036 
    result = getOrdersForCustomer_result()
94 ashish 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
94 ashish 2040 
      return result.success
3431 rajveer 2041 
    if result.ex is not None:
94 ashish 2042 
      raise result.ex
483 rajveer 2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2044 
 
483 rajveer 2045 
  def createOrder(self, order):
94 ashish 2046 
    """
2047 
    Parameters:
483 rajveer 2048 
     - order
94 ashish 2049 
    """
483 rajveer 2050 
    self.send_createOrder(order)
2051 
    return self.recv_createOrder()
94 ashish 2052 
 
483 rajveer 2053 
  def send_createOrder(self, order):
2054 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2055 
    args = createOrder_args()
2056 
    args.order = order
94 ashish 2057 
    args.write(self._oprot)
2058 
    self._oprot.writeMessageEnd()
2059 
    self._oprot.trans.flush()
2060 
 
483 rajveer 2061 
  def recv_createOrder(self, ):
94 ashish 2062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2063 
    if mtype == TMessageType.EXCEPTION:
2064 
      x = TApplicationException()
2065 
      x.read(self._iprot)
2066 
      self._iprot.readMessageEnd()
2067 
      raise x
483 rajveer 2068 
    result = createOrder_result()
94 ashish 2069 
    result.read(self._iprot)
2070 
    self._iprot.readMessageEnd()
3431 rajveer 2071 
    if result.success is not None:
94 ashish 2072 
      return result.success
3431 rajveer 2073 
    if result.ex is not None:
94 ashish 2074 
      raise result.ex
483 rajveer 2075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2076 
 
483 rajveer 2077 
  def getOrder(self, id):
94 ashish 2078 
    """
2079 
    Parameters:
483 rajveer 2080 
     - id
94 ashish 2081 
    """
483 rajveer 2082 
    self.send_getOrder(id)
2083 
    return self.recv_getOrder()
94 ashish 2084 
 
483 rajveer 2085 
  def send_getOrder(self, id):
2086 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2087 
    args = getOrder_args()
2088 
    args.id = id
94 ashish 2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
483 rajveer 2093 
  def recv_getOrder(self, ):
94 ashish 2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
483 rajveer 2100 
    result = getOrder_result()
94 ashish 2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
3431 rajveer 2103 
    if result.success is not None:
94 ashish 2104 
      return result.success
3431 rajveer 2105 
    if result.ex is not None:
94 ashish 2106 
      raise result.ex
483 rajveer 2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2108 
 
483 rajveer 2109 
  def getLineItemsForOrder(self, orderId):
94 ashish 2110 
    """
2111 
    Parameters:
483 rajveer 2112 
     - orderId
94 ashish 2113 
    """
483 rajveer 2114 
    self.send_getLineItemsForOrder(orderId)
2115 
    return self.recv_getLineItemsForOrder()
94 ashish 2116 
 
483 rajveer 2117 
  def send_getLineItemsForOrder(self, orderId):
2118 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2119 
    args = getLineItemsForOrder_args()
2120 
    args.orderId = orderId
94 ashish 2121 
    args.write(self._oprot)
2122 
    self._oprot.writeMessageEnd()
2123 
    self._oprot.trans.flush()
2124 
 
483 rajveer 2125 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2127 
    if mtype == TMessageType.EXCEPTION:
2128 
      x = TApplicationException()
2129 
      x.read(self._iprot)
2130 
      self._iprot.readMessageEnd()
2131 
      raise x
483 rajveer 2132 
    result = getLineItemsForOrder_result()
94 ashish 2133 
    result.read(self._iprot)
2134 
    self._iprot.readMessageEnd()
3431 rajveer 2135 
    if result.success is not None:
94 ashish 2136 
      return result.success
3431 rajveer 2137 
    if result.ex is not None:
94 ashish 2138 
      raise result.ex
483 rajveer 2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2140 
 
4999 phani.kuma 2141 
  def getOrderList(self, order_ids):
2142 
    """
2143 
    Parameters:
2144 
     - order_ids
2145 
    """
2146 
    self.send_getOrderList(order_ids)
2147 
    return self.recv_getOrderList()
2148 
 
2149 
  def send_getOrderList(self, order_ids):
2150 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2151 
    args = getOrderList_args()
2152 
    args.order_ids = order_ids
2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_getOrderList(self, ):
2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
2164 
    result = getOrderList_result()
2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
2167 
    if result.success is not None:
2168 
      return result.success
2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2170 
 
5386 phani.kuma 2171 
  def getOrderListForVendor(self, order_ids, vendorId):
2172 
    """
2173 
    Parameters:
2174 
     - order_ids
2175 
     - vendorId
2176 
    """
2177 
    self.send_getOrderListForVendor(order_ids, vendorId)
2178 
    return self.recv_getOrderListForVendor()
2179 
 
2180 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2181 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2182 
    args = getOrderListForVendor_args()
2183 
    args.order_ids = order_ids
2184 
    args.vendorId = vendorId
2185 
    args.write(self._oprot)
2186 
    self._oprot.writeMessageEnd()
2187 
    self._oprot.trans.flush()
2188 
 
2189 
  def recv_getOrderListForVendor(self, ):
2190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2191 
    if mtype == TMessageType.EXCEPTION:
2192 
      x = TApplicationException()
2193 
      x.read(self._iprot)
2194 
      self._iprot.readMessageEnd()
2195 
      raise x
2196 
    result = getOrderListForVendor_result()
2197 
    result.read(self._iprot)
2198 
    self._iprot.readMessageEnd()
2199 
    if result.success is not None:
2200 
      return result.success
2201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2202 
 
1528 ankur.sing 2203 
  def getOrderForCustomer(self, orderId, customerId):
2204 
    """
2205 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2206 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2207 
 
1528 ankur.sing 2208 
    Parameters:
2209 
     - orderId
2210 
     - customerId
2211 
    """
2212 
    self.send_getOrderForCustomer(orderId, customerId)
2213 
    return self.recv_getOrderForCustomer()
2214 
 
2215 
  def send_getOrderForCustomer(self, orderId, customerId):
2216 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2217 
    args = getOrderForCustomer_args()
2218 
    args.orderId = orderId
2219 
    args.customerId = customerId
2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
2224 
  def recv_getOrderForCustomer(self, ):
2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
2231 
    result = getOrderForCustomer_result()
2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
3431 rajveer 2234 
    if result.success is not None:
1528 ankur.sing 2235 
      return result.success
3431 rajveer 2236 
    if result.ex is not None:
1528 ankur.sing 2237 
      raise result.ex
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2239 
 
4444 rajveer 2240 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2241 
    """
2242 
    Parameters:
4394 rajveer 2243 
     - type
4444 rajveer 2244 
     - warehouseId
4394 rajveer 2245 
     - status
2246 
     - timestamp
3064 chandransh 2247 
    """
4444 rajveer 2248 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2249 
    return self.recv_getAlerts()
2250 
 
4444 rajveer 2251 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2252 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2253 
    args = getAlerts_args()
4394 rajveer 2254 
    args.type = type
4444 rajveer 2255 
    args.warehouseId = warehouseId
4394 rajveer 2256 
    args.status = status
2257 
    args.timestamp = timestamp
3064 chandransh 2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_getAlerts(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = getAlerts_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
3431 rajveer 2272 
    if result.success is not None:
3064 chandransh 2273 
      return result.success
2274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2275 
 
4444 rajveer 2276 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2277 
    """
2278 
    Parameters:
2279 
     - type
4444 rajveer 2280 
     - warehouseId
4394 rajveer 2281 
     - description
3064 chandransh 2282 
    """
4444 rajveer 2283 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2284 
    self.recv_addAlert()
3064 chandransh 2285 
 
4444 rajveer 2286 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2287 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2288 
    args = addAlert_args()
3064 chandransh 2289 
    args.type = type
4444 rajveer 2290 
    args.warehouseId = warehouseId
4394 rajveer 2291 
    args.description = description
3064 chandransh 2292 
    args.write(self._oprot)
2293 
    self._oprot.writeMessageEnd()
2294 
    self._oprot.trans.flush()
2295 
 
4394 rajveer 2296 
  def recv_addAlert(self, ):
3064 chandransh 2297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2298 
    if mtype == TMessageType.EXCEPTION:
2299 
      x = TApplicationException()
2300 
      x.read(self._iprot)
2301 
      self._iprot.readMessageEnd()
2302 
      raise x
4394 rajveer 2303 
    result = addAlert_result()
3064 chandransh 2304 
    result.read(self._iprot)
2305 
    self._iprot.readMessageEnd()
2306 
    return
2307 
 
4444 rajveer 2308 
  def markAlertsAsSeen(self, warehouseId):
2309 
    """
2310 
    Parameters:
2311 
     - warehouseId
2312 
    """
2313 
    self.send_markAlertsAsSeen(warehouseId)
2314 
    self.recv_markAlertsAsSeen()
2315 
 
2316 
  def send_markAlertsAsSeen(self, warehouseId):
2317 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2318 
    args = markAlertsAsSeen_args()
2319 
    args.warehouseId = warehouseId
2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
2324 
  def recv_markAlertsAsSeen(self, ):
2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
2331 
    result = markAlertsAsSeen_result()
2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
2334 
    return
2335 
 
3064 chandransh 2336 
  def getValidOrderCount(self, ):
2337 
    """
2338 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2339 
    """
2340 
    self.send_getValidOrderCount()
2341 
    return self.recv_getValidOrderCount()
2342 
 
2343 
  def send_getValidOrderCount(self, ):
2344 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2345 
    args = getValidOrderCount_args()
2346 
    args.write(self._oprot)
2347 
    self._oprot.writeMessageEnd()
2348 
    self._oprot.trans.flush()
2349 
 
2350 
  def recv_getValidOrderCount(self, ):
2351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2352 
    if mtype == TMessageType.EXCEPTION:
2353 
      x = TApplicationException()
2354 
      x.read(self._iprot)
2355 
      self._iprot.readMessageEnd()
2356 
      raise x
2357 
    result = getValidOrderCount_result()
2358 
    result.read(self._iprot)
2359 
    self._iprot.readMessageEnd()
3431 rajveer 2360 
    if result.success is not None:
3064 chandransh 2361 
      return result.success
2362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2363 
 
2364 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2365 
    """
2366 
    Returns the number of distinct customers who have done successful transactions
2367 
    """
2368 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2369 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2370 
 
2371 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2372 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2373 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2374 
    args.write(self._oprot)
2375 
    self._oprot.writeMessageEnd()
2376 
    self._oprot.trans.flush()
2377 
 
2378 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2380 
    if mtype == TMessageType.EXCEPTION:
2381 
      x = TApplicationException()
2382 
      x.read(self._iprot)
2383 
      self._iprot.readMessageEnd()
2384 
      raise x
2385 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2386 
    result.read(self._iprot)
2387 
    self._iprot.readMessageEnd()
3431 rajveer 2388 
    if result.success is not None:
3064 chandransh 2389 
      return result.success
2390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2391 
 
2392 
  def getValidOrdersAmountRange(self, ):
2393 
    """
2394 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2395 
    List contains two values, first minimum amount and second maximum amount.
2396 
    """
2397 
    self.send_getValidOrdersAmountRange()
2398 
    return self.recv_getValidOrdersAmountRange()
2399 
 
2400 
  def send_getValidOrdersAmountRange(self, ):
2401 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2402 
    args = getValidOrdersAmountRange_args()
2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
2407 
  def recv_getValidOrdersAmountRange(self, ):
2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
2414 
    result = getValidOrdersAmountRange_result()
2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
3431 rajveer 2417 
    if result.success is not None:
3064 chandransh 2418 
      return result.success
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2420 
 
5874 rajveer 2421 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2422 
    """
2423 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2424 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2425 
 
3064 chandransh 2426 
    Parameters:
2427 
     - limit
5874 rajveer 2428 
     - onlyStore
3064 chandransh 2429 
    """
5874 rajveer 2430 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2431 
    return self.recv_getValidOrders()
2432 
 
5874 rajveer 2433 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2434 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2435 
    args = getValidOrders_args()
2436 
    args.limit = limit
5874 rajveer 2437 
    args.onlyStore = onlyStore
3064 chandransh 2438 
    args.write(self._oprot)
2439 
    self._oprot.writeMessageEnd()
2440 
    self._oprot.trans.flush()
2441 
 
2442 
  def recv_getValidOrders(self, ):
2443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2444 
    if mtype == TMessageType.EXCEPTION:
2445 
      x = TApplicationException()
2446 
      x.read(self._iprot)
2447 
      self._iprot.readMessageEnd()
2448 
      raise x
2449 
    result = getValidOrders_result()
2450 
    result.read(self._iprot)
2451 
    self._iprot.readMessageEnd()
3431 rajveer 2452 
    if result.success is not None:
3064 chandransh 2453 
      return result.success
2454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2455 
 
1220 chandransh 2456 
  def batchOrders(self, warehouseId):
2457 
    """
2458 
    Create a batch of all the pending orders for the given warehouse.
2459 
    The returned list is orderd by created_timestamp.
2460 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2461 
 
1220 chandransh 2462 
    Parameters:
2463 
     - warehouseId
2464 
    """
2465 
    self.send_batchOrders(warehouseId)
2466 
    return self.recv_batchOrders()
2467 
 
2468 
  def send_batchOrders(self, warehouseId):
2469 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2470 
    args = batchOrders_args()
2471 
    args.warehouseId = warehouseId
2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
2476 
  def recv_batchOrders(self, ):
2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
2483 
    result = batchOrders_result()
2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
3431 rajveer 2486 
    if result.success is not None:
1220 chandransh 2487 
      return result.success
3431 rajveer 2488 
    if result.ex is not None:
1220 chandransh 2489 
      raise result.ex
2490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2491 
 
1208 chandransh 2492 
  def markOrderAsOutOfStock(self, orderId):
2493 
    """
2494 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2495 
 
1208 chandransh 2496 
    Parameters:
2497 
     - orderId
2498 
    """
2499 
    self.send_markOrderAsOutOfStock(orderId)
2500 
    return self.recv_markOrderAsOutOfStock()
2501 
 
2502 
  def send_markOrderAsOutOfStock(self, orderId):
2503 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2504 
    args = markOrderAsOutOfStock_args()
2505 
    args.orderId = orderId
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_markOrderAsOutOfStock(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = markOrderAsOutOfStock_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
3431 rajveer 2520 
    if result.success is not None:
1208 chandransh 2521 
      return result.success
3431 rajveer 2522 
    if result.ex is not None:
1208 chandransh 2523 
      raise result.ex
2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2525 
 
3064 chandransh 2526 
  def verifyOrder(self, orderId):
759 chandransh 2527 
    """
3064 chandransh 2528 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2529 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2530 
    used for all other orders as well.
2531 
    Throws an exception if no such order exists.
3431 rajveer 2532 
 
759 chandransh 2533 
    Parameters:
3064 chandransh 2534 
     - orderId
759 chandransh 2535 
    """
3064 chandransh 2536 
    self.send_verifyOrder(orderId)
2537 
    return self.recv_verifyOrder()
759 chandransh 2538 
 
3064 chandransh 2539 
  def send_verifyOrder(self, orderId):
2540 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2541 
    args = verifyOrder_args()
2542 
    args.orderId = orderId
759 chandransh 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
3064 chandransh 2547 
  def recv_verifyOrder(self, ):
759 chandransh 2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
3064 chandransh 2554 
    result = verifyOrder_result()
759 chandransh 2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
3431 rajveer 2557 
    if result.success is not None:
759 chandransh 2558 
      return result.success
3431 rajveer 2559 
    if result.ex is not None:
759 chandransh 2560 
      raise result.ex
3064 chandransh 2561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2562 
 
3064 chandransh 2563 
  def acceptOrder(self, orderId):
1113 chandransh 2564 
    """
3064 chandransh 2565 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2566 
    given order is not a COD order, it also captures the payment if the same has
2567 
    not been captured.
2568 
    Throws an exception if no such order exists.
3431 rajveer 2569 
 
1113 chandransh 2570 
    Parameters:
3064 chandransh 2571 
     - orderId
1113 chandransh 2572 
    """
3064 chandransh 2573 
    self.send_acceptOrder(orderId)
2574 
    return self.recv_acceptOrder()
1113 chandransh 2575 
 
3064 chandransh 2576 
  def send_acceptOrder(self, orderId):
2577 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2578 
    args = acceptOrder_args()
2579 
    args.orderId = orderId
1113 chandransh 2580 
    args.write(self._oprot)
2581 
    self._oprot.writeMessageEnd()
2582 
    self._oprot.trans.flush()
2583 
 
3064 chandransh 2584 
  def recv_acceptOrder(self, ):
1113 chandransh 2585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2586 
    if mtype == TMessageType.EXCEPTION:
2587 
      x = TApplicationException()
2588 
      x.read(self._iprot)
2589 
      self._iprot.readMessageEnd()
2590 
      raise x
3064 chandransh 2591 
    result = acceptOrder_result()
1113 chandransh 2592 
    result.read(self._iprot)
2593 
    self._iprot.readMessageEnd()
3431 rajveer 2594 
    if result.success is not None:
1113 chandransh 2595 
      return result.success
3431 rajveer 2596 
    if result.ex is not None:
1113 chandransh 2597 
      raise result.ex
3064 chandransh 2598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2599 
 
5110 mandeep.dh 2600 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2601 
    """
3064 chandransh 2602 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2603 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2604 
    the IMEI no. if a -1 is supplied.
2605 
    Also, it generates an invoice number for the order, marks the order as
2606 
    BILLED and sets the billing timestamp.
2607 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2608 
 
1135 chandransh 2609 
    Parameters:
3064 chandransh 2610 
     - orderId
2611 
     - invoice_number
4658 mandeep.dh 2612 
     - serialNumber
4283 anupam.sin 2613 
     - itemNumber
3064 chandransh 2614 
     - billed_by
4264 rajveer 2615 
     - jacketNumber
4283 anupam.sin 2616 
     - billingType
5110 mandeep.dh 2617 
     - fulfilmentWarehouseId
4763 rajveer 2618 
     - authorize
1135 chandransh 2619 
    """
5110 mandeep.dh 2620 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2621 
    return self.recv_addBillingDetails()
1135 chandransh 2622 
 
5110 mandeep.dh 2623 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2624 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2625 
    args = addBillingDetails_args()
2626 
    args.orderId = orderId
2627 
    args.invoice_number = invoice_number
4658 mandeep.dh 2628 
    args.serialNumber = serialNumber
4283 anupam.sin 2629 
    args.itemNumber = itemNumber
3064 chandransh 2630 
    args.billed_by = billed_by
4264 rajveer 2631 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2632 
    args.billingType = billingType
5110 mandeep.dh 2633 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2634 
    args.authorize = authorize
1135 chandransh 2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
3064 chandransh 2639 
  def recv_addBillingDetails(self, ):
1135 chandransh 2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
3064 chandransh 2646 
    result = addBillingDetails_result()
1135 chandransh 2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.success is not None:
3064 chandransh 2650 
      return result.success
3431 rajveer 2651 
    if result.ex is not None:
1135 chandransh 2652 
      raise result.ex
3064 chandransh 2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2654 
 
4763 rajveer 2655 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2656 
    """
2657 
    Add the invoice number to the order.
2658 
 
2659 
    Parameters:
2660 
     - orderId
2661 
     - invoiceNumber
4763 rajveer 2662 
     - color
4579 rajveer 2663 
    """
4763 rajveer 2664 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2665 
    self.recv_addInvoiceNumber()
2666 
 
4763 rajveer 2667 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2668 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2669 
    args = addInvoiceNumber_args()
2670 
    args.orderId = orderId
2671 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2672 
    args.color = color
4579 rajveer 2673 
    args.write(self._oprot)
2674 
    self._oprot.writeMessageEnd()
2675 
    self._oprot.trans.flush()
2676 
 
2677 
  def recv_addInvoiceNumber(self, ):
2678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2679 
    if mtype == TMessageType.EXCEPTION:
2680 
      x = TApplicationException()
2681 
      x.read(self._iprot)
2682 
      self._iprot.readMessageEnd()
2683 
      raise x
2684 
    result = addInvoiceNumber_result()
2685 
    result.read(self._iprot)
2686 
    self._iprot.readMessageEnd()
2687 
    if result.ex is not None:
2688 
      raise result.ex
2689 
    return
2690 
 
4910 phani.kuma 2691 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2692 
    """
3064 chandransh 2693 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2694 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2695 
 
1408 ankur.sing 2696 
    Parameters:
3064 chandransh 2697 
     - warehouseId
1408 ankur.sing 2698 
     - providerId
3064 chandransh 2699 
     - cod
4910 phani.kuma 2700 
     - orderIds
1408 ankur.sing 2701 
    """
4910 phani.kuma 2702 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2703 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2704 
 
4910 phani.kuma 2705 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2706 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2707 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2708 
    args.warehouseId = warehouseId
1408 ankur.sing 2709 
    args.providerId = providerId
3064 chandransh 2710 
    args.cod = cod
4910 phani.kuma 2711 
    args.orderIds = orderIds
1408 ankur.sing 2712 
    args.write(self._oprot)
2713 
    self._oprot.writeMessageEnd()
2714 
    self._oprot.trans.flush()
2715 
 
4910 phani.kuma 2716 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2718 
    if mtype == TMessageType.EXCEPTION:
2719 
      x = TApplicationException()
2720 
      x.read(self._iprot)
2721 
      self._iprot.readMessageEnd()
2722 
      raise x
4910 phani.kuma 2723 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2724 
    result.read(self._iprot)
2725 
    self._iprot.readMessageEnd()
3431 rajveer 2726 
    if result.success is not None:
1408 ankur.sing 2727 
      return result.success
3431 rajveer 2728 
    if result.ex is not None:
3064 chandransh 2729 
      raise result.ex
4910 phani.kuma 2730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2731 
 
5713 rajveer 2732 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2733 
    """
2734 
    Parameters:
2735 
     - providerId
2736 
     - orderIds
5713 rajveer 2737 
     - awbs
5676 rajveer 2738 
    """
5713 rajveer 2739 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2740 
    return self.recv_markOrdersAsReturnedFromStore()
2741 
 
5713 rajveer 2742 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2743 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2744 
    args = markOrdersAsReturnedFromStore_args()
2745 
    args.providerId = providerId
2746 
    args.orderIds = orderIds
5713 rajveer 2747 
    args.awbs = awbs
5676 rajveer 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
2752 
  def recv_markOrdersAsReturnedFromStore(self, ):
2753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2754 
    if mtype == TMessageType.EXCEPTION:
2755 
      x = TApplicationException()
2756 
      x.read(self._iprot)
2757 
      self._iprot.readMessageEnd()
2758 
      raise x
2759 
    result = markOrdersAsReturnedFromStore_result()
2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
2762 
    if result.success is not None:
2763 
      return result.success
2764 
    if result.ex is not None:
2765 
      raise result.ex
2766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2767 
 
4910 phani.kuma 2768 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2769 
    """
4910 phani.kuma 2770 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2771 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2772 
 
2773 
    Parameters:
2774 
     - providerId
4910 phani.kuma 2775 
     - pickupDetails
4410 rajveer 2776 
    """
4910 phani.kuma 2777 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2778 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2779 
 
4910 phani.kuma 2780 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2781 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2782 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2783 
    args.providerId = providerId
4910 phani.kuma 2784 
    args.pickupDetails = pickupDetails
4410 rajveer 2785 
    args.write(self._oprot)
2786 
    self._oprot.writeMessageEnd()
2787 
    self._oprot.trans.flush()
2788 
 
4910 phani.kuma 2789 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2791 
    if mtype == TMessageType.EXCEPTION:
2792 
      x = TApplicationException()
2793 
      x.read(self._iprot)
2794 
      self._iprot.readMessageEnd()
2795 
      raise x
4910 phani.kuma 2796 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2797 
    result.read(self._iprot)
2798 
    self._iprot.readMessageEnd()
2799 
    if result.ex is not None:
2800 
      raise result.ex
4910 phani.kuma 2801 
    return
4410 rajveer 2802 
 
4910 phani.kuma 2803 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2804 
    """
3064 chandransh 2805 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2806 
 
94 ashish 2807 
    Parameters:
3064 chandransh 2808 
     - providerId
304 ashish 2809 
    """
4910 phani.kuma 2810 
    self.send_getOrdersNotPickedUp(providerId)
2811 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2812 
 
4910 phani.kuma 2813 
  def send_getOrdersNotPickedUp(self, providerId):
2814 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2815 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2816 
    args.providerId = providerId
304 ashish 2817 
    args.write(self._oprot)
2818 
    self._oprot.writeMessageEnd()
2819 
    self._oprot.trans.flush()
2820 
 
4910 phani.kuma 2821 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2823 
    if mtype == TMessageType.EXCEPTION:
2824 
      x = TApplicationException()
2825 
      x.read(self._iprot)
2826 
      self._iprot.readMessageEnd()
2827 
      raise x
4910 phani.kuma 2828 
    result = getOrdersNotPickedUp_result()
304 ashish 2829 
    result.read(self._iprot)
2830 
    self._iprot.readMessageEnd()
3431 rajveer 2831 
    if result.success is not None:
304 ashish 2832 
      return result.success
4910 phani.kuma 2833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2834 
 
3064 chandransh 2835 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2836 
    """
3064 chandransh 2837 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2838 
    the name of the receiver.
2839 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2840 
 
304 ashish 2841 
    Parameters:
3064 chandransh 2842 
     - providerId
2843 
     - deliveredOrders
304 ashish 2844 
    """
3064 chandransh 2845 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2846 
    self.recv_markOrdersAsDelivered()
304 ashish 2847 
 
3064 chandransh 2848 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2849 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2850 
    args = markOrdersAsDelivered_args()
2851 
    args.providerId = providerId
2852 
    args.deliveredOrders = deliveredOrders
304 ashish 2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
3064 chandransh 2857 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
3064 chandransh 2864 
    result = markOrdersAsDelivered_result()
304 ashish 2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
3431 rajveer 2867 
    if result.ex is not None:
3064 chandransh 2868 
      raise result.ex
304 ashish 2869 
    return
2870 
 
4910 phani.kuma 2871 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2872 
    """
4910 phani.kuma 2873 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2874 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2875 
 
3064 chandransh 2876 
    Parameters:
2877 
     - providerId
2878 
     - returnedOrders
1596 ankur.sing 2879 
    """
4910 phani.kuma 2880 
    self.send_markAsRTOrders(providerId, returnedOrders)
2881 
    self.recv_markAsRTOrders()
304 ashish 2882 
 
4910 phani.kuma 2883 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2884 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2885 
    args = markAsRTOrders_args()
3064 chandransh 2886 
    args.providerId = providerId
2887 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2888 
    args.write(self._oprot)
2889 
    self._oprot.writeMessageEnd()
2890 
    self._oprot.trans.flush()
2891 
 
4910 phani.kuma 2892 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2894 
    if mtype == TMessageType.EXCEPTION:
2895 
      x = TApplicationException()
2896 
      x.read(self._iprot)
2897 
      self._iprot.readMessageEnd()
2898 
      raise x
4910 phani.kuma 2899 
    result = markAsRTOrders_result()
1596 ankur.sing 2900 
    result.read(self._iprot)
2901 
    self._iprot.readMessageEnd()
3431 rajveer 2902 
    if result.ex is not None:
3064 chandransh 2903 
      raise result.ex
2904 
    return
1596 ankur.sing 2905 
 
4910 phani.kuma 2906 
  def getRTOrders(self, providerId):
2907 
    """
2908 
    Returns a list of orders that were returned by courier.
2909 
 
2910 
    Parameters:
2911 
     - providerId
2912 
    """
2913 
    self.send_getRTOrders(providerId)
2914 
    return self.recv_getRTOrders()
2915 
 
2916 
  def send_getRTOrders(self, providerId):
2917 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2918 
    args = getRTOrders_args()
2919 
    args.providerId = providerId
2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2924 
  def recv_getRTOrders(self, ):
2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2931 
    result = getRTOrders_result()
2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    if result.success is not None:
2935 
      return result.success
2936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2937 
 
3064 chandransh 2938 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2939 
    """
3064 chandransh 2940 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2941 
 
3064 chandransh 2942 
    Parameters:
2943 
     - providerId
2944 
     - undeliveredOrders
1627 ankur.sing 2945 
    """
3064 chandransh 2946 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2947 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2948 
 
3064 chandransh 2949 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2950 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2951 
    args = updateNonDeliveryReason_args()
2952 
    args.providerId = providerId
2953 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
3064 chandransh 2958 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
3064 chandransh 2965 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
4910 phani.kuma 2968 
    if result.ex is not None:
2969 
      raise result.ex
2970 
    return
2971 
 
2972 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2973 
    """
2974 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2975 
 
2976 
    Parameters:
2977 
     - providerId
2978 
    """
2979 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2980 
    return self.recv_getNonDeliveredOrdersbyCourier()
2981 
 
2982 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2983 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2984 
    args = getNonDeliveredOrdersbyCourier_args()
2985 
    args.providerId = providerId
2986 
    args.write(self._oprot)
2987 
    self._oprot.writeMessageEnd()
2988 
    self._oprot.trans.flush()
2989 
 
2990 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2992 
    if mtype == TMessageType.EXCEPTION:
2993 
      x = TApplicationException()
2994 
      x.read(self._iprot)
2995 
      self._iprot.readMessageEnd()
2996 
      raise x
2997 
    result = getNonDeliveredOrdersbyCourier_result()
2998 
    result.read(self._iprot)
2999 
    self._iprot.readMessageEnd()
4581 phani.kuma 3000 
    if result.success is not None:
3001 
      return result.success
4910 phani.kuma 3002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3003 
 
3004 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3005 
    """
3006 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3007 
 
3008 
    Parameters:
3009 
     - providerId
3010 
     - local_connected_orders
3011 
    """
3012 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3013 
    self.recv_markOrdersAsLocalConnected()
3014 
 
3015 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3016 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3017 
    args = markOrdersAsLocalConnected_args()
3018 
    args.providerId = providerId
3019 
    args.local_connected_orders = local_connected_orders
3020 
    args.write(self._oprot)
3021 
    self._oprot.writeMessageEnd()
3022 
    self._oprot.trans.flush()
3023 
 
3024 
  def recv_markOrdersAsLocalConnected(self, ):
3025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3026 
    if mtype == TMessageType.EXCEPTION:
3027 
      x = TApplicationException()
3028 
      x.read(self._iprot)
3029 
      self._iprot.readMessageEnd()
3030 
      raise x
3031 
    result = markOrdersAsLocalConnected_result()
3032 
    result.read(self._iprot)
3033 
    self._iprot.readMessageEnd()
3431 rajveer 3034 
    if result.ex is not None:
3064 chandransh 3035 
      raise result.ex
4910 phani.kuma 3036 
    return
1627 ankur.sing 3037 
 
4910 phani.kuma 3038 
  def getOrdersNotLocalConnected(self, providerId):
3039 
    """
3040 
    Returns a list of orders that were picked up or shipped but pending local connection.
3041 
 
3042 
    Parameters:
3043 
     - providerId
3044 
    """
3045 
    self.send_getOrdersNotLocalConnected(providerId)
3046 
    return self.recv_getOrdersNotLocalConnected()
3047 
 
3048 
  def send_getOrdersNotLocalConnected(self, providerId):
3049 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3050 
    args = getOrdersNotLocalConnected_args()
3051 
    args.providerId = providerId
3052 
    args.write(self._oprot)
3053 
    self._oprot.writeMessageEnd()
3054 
    self._oprot.trans.flush()
3055 
 
3056 
  def recv_getOrdersNotLocalConnected(self, ):
3057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3058 
    if mtype == TMessageType.EXCEPTION:
3059 
      x = TApplicationException()
3060 
      x.read(self._iprot)
3061 
      self._iprot.readMessageEnd()
3062 
      raise x
3063 
    result = getOrdersNotLocalConnected_result()
3064 
    result.read(self._iprot)
3065 
    self._iprot.readMessageEnd()
3066 
    if result.success is not None:
3067 
      return result.success
3068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3069 
 
3070 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3071 
    """
3072 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3073 
 
3074 
    Parameters:
3075 
     - providerId
3076 
     - destination_city_reached_orders
3077 
    """
3078 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3079 
    self.recv_markOrdersAsDestinationCityReached()
3080 
 
3081 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3082 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3083 
    args = markOrdersAsDestinationCityReached_args()
3084 
    args.providerId = providerId
3085 
    args.destination_city_reached_orders = destination_city_reached_orders
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
3090 
  def recv_markOrdersAsDestinationCityReached(self, ):
3091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3092 
    if mtype == TMessageType.EXCEPTION:
3093 
      x = TApplicationException()
3094 
      x.read(self._iprot)
3095 
      self._iprot.readMessageEnd()
3096 
      raise x
3097 
    result = markOrdersAsDestinationCityReached_result()
3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    if result.ex is not None:
3101 
      raise result.ex
3102 
    return
3103 
 
3104 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3105 
    """
3106 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3107 
 
3108 
    Parameters:
3109 
     - providerId
3110 
     - first_atdl_orders
3111 
    """
3112 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3113 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3114 
 
3115 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3116 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3117 
    args = markOrdersAsFirstDeliveryAttempted_args()
3118 
    args.providerId = providerId
3119 
    args.first_atdl_orders = first_atdl_orders
3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = markOrdersAsFirstDeliveryAttempted_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3134 
    if result.ex is not None:
3135 
      raise result.ex
3136 
    return
3137 
 
3064 chandransh 3138 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3139 
    """
3064 chandransh 3140 
    Returns the list of orders whose delivery time has passed but have not been
3141 
    delivered yet for the given provider and warehouse. To get a complete list of
3142 
    undelivered orders, pass them as -1.
3143 
    Returns an empty list if no such orders exist.
3431 rajveer 3144 
 
1886 ankur.sing 3145 
    Parameters:
3064 chandransh 3146 
     - providerId
3147 
     - warehouseId
1886 ankur.sing 3148 
    """
3064 chandransh 3149 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3150 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3151 
 
3064 chandransh 3152 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3153 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3154 
    args = getUndeliveredOrders_args()
3155 
    args.providerId = providerId
3156 
    args.warehouseId = warehouseId
1886 ankur.sing 3157 
    args.write(self._oprot)
3158 
    self._oprot.writeMessageEnd()
3159 
    self._oprot.trans.flush()
3160 
 
3064 chandransh 3161 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3163 
    if mtype == TMessageType.EXCEPTION:
3164 
      x = TApplicationException()
3165 
      x.read(self._iprot)
3166 
      self._iprot.readMessageEnd()
3167 
      raise x
3064 chandransh 3168 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3169 
    result.read(self._iprot)
3170 
    self._iprot.readMessageEnd()
3431 rajveer 3171 
    if result.success is not None:
1886 ankur.sing 3172 
      return result.success
3064 chandransh 3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3174 
 
4783 phani.kuma 3175 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3176 
    """
3177 
    Returns the list of orders whose expected delivery date has passed but have not been
3178 
    delivered yet.
3179 
    Returns an empty list if no such orders exist.
3180 
    """
3181 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3182 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3183 
 
3184 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3185 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3186 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3187 
    args.write(self._oprot)
3188 
    self._oprot.writeMessageEnd()
3189 
    self._oprot.trans.flush()
3190 
 
3191 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3193 
    if mtype == TMessageType.EXCEPTION:
3194 
      x = TApplicationException()
3195 
      x.read(self._iprot)
3196 
      self._iprot.readMessageEnd()
3197 
      raise x
3198 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3199 
    result.read(self._iprot)
3200 
    self._iprot.readMessageEnd()
3201 
    if result.success is not None:
3202 
      return result.success
3203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3204 
 
2536 chandransh 3205 
  def toggleDOAFlag(self, orderId):
3206 
    """
3207 
    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.
3208 
    Returns the final flag status.
3209 
    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 3210 
 
2536 chandransh 3211 
    Parameters:
3212 
     - orderId
3213 
    """
3214 
    self.send_toggleDOAFlag(orderId)
3215 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3216 
 
2536 chandransh 3217 
  def send_toggleDOAFlag(self, orderId):
3218 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3219 
    args = toggleDOAFlag_args()
3220 
    args.orderId = orderId
3221 
    args.write(self._oprot)
3222 
    self._oprot.writeMessageEnd()
3223 
    self._oprot.trans.flush()
3224 
 
3225 
  def recv_toggleDOAFlag(self, ):
3226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3227 
    if mtype == TMessageType.EXCEPTION:
3228 
      x = TApplicationException()
3229 
      x.read(self._iprot)
3230 
      self._iprot.readMessageEnd()
3231 
      raise x
3232 
    result = toggleDOAFlag_result()
3233 
    result.read(self._iprot)
3234 
    self._iprot.readMessageEnd()
3431 rajveer 3235 
    if result.success is not None:
2536 chandransh 3236 
      return result.success
3431 rajveer 3237 
    if result.ex is not None:
2536 chandransh 3238 
      raise result.ex
3239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3240 
 
4712 rajveer 3241 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3242 
    """
3243 
    Parameters:
3244 
     - orderId
3245 
     - deliveryTimestamp
3246 
     - receiver
3247 
    """
3248 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3249 
    self.recv_markOrderAsDelivered()
3250 
 
3251 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3252 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3253 
    args = markOrderAsDelivered_args()
3254 
    args.orderId = orderId
3255 
    args.deliveryTimestamp = deliveryTimestamp
3256 
    args.receiver = receiver
3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_markOrderAsDelivered(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = markOrderAsDelivered_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3271 
    if result.ex is not None:
3272 
      raise result.ex
3273 
    return
3274 
 
5553 rajveer 3275 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3276 
    """
3277 
    Parameters:
3278 
     - orderId
3279 
     - deliveryTimestamp
3280 
    """
3281 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3282 
    self.recv_markOrderAsReceivedAtStore()
3283 
 
3284 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3285 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3286 
    args = markOrderAsReceivedAtStore_args()
3287 
    args.orderId = orderId
3288 
    args.deliveryTimestamp = deliveryTimestamp
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_markOrderAsReceivedAtStore(self, ):
3294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3295 
    if mtype == TMessageType.EXCEPTION:
3296 
      x = TApplicationException()
3297 
      x.read(self._iprot)
3298 
      self._iprot.readMessageEnd()
3299 
      raise x
3300 
    result = markOrderAsReceivedAtStore_result()
3301 
    result.read(self._iprot)
3302 
    self._iprot.readMessageEnd()
3303 
    if result.ex is not None:
3304 
      raise result.ex
3305 
    return
3306 
 
4454 rajveer 3307 
  def markOrderDoaRequestReceived(self, orderId):
3308 
    """
3309 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3310 
 
3311 
    Parameters:
3312 
     - orderId
3313 
    """
3314 
    self.send_markOrderDoaRequestReceived(orderId)
3315 
    return self.recv_markOrderDoaRequestReceived()
3316 
 
3317 
  def send_markOrderDoaRequestReceived(self, orderId):
3318 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3319 
    args = markOrderDoaRequestReceived_args()
3320 
    args.orderId = orderId
3321 
    args.write(self._oprot)
3322 
    self._oprot.writeMessageEnd()
3323 
    self._oprot.trans.flush()
3324 
 
3325 
  def recv_markOrderDoaRequestReceived(self, ):
3326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3327 
    if mtype == TMessageType.EXCEPTION:
3328 
      x = TApplicationException()
3329 
      x.read(self._iprot)
3330 
      self._iprot.readMessageEnd()
3331 
      raise x
3332 
    result = markOrderDoaRequestReceived_result()
3333 
    result.read(self._iprot)
3334 
    self._iprot.readMessageEnd()
3335 
    if result.success is not None:
3336 
      return result.success
3337 
    if result.ex is not None:
3338 
      raise result.ex
3339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3340 
 
3341 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3342 
    """
3343 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3344 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3345 
 
3346 
    Parameters:
3347 
     - orderId
3348 
     - isAuthorized
3349 
    """
3350 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3351 
    return self.recv_markOrderDoaRequestAuthorized()
3352 
 
3353 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3354 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3355 
    args = markOrderDoaRequestAuthorized_args()
3356 
    args.orderId = orderId
3357 
    args.isAuthorized = isAuthorized
3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
3362 
  def recv_markOrderDoaRequestAuthorized(self, ):
3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
3369 
    result = markOrderDoaRequestAuthorized_result()
3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3372 
    if result.success is not None:
3373 
      return result.success
3374 
    if result.ex is not None:
3375 
      raise result.ex
3376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3377 
 
4488 rajveer 3378 
  def markOrderReturnRequestReceived(self, orderId):
3379 
    """
3380 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3381 
 
3382 
    Parameters:
3383 
     - orderId
3384 
    """
3385 
    self.send_markOrderReturnRequestReceived(orderId)
3386 
    return self.recv_markOrderReturnRequestReceived()
3387 
 
3388 
  def send_markOrderReturnRequestReceived(self, orderId):
3389 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3390 
    args = markOrderReturnRequestReceived_args()
3391 
    args.orderId = orderId
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_markOrderReturnRequestReceived(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = markOrderReturnRequestReceived_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.success is not None:
3407 
      return result.success
3408 
    if result.ex is not None:
3409 
      raise result.ex
3410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3411 
 
3412 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3413 
    """
3414 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3415 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3416 
 
3417 
    Parameters:
3418 
     - orderId
3419 
     - isAuthorized
3420 
    """
3421 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3422 
    return self.recv_markOrderReturnRequestAuthorized()
3423 
 
3424 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3425 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3426 
    args = markOrderReturnRequestAuthorized_args()
3427 
    args.orderId = orderId
3428 
    args.isAuthorized = isAuthorized
3429 
    args.write(self._oprot)
3430 
    self._oprot.writeMessageEnd()
3431 
    self._oprot.trans.flush()
3432 
 
3433 
  def recv_markOrderReturnRequestAuthorized(self, ):
3434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3435 
    if mtype == TMessageType.EXCEPTION:
3436 
      x = TApplicationException()
3437 
      x.read(self._iprot)
3438 
      self._iprot.readMessageEnd()
3439 
      raise x
3440 
    result = markOrderReturnRequestAuthorized_result()
3441 
    result.read(self._iprot)
3442 
    self._iprot.readMessageEnd()
3443 
    if result.success is not None:
3444 
      return result.success
3445 
    if result.ex is not None:
3446 
      raise result.ex
3447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3448 
 
4579 rajveer 3449 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3450 
    """
3451 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3452 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3453 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3454 
    For any other status, it returns false.
3455 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3456 
 
2536 chandransh 3457 
    Parameters:
3458 
     - orderId
4579 rajveer 3459 
     - providerId
2536 chandransh 3460 
    """
4579 rajveer 3461 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3462 
    return self.recv_requestPickupNumber()
3463 
 
4579 rajveer 3464 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3465 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3466 
    args = requestPickupNumber_args()
3467 
    args.orderId = orderId
4579 rajveer 3468 
    args.providerId = providerId
2536 chandransh 3469 
    args.write(self._oprot)
3470 
    self._oprot.writeMessageEnd()
3471 
    self._oprot.trans.flush()
3472 
 
3473 
  def recv_requestPickupNumber(self, ):
3474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3475 
    if mtype == TMessageType.EXCEPTION:
3476 
      x = TApplicationException()
3477 
      x.read(self._iprot)
3478 
      self._iprot.readMessageEnd()
3479 
      raise x
3480 
    result = requestPickupNumber_result()
3481 
    result.read(self._iprot)
3482 
    self._iprot.readMessageEnd()
3431 rajveer 3483 
    if result.success is not None:
2536 chandransh 3484 
      return result.success
3431 rajveer 3485 
    if result.ex is not None:
2536 chandransh 3486 
      raise result.ex
3487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3488 
 
4602 rajveer 3489 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3490 
    """
4452 rajveer 3491 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3492 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3493 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3494 
    	3. Returns true
2591 chandransh 3495 
    If the order is in any other status, it returns false.
2536 chandransh 3496 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3497 
 
2536 chandransh 3498 
    Parameters:
3499 
     - orderId
3500 
     - pickupNumber
4602 rajveer 3501 
     - providerId
2536 chandransh 3502 
    """
4602 rajveer 3503 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3504 
    return self.recv_authorizePickup()
3505 
 
4602 rajveer 3506 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3507 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3508 
    args = authorizePickup_args()
3509 
    args.orderId = orderId
3510 
    args.pickupNumber = pickupNumber
4602 rajveer 3511 
    args.providerId = providerId
2536 chandransh 3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_authorizePickup(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = authorizePickup_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3431 rajveer 3526 
    if result.success is not None:
2536 chandransh 3527 
      return result.success
3431 rajveer 3528 
    if result.ex is not None:
2536 chandransh 3529 
      raise result.ex
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3531 
 
2764 chandransh 3532 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3533 
    """
3534 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3535 
 
2764 chandransh 3536 
    Parameters:
3537 
     - providerId
3538 
     - pickupDetails
3539 
    """
3540 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3541 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3542 
 
3543 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3544 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3545 
    args = markDoasAsPickedUp_args()
3546 
    args.providerId = providerId
3547 
    args.pickupDetails = pickupDetails
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_markDoasAsPickedUp(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = markDoasAsPickedUp_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
4910 phani.kuma 3562 
    return
3563 
 
3564 
  def getDoasNotPickedUp(self, providerId):
3565 
    """
3566 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3567 
 
3568 
    Parameters:
3569 
     - providerId
3570 
    """
3571 
    self.send_getDoasNotPickedUp(providerId)
3572 
    return self.recv_getDoasNotPickedUp()
3573 
 
3574 
  def send_getDoasNotPickedUp(self, providerId):
3575 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3576 
    args = getDoasNotPickedUp_args()
3577 
    args.providerId = providerId
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_getDoasNotPickedUp(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = getDoasNotPickedUp_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3431 rajveer 3592 
    if result.success is not None:
2764 chandransh 3593 
      return result.success
4910 phani.kuma 3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3595 
 
4741 phani.kuma 3596 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3597 
    """
3598 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3599 
 
3600 
    Parameters:
3601 
     - providerId
3602 
     - pickupDetails
3603 
    """
3604 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3605 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3606 
 
3607 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3608 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3609 
    args = markReturnOrdersAsPickedUp_args()
3610 
    args.providerId = providerId
3611 
    args.pickupDetails = pickupDetails
3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_markReturnOrdersAsPickedUp(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = markReturnOrdersAsPickedUp_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
4910 phani.kuma 3626 
    return
3627 
 
3628 
  def getReturnOrdersNotPickedUp(self, providerId):
3629 
    """
3630 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3631 
 
3632 
    Parameters:
3633 
     - providerId
3634 
    """
3635 
    self.send_getReturnOrdersNotPickedUp(providerId)
3636 
    return self.recv_getReturnOrdersNotPickedUp()
3637 
 
3638 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3639 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3640 
    args = getReturnOrdersNotPickedUp_args()
3641 
    args.providerId = providerId
3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
3646 
  def recv_getReturnOrdersNotPickedUp(self, ):
3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
3653 
    result = getReturnOrdersNotPickedUp_result()
3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
4741 phani.kuma 3656 
    if result.success is not None:
3657 
      return result.success
4910 phani.kuma 3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3659 
 
4479 rajveer 3660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3661 
    """
4452 rajveer 3662 
    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 3663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3664 
    If the order is in any other state, it returns false.
3665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3666 
 
2591 chandransh 3667 
    Parameters:
3668 
     - orderId
4479 rajveer 3669 
     - receiveCondition
2591 chandransh 3670 
    """
4479 rajveer 3671 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3672 
    return self.recv_receiveReturn()
2536 chandransh 3673 
 
4479 rajveer 3674 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3675 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3676 
    args = receiveReturn_args()
2591 chandransh 3677 
    args.orderId = orderId
4479 rajveer 3678 
    args.receiveCondition = receiveCondition
2591 chandransh 3679 
    args.write(self._oprot)
3680 
    self._oprot.writeMessageEnd()
3681 
    self._oprot.trans.flush()
3682 
 
2616 chandransh 3683 
  def recv_receiveReturn(self, ):
2591 chandransh 3684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3685 
    if mtype == TMessageType.EXCEPTION:
3686 
      x = TApplicationException()
3687 
      x.read(self._iprot)
3688 
      self._iprot.readMessageEnd()
3689 
      raise x
2616 chandransh 3690 
    result = receiveReturn_result()
2591 chandransh 3691 
    result.read(self._iprot)
3692 
    self._iprot.readMessageEnd()
3431 rajveer 3693 
    if result.success is not None:
2591 chandransh 3694 
      return result.success
3431 rajveer 3695 
    if result.ex is not None:
2591 chandransh 3696 
      raise result.ex
2616 chandransh 3697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3698 
 
3699 
  def validateDoa(self, orderId, isValid):
3700 
    """
4452 rajveer 3701 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3702 
    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 3703 
    If the order is in any other state, it returns false.
3704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3705 
 
2591 chandransh 3706 
    Parameters:
3707 
     - orderId
3708 
     - isValid
3709 
    """
3710 
    self.send_validateDoa(orderId, isValid)
3711 
    return self.recv_validateDoa()
3712 
 
3713 
  def send_validateDoa(self, orderId, isValid):
3714 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3715 
    args = validateDoa_args()
3716 
    args.orderId = orderId
3717 
    args.isValid = isValid
3718 
    args.write(self._oprot)
3719 
    self._oprot.writeMessageEnd()
3720 
    self._oprot.trans.flush()
3721 
 
3722 
  def recv_validateDoa(self, ):
3723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3724 
    if mtype == TMessageType.EXCEPTION:
3725 
      x = TApplicationException()
3726 
      x.read(self._iprot)
3727 
      self._iprot.readMessageEnd()
3728 
      raise x
3729 
    result = validateDoa_result()
3730 
    result.read(self._iprot)
3731 
    self._iprot.readMessageEnd()
3431 rajveer 3732 
    if result.success is not None:
2591 chandransh 3733 
      return result.success
3431 rajveer 3734 
    if result.ex is not None:
2591 chandransh 3735 
      raise result.ex
3736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3737 
 
4495 rajveer 3738 
  def validateReturnProduct(self, orderId, isUsable):
3739 
    """
3740 
    Parameters:
3741 
     - orderId
3742 
     - isUsable
3743 
    """
3744 
    self.send_validateReturnProduct(orderId, isUsable)
3745 
    return self.recv_validateReturnProduct()
3746 
 
3747 
  def send_validateReturnProduct(self, orderId, isUsable):
3748 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3749 
    args = validateReturnProduct_args()
3750 
    args.orderId = orderId
3751 
    args.isUsable = isUsable
3752 
    args.write(self._oprot)
3753 
    self._oprot.writeMessageEnd()
3754 
    self._oprot.trans.flush()
3755 
 
3756 
  def recv_validateReturnProduct(self, ):
3757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3758 
    if mtype == TMessageType.EXCEPTION:
3759 
      x = TApplicationException()
3760 
      x.read(self._iprot)
3761 
      self._iprot.readMessageEnd()
3762 
      raise x
3763 
    result = validateReturnProduct_result()
3764 
    result.read(self._iprot)
3765 
    self._iprot.readMessageEnd()
3766 
    if result.success is not None:
3767 
      return result.success
3768 
    if result.ex is not None:
3769 
      raise result.ex
3770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3771 
 
2616 chandransh 3772 
  def reshipOrder(self, orderId):
3773 
    """
4484 rajveer 3774 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3775 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3776 
    	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 3777 
 
3778 
    If the order is in DOA_CERT_VALID state, it does the following:
3779 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3780 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3781 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3782 
 
2616 chandransh 3783 
    Returns the id of the newly created order.
3431 rajveer 3784 
 
2616 chandransh 3785 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3786 
 
2616 chandransh 3787 
    Parameters:
3788 
     - orderId
3789 
    """
3790 
    self.send_reshipOrder(orderId)
3791 
    return self.recv_reshipOrder()
2591 chandransh 3792 
 
2616 chandransh 3793 
  def send_reshipOrder(self, orderId):
3794 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3795 
    args = reshipOrder_args()
3796 
    args.orderId = orderId
3797 
    args.write(self._oprot)
3798 
    self._oprot.writeMessageEnd()
3799 
    self._oprot.trans.flush()
3800 
 
3801 
  def recv_reshipOrder(self, ):
3802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3803 
    if mtype == TMessageType.EXCEPTION:
3804 
      x = TApplicationException()
3805 
      x.read(self._iprot)
3806 
      self._iprot.readMessageEnd()
3807 
      raise x
3808 
    result = reshipOrder_result()
3809 
    result.read(self._iprot)
3810 
    self._iprot.readMessageEnd()
3431 rajveer 3811 
    if result.success is not None:
2616 chandransh 3812 
      return result.success
3431 rajveer 3813 
    if result.ex is not None:
2616 chandransh 3814 
      raise result.ex
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3816 
 
3226 chandransh 3817 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3818 
    """
4484 rajveer 3819 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3820 
    	1. Creates a refund request for batch processing.
3821 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3822 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3823 
 
2616 chandransh 3824 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3825 
    	1. Creates a refund request for batch processing.
3226 chandransh 3826 
    	2. Cancels the reservation of the item in the warehouse.
3827 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3828 
 
3226 chandransh 3829 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3830 
    	1. Cancels the reservation of the item in the warehouse.
3831 
    	2. Marks the current order as CANCELED.
3832 
 
3833 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3834 
 
2616 chandransh 3835 
    Returns True if it is successful, False otherwise.
3431 rajveer 3836 
 
2616 chandransh 3837 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3838 
 
2616 chandransh 3839 
    Parameters:
3840 
     - orderId
3226 chandransh 3841 
     - refundedBy
3842 
     - reason
2616 chandransh 3843 
    """
3226 chandransh 3844 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3845 
    return self.recv_refundOrder()
3846 
 
3226 chandransh 3847 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3848 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3849 
    args = refundOrder_args()
3850 
    args.orderId = orderId
3226 chandransh 3851 
    args.refundedBy = refundedBy
3852 
    args.reason = reason
2616 chandransh 3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_refundOrder(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = refundOrder_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3431 rajveer 3867 
    if result.success is not None:
2616 chandransh 3868 
      return result.success
3431 rajveer 3869 
    if result.ex is not None:
2616 chandransh 3870 
      raise result.ex
3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3872 
 
2690 chandransh 3873 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3874 
    """
3875 
    Get all return orders created between the from and to dates for the given warehouse.
3876 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3877 
 
2690 chandransh 3878 
    Parameters:
3879 
     - warehouseId
3880 
     - fromDate
3881 
     - toDate
3882 
    """
3883 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3884 
    return self.recv_getReturnOrders()
2616 chandransh 3885 
 
2690 chandransh 3886 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3887 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3888 
    args = getReturnOrders_args()
3889 
    args.warehouseId = warehouseId
3890 
    args.fromDate = fromDate
3891 
    args.toDate = toDate
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_getReturnOrders(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = getReturnOrders_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3431 rajveer 3906 
    if result.success is not None:
2690 chandransh 3907 
      return result.success
3908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3909 
 
5481 phani.kuma 3910 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3911 
    """
3912 
    Get all return orders created between the from and to dates.
3913 
 
3914 
    Parameters:
3915 
     - onlyNotProcessed
3916 
     - fromDate
3917 
     - toDate
3918 
    """
3919 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3920 
    return self.recv_getAllReturnOrders()
3921 
 
3922 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3923 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3924 
    args = getAllReturnOrders_args()
3925 
    args.onlyNotProcessed = onlyNotProcessed
3926 
    args.fromDate = fromDate
3927 
    args.toDate = toDate
3928 
    args.write(self._oprot)
3929 
    self._oprot.writeMessageEnd()
3930 
    self._oprot.trans.flush()
3931 
 
3932 
  def recv_getAllReturnOrders(self, ):
3933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3934 
    if mtype == TMessageType.EXCEPTION:
3935 
      x = TApplicationException()
3936 
      x.read(self._iprot)
3937 
      self._iprot.readMessageEnd()
3938 
      raise x
3939 
    result = getAllReturnOrders_result()
3940 
    result.read(self._iprot)
3941 
    self._iprot.readMessageEnd()
3942 
    if result.success is not None:
3943 
      return result.success
3944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3945 
 
2700 chandransh 3946 
  def getReturnOrder(self, id):
3947 
    """
3948 
    Returns the ReturnOrder corresponding to the given id.
3949 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3950 
 
2700 chandransh 3951 
    Parameters:
3952 
     - id
3953 
    """
3954 
    self.send_getReturnOrder(id)
3955 
    return self.recv_getReturnOrder()
3956 
 
3957 
  def send_getReturnOrder(self, id):
3958 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3959 
    args = getReturnOrder_args()
3960 
    args.id = id
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_getReturnOrder(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = getReturnOrder_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3431 rajveer 3975 
    if result.success is not None:
2700 chandransh 3976 
      return result.success
3431 rajveer 3977 
    if result.ex is not None:
2700 chandransh 3978 
      raise result.ex
3979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3980 
 
2690 chandransh 3981 
  def processReturn(self, returnOrderId):
3982 
    """
3983 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3984 
 
2690 chandransh 3985 
    Parameters:
3986 
     - returnOrderId
3987 
    """
3988 
    self.send_processReturn(returnOrderId)
3989 
    self.recv_processReturn()
3990 
 
3991 
  def send_processReturn(self, returnOrderId):
3992 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3993 
    args = processReturn_args()
3994 
    args.returnOrderId = returnOrderId
3995 
    args.write(self._oprot)
3996 
    self._oprot.writeMessageEnd()
3997 
    self._oprot.trans.flush()
3998 
 
3999 
  def recv_processReturn(self, ):
4000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4001 
    if mtype == TMessageType.EXCEPTION:
4002 
      x = TApplicationException()
4003 
      x.read(self._iprot)
4004 
      self._iprot.readMessageEnd()
4005 
      raise x
4006 
    result = processReturn_result()
4007 
    result.read(self._iprot)
4008 
    self._iprot.readMessageEnd()
3431 rajveer 4009 
    if result.ex is not None:
2690 chandransh 4010 
      raise result.ex
4011 
    return
4012 
 
3451 chandransh 4013 
  def updateWeight(self, orderId, weight):
4014 
    """
4015 
    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 4016 
 
3451 chandransh 4017 
    Parameters:
4018 
     - orderId
4019 
     - weight
4020 
    """
4021 
    self.send_updateWeight(orderId, weight)
4022 
    return self.recv_updateWeight()
4023 
 
4024 
  def send_updateWeight(self, orderId, weight):
4025 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4026 
    args = updateWeight_args()
4027 
    args.orderId = orderId
4028 
    args.weight = weight
4029 
    args.write(self._oprot)
4030 
    self._oprot.writeMessageEnd()
4031 
    self._oprot.trans.flush()
4032 
 
4033 
  def recv_updateWeight(self, ):
4034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4035 
    if mtype == TMessageType.EXCEPTION:
4036 
      x = TApplicationException()
4037 
      x.read(self._iprot)
4038 
      self._iprot.readMessageEnd()
4039 
      raise x
4040 
    result = updateWeight_result()
4041 
    result.read(self._iprot)
4042 
    self._iprot.readMessageEnd()
4043 
    if result.success is not None:
4044 
      return result.success
4045 
    if result.ex is not None:
4046 
      raise result.ex
4047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4048 
 
3469 chandransh 4049 
  def changeItem(self, orderId, itemId):
4050 
    """
4051 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4052 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4053 
 
3469 chandransh 4054 
    Parameters:
4055 
     - orderId
4056 
     - itemId
4057 
    """
4058 
    self.send_changeItem(orderId, itemId)
4059 
    return self.recv_changeItem()
4060 
 
4061 
  def send_changeItem(self, orderId, itemId):
4062 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4063 
    args = changeItem_args()
4064 
    args.orderId = orderId
4065 
    args.itemId = itemId
4066 
    args.write(self._oprot)
4067 
    self._oprot.writeMessageEnd()
4068 
    self._oprot.trans.flush()
4069 
 
4070 
  def recv_changeItem(self, ):
4071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4072 
    if mtype == TMessageType.EXCEPTION:
4073 
      x = TApplicationException()
4074 
      x.read(self._iprot)
4075 
      self._iprot.readMessageEnd()
4076 
      raise x
4077 
    result = changeItem_result()
4078 
    result.read(self._iprot)
4079 
    self._iprot.readMessageEnd()
4080 
    if result.success is not None:
4081 
      return result.success
4082 
    if result.ex is not None:
4083 
      raise result.ex
4084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4085 
 
4086 
  def shiftToWarehouse(self, orderId, warehouseId):
4087 
    """
4088 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4089 
 
4090 
    Parameters:
4091 
     - orderId
4092 
     - warehouseId
4093 
    """
4094 
    self.send_shiftToWarehouse(orderId, warehouseId)
4095 
    return self.recv_shiftToWarehouse()
4096 
 
4097 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4098 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4099 
    args = shiftToWarehouse_args()
4100 
    args.orderId = orderId
4101 
    args.warehouseId = warehouseId
4102 
    args.write(self._oprot)
4103 
    self._oprot.writeMessageEnd()
4104 
    self._oprot.trans.flush()
4105 
 
4106 
  def recv_shiftToWarehouse(self, ):
4107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4108 
    if mtype == TMessageType.EXCEPTION:
4109 
      x = TApplicationException()
4110 
      x.read(self._iprot)
4111 
      self._iprot.readMessageEnd()
4112 
      raise x
4113 
    result = shiftToWarehouse_result()
4114 
    result.read(self._iprot)
4115 
    self._iprot.readMessageEnd()
4116 
    if result.success is not None:
4117 
      return result.success
4118 
    if result.ex is not None:
4119 
      raise result.ex
4120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4121 
 
4647 rajveer 4122 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4123 
    """
4124 
    Adds the given delay reason to the given order.
3986 chandransh 4125 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4126 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4127 
 
3553 chandransh 4128 
    Parameters:
4129 
     - orderId
4130 
     - delayReason
3986 chandransh 4131 
     - furtherDelay
4647 rajveer 4132 
     - delayReasonText
3553 chandransh 4133 
    """
4647 rajveer 4134 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4135 
    return self.recv_addDelayReason()
4136 
 
4647 rajveer 4137 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4138 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4139 
    args = addDelayReason_args()
4140 
    args.orderId = orderId
4141 
    args.delayReason = delayReason
3986 chandransh 4142 
    args.furtherDelay = furtherDelay
4647 rajveer 4143 
    args.delayReasonText = delayReasonText
3553 chandransh 4144 
    args.write(self._oprot)
4145 
    self._oprot.writeMessageEnd()
4146 
    self._oprot.trans.flush()
4147 
 
4148 
  def recv_addDelayReason(self, ):
4149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4150 
    if mtype == TMessageType.EXCEPTION:
4151 
      x = TApplicationException()
4152 
      x.read(self._iprot)
4153 
      self._iprot.readMessageEnd()
4154 
      raise x
4155 
    result = addDelayReason_result()
4156 
    result.read(self._iprot)
4157 
    self._iprot.readMessageEnd()
4158 
    if result.success is not None:
4159 
      return result.success
4160 
    if result.ex is not None:
4161 
      raise result.ex
4162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4163 
 
3956 chandransh 4164 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4165 
    """
4166 
    Marks the COD orders with given AWB nos. as having been processed.
4167 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4168 
 
3956 chandransh 4169 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4170 
    1. There is no order corresponding to an AWB number.
4171 
    2. The captured amount for a payment exceeds the total payment.
4172 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4173 
 
4174 
    Parameters:
4175 
     - collectedAmountMap
4176 
     - xferBy
4177 
     - xferTxnId
4178 
     - xferDate
4179 
    """
4180 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4181 
    return self.recv_reconcileCodCollection()
4182 
 
4183 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4184 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4185 
    args = reconcileCodCollection_args()
4186 
    args.collectedAmountMap = collectedAmountMap
4187 
    args.xferBy = xferBy
4188 
    args.xferTxnId = xferTxnId
4189 
    args.xferDate = xferDate
4190 
    args.write(self._oprot)
4191 
    self._oprot.writeMessageEnd()
4192 
    self._oprot.trans.flush()
4193 
 
4194 
  def recv_reconcileCodCollection(self, ):
4195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4196 
    if mtype == TMessageType.EXCEPTION:
4197 
      x = TApplicationException()
4198 
      x.read(self._iprot)
4199 
      self._iprot.readMessageEnd()
4200 
      raise x
4201 
    result = reconcileCodCollection_result()
4202 
    result.read(self._iprot)
4203 
    self._iprot.readMessageEnd()
4204 
    if result.success is not None:
4205 
      return result.success
4206 
    if result.ex is not None:
4207 
      raise result.ex
4208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4209 
 
4008 mandeep.dh 4210 
  def getTransactionsRequiringExtraProcessing(self, category):
4211 
    """
4065 mandeep.dh 4212 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4213 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4214 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4215 
 
4008 mandeep.dh 4216 
    Parameters:
4217 
     - category
4218 
    """
4219 
    self.send_getTransactionsRequiringExtraProcessing(category)
4220 
    return self.recv_getTransactionsRequiringExtraProcessing()
4221 
 
4222 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4223 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4224 
    args = getTransactionsRequiringExtraProcessing_args()
4225 
    args.category = category
4226 
    args.write(self._oprot)
4227 
    self._oprot.writeMessageEnd()
4228 
    self._oprot.trans.flush()
4229 
 
4230 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4232 
    if mtype == TMessageType.EXCEPTION:
4233 
      x = TApplicationException()
4234 
      x.read(self._iprot)
4235 
      self._iprot.readMessageEnd()
4236 
      raise x
4237 
    result = getTransactionsRequiringExtraProcessing_result()
4238 
    result.read(self._iprot)
4239 
    self._iprot.readMessageEnd()
4240 
    if result.success is not None:
4241 
      return result.success
4242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4243 
 
4244 
  def markTransactionAsProcessed(self, transactionId, category):
4245 
    """
4246 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4247 
    It essentially deletes the transaction id record for a particular
4248 
    processing type category (if present) from DB.
4249 
    This is currently used by CRM application.
4008 mandeep.dh 4250 
 
4251 
    Parameters:
4252 
     - transactionId
4253 
     - category
4254 
    """
4255 
    self.send_markTransactionAsProcessed(transactionId, category)
4256 
    self.recv_markTransactionAsProcessed()
4257 
 
4258 
  def send_markTransactionAsProcessed(self, transactionId, category):
4259 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4260 
    args = markTransactionAsProcessed_args()
4261 
    args.transactionId = transactionId
4262 
    args.category = category
4263 
    args.write(self._oprot)
4264 
    self._oprot.writeMessageEnd()
4265 
    self._oprot.trans.flush()
4266 
 
4267 
  def recv_markTransactionAsProcessed(self, ):
4268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4269 
    if mtype == TMessageType.EXCEPTION:
4270 
      x = TApplicationException()
4271 
      x.read(self._iprot)
4272 
      self._iprot.readMessageEnd()
4273 
      raise x
4274 
    result = markTransactionAsProcessed_result()
4275 
    result.read(self._iprot)
4276 
    self._iprot.readMessageEnd()
4277 
    return
4278 
 
4018 chandransh 4279 
  def getItemWiseRiskyOrdersCount(self, ):
4280 
    """
4281 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4282 
    is defined as one whose shipping date is about to expire.
4283 
    """
4284 
    self.send_getItemWiseRiskyOrdersCount()
4285 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4286 
 
4018 chandransh 4287 
  def send_getItemWiseRiskyOrdersCount(self, ):
4288 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4289 
    args = getItemWiseRiskyOrdersCount_args()
4290 
    args.write(self._oprot)
4291 
    self._oprot.writeMessageEnd()
4292 
    self._oprot.trans.flush()
4293 
 
4294 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4296 
    if mtype == TMessageType.EXCEPTION:
4297 
      x = TApplicationException()
4298 
      x.read(self._iprot)
4299 
      self._iprot.readMessageEnd()
4300 
      raise x
4301 
    result = getItemWiseRiskyOrdersCount_result()
4302 
    result.read(self._iprot)
4303 
    self._iprot.readMessageEnd()
4304 
    if result.success is not None:
4305 
      return result.success
4306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4307 
 
4295 varun.gupt 4308 
  def getOrdersForItemIds(self, itemIds):
4309 
    """
4310 
    Returns a list of all orders which have items with given id
4311 
 
4312 
    Parameters:
4313 
     - itemIds
4314 
    """
4315 
    self.send_getOrdersForItemIds(itemIds)
4316 
    return self.recv_getOrdersForItemIds()
4317 
 
4318 
  def send_getOrdersForItemIds(self, itemIds):
4319 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4320 
    args = getOrdersForItemIds_args()
4321 
    args.itemIds = itemIds
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_getOrdersForItemIds(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = getOrdersForItemIds_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4339 
 
4247 rajveer 4340 
  def markOrderCancellationRequestReceived(self, orderId):
4341 
    """
4342 
    Mark order as cancellation request received. If customer sends request of cancellation of
4343 
    a particular order, this method will be called. It will just change status of the order
4344 
    depending on its current status. It also records the previous status, so that we can move
4345 
    back to that status if cancellation request is denied.
4018 chandransh 4346 
 
4247 rajveer 4347 
    Parameters:
4348 
     - orderId
4349 
    """
4350 
    self.send_markOrderCancellationRequestReceived(orderId)
4351 
    self.recv_markOrderCancellationRequestReceived()
4352 
 
4353 
  def send_markOrderCancellationRequestReceived(self, orderId):
4354 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4355 
    args = markOrderCancellationRequestReceived_args()
4356 
    args.orderId = orderId
4357 
    args.write(self._oprot)
4358 
    self._oprot.writeMessageEnd()
4359 
    self._oprot.trans.flush()
4360 
 
4361 
  def recv_markOrderCancellationRequestReceived(self, ):
4362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4363 
    if mtype == TMessageType.EXCEPTION:
4364 
      x = TApplicationException()
4365 
      x.read(self._iprot)
4366 
      self._iprot.readMessageEnd()
4367 
      raise x
4368 
    result = markOrderCancellationRequestReceived_result()
4369 
    result.read(self._iprot)
4370 
    self._iprot.readMessageEnd()
4371 
    if result.ex is not None:
4372 
      raise result.ex
4373 
    return
4374 
 
4375 
  def markOrderCancellationRequestConfirmed(self, orderId):
4376 
    """
4377 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4378 
    cancellation request confirmed. After this OM will be able to cancel the order.
4379 
 
4380 
    Parameters:
4381 
     - orderId
4382 
    """
4383 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4384 
    self.recv_markOrderCancellationRequestConfirmed()
4385 
 
4386 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4387 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4388 
    args = markOrderCancellationRequestConfirmed_args()
4389 
    args.orderId = orderId
4390 
    args.write(self._oprot)
4391 
    self._oprot.writeMessageEnd()
4392 
    self._oprot.trans.flush()
4393 
 
4394 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4396 
    if mtype == TMessageType.EXCEPTION:
4397 
      x = TApplicationException()
4398 
      x.read(self._iprot)
4399 
      self._iprot.readMessageEnd()
4400 
      raise x
4401 
    result = markOrderCancellationRequestConfirmed_result()
4402 
    result.read(self._iprot)
4403 
    self._iprot.readMessageEnd()
4404 
    if result.ex is not None:
4405 
      raise result.ex
4406 
    return
4407 
 
4408 
  def markOrderCancellationRequestDenied(self, orderId):
4409 
    """
4410 
    If we decide to not to cancel order, we will move the order ro previous status.
4411 
 
4412 
    Parameters:
4413 
     - orderId
4414 
    """
4415 
    self.send_markOrderCancellationRequestDenied(orderId)
4416 
    self.recv_markOrderCancellationRequestDenied()
4417 
 
4418 
  def send_markOrderCancellationRequestDenied(self, orderId):
4419 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4420 
    args = markOrderCancellationRequestDenied_args()
4421 
    args.orderId = orderId
4422 
    args.write(self._oprot)
4423 
    self._oprot.writeMessageEnd()
4424 
    self._oprot.trans.flush()
4425 
 
4426 
  def recv_markOrderCancellationRequestDenied(self, ):
4427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4428 
    if mtype == TMessageType.EXCEPTION:
4429 
      x = TApplicationException()
4430 
      x.read(self._iprot)
4431 
      self._iprot.readMessageEnd()
4432 
      raise x
4433 
    result = markOrderCancellationRequestDenied_result()
4434 
    result.read(self._iprot)
4435 
    self._iprot.readMessageEnd()
4436 
    if result.ex is not None:
4437 
      raise result.ex
4438 
    return
4439 
 
4258 rajveer 4440 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4441 
    """
4258 rajveer 4442 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4443 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4444 
 
4445 
    Parameters:
4258 rajveer 4446 
     - transactionId
4247 rajveer 4447 
    """
4258 rajveer 4448 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4449 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4450 
 
4258 rajveer 4451 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4452 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4453 
    args = markTransactionAsPaymentFlagRemoved_args()
4454 
    args.transactionId = transactionId
4247 rajveer 4455 
    args.write(self._oprot)
4456 
    self._oprot.writeMessageEnd()
4457 
    self._oprot.trans.flush()
4458 
 
4258 rajveer 4459 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4461 
    if mtype == TMessageType.EXCEPTION:
4462 
      x = TApplicationException()
4463 
      x.read(self._iprot)
4464 
      self._iprot.readMessageEnd()
4465 
      raise x
4258 rajveer 4466 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4467 
    result.read(self._iprot)
4468 
    self._iprot.readMessageEnd()
4469 
    if result.ex is not None:
4470 
      raise result.ex
4471 
    return
4472 
 
4259 anupam.sin 4473 
  def refundTransaction(self, transactionId, refundedBy, reason):
4474 
    """
4475 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4476 
    need to be cancelled
4247 rajveer 4477 
 
4259 anupam.sin 4478 
    Parameters:
4479 
     - transactionId
4480 
     - refundedBy
4481 
     - reason
4482 
    """
4483 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4484 
    self.recv_refundTransaction()
4485 
 
4486 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4487 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4488 
    args = refundTransaction_args()
4489 
    args.transactionId = transactionId
4490 
    args.refundedBy = refundedBy
4491 
    args.reason = reason
4492 
    args.write(self._oprot)
4493 
    self._oprot.writeMessageEnd()
4494 
    self._oprot.trans.flush()
4495 
 
4496 
  def recv_refundTransaction(self, ):
4497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4498 
    if mtype == TMessageType.EXCEPTION:
4499 
      x = TApplicationException()
4500 
      x.read(self._iprot)
4501 
      self._iprot.readMessageEnd()
4502 
      raise x
4503 
    result = refundTransaction_result()
4504 
    result.read(self._iprot)
4505 
    self._iprot.readMessageEnd()
4506 
    if result.ex is not None:
4507 
      raise result.ex
4508 
    return
4509 
 
4324 mandeep.dh 4510 
  def updateShipmentAddress(self, orderId, addressId):
4511 
    """
4512 
    Updates shipment address of an order. Delivery and shipping date estimates
4513 
    etc. are also updated here.
4514 
 
4515 
    Throws TransactionServiceException in case address change is not
4516 
    possible due to certain reasons such as new pincode in address is
4517 
    not serviceable etc.
4518 
 
4519 
    Parameters:
4520 
     - orderId
4521 
     - addressId
4522 
    """
4523 
    self.send_updateShipmentAddress(orderId, addressId)
4524 
    self.recv_updateShipmentAddress()
4525 
 
4526 
  def send_updateShipmentAddress(self, orderId, addressId):
4527 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4528 
    args = updateShipmentAddress_args()
4529 
    args.orderId = orderId
4530 
    args.addressId = addressId
4531 
    args.write(self._oprot)
4532 
    self._oprot.writeMessageEnd()
4533 
    self._oprot.trans.flush()
4534 
 
4535 
  def recv_updateShipmentAddress(self, ):
4536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4537 
    if mtype == TMessageType.EXCEPTION:
4538 
      x = TApplicationException()
4539 
      x.read(self._iprot)
4540 
      self._iprot.readMessageEnd()
4541 
      raise x
4542 
    result = updateShipmentAddress_result()
4543 
    result.read(self._iprot)
4544 
    self._iprot.readMessageEnd()
4545 
    if result.ex is not None:
4546 
      raise result.ex
4547 
    return
4548 
 
4285 rajveer 4549 
  def acceptOrdersForItemId(self, itemId, inventory):
4550 
    """
4551 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4552 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4553 
 
4285 rajveer 4554 
    Parameters:
4555 
     - itemId
4556 
     - inventory
4557 
    """
4558 
    self.send_acceptOrdersForItemId(itemId, inventory)
4559 
    return self.recv_acceptOrdersForItemId()
4560 
 
4561 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4562 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4563 
    args = acceptOrdersForItemId_args()
4564 
    args.itemId = itemId
4565 
    args.inventory = inventory
4566 
    args.write(self._oprot)
4567 
    self._oprot.writeMessageEnd()
4568 
    self._oprot.trans.flush()
4569 
 
4570 
  def recv_acceptOrdersForItemId(self, ):
4571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4572 
    if mtype == TMessageType.EXCEPTION:
4573 
      x = TApplicationException()
4574 
      x.read(self._iprot)
4575 
      self._iprot.readMessageEnd()
4576 
      raise x
4577 
    result = acceptOrdersForItemId_result()
4578 
    result.read(self._iprot)
4579 
    self._iprot.readMessageEnd()
4580 
    if result.success is not None:
4581 
      return result.success
4582 
    if result.ex is not None:
4583 
      raise result.ex
4584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4585 
 
4369 rajveer 4586 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4587 
    """
4588 
    Parameters:
4589 
     - vendorId
4590 
     - itemId
4591 
     - quantity
4592 
     - estimate
4369 rajveer 4593 
     - isReminder
4303 rajveer 4594 
    """
4369 rajveer 4595 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4596 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4597 
 
4369 rajveer 4598 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4599 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4600 
    args = markOrdersAsPORaised_args()
4601 
    args.vendorId = vendorId
4602 
    args.itemId = itemId
4603 
    args.quantity = quantity
4604 
    args.estimate = estimate
4369 rajveer 4605 
    args.isReminder = isReminder
4303 rajveer 4606 
    args.write(self._oprot)
4607 
    self._oprot.writeMessageEnd()
4608 
    self._oprot.trans.flush()
4609 
 
4610 
  def recv_markOrdersAsPORaised(self, ):
4611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4612 
    if mtype == TMessageType.EXCEPTION:
4613 
      x = TApplicationException()
4614 
      x.read(self._iprot)
4615 
      self._iprot.readMessageEnd()
4616 
      raise x
4617 
    result = markOrdersAsPORaised_result()
4618 
    result.read(self._iprot)
4619 
    self._iprot.readMessageEnd()
4620 
    if result.ex is not None:
4621 
      raise result.ex
4622 
    return
4623 
 
4369 rajveer 4624 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4625 
    """
4626 
    Parameters:
4627 
     - vendorId
4628 
     - itemId
4629 
     - quantity
4630 
     - estimate
4369 rajveer 4631 
     - isReminder
4303 rajveer 4632 
    """
4369 rajveer 4633 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4634 
    self.recv_markOrdersAsReversalInitiated()
4635 
 
4369 rajveer 4636 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4637 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4638 
    args = markOrdersAsReversalInitiated_args()
4639 
    args.vendorId = vendorId
4640 
    args.itemId = itemId
4641 
    args.quantity = quantity
4642 
    args.estimate = estimate
4369 rajveer 4643 
    args.isReminder = isReminder
4303 rajveer 4644 
    args.write(self._oprot)
4645 
    self._oprot.writeMessageEnd()
4646 
    self._oprot.trans.flush()
4647 
 
4648 
  def recv_markOrdersAsReversalInitiated(self, ):
4649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4650 
    if mtype == TMessageType.EXCEPTION:
4651 
      x = TApplicationException()
4652 
      x.read(self._iprot)
4653 
      self._iprot.readMessageEnd()
4654 
      raise x
4655 
    result = markOrdersAsReversalInitiated_result()
4656 
    result.read(self._iprot)
4657 
    self._iprot.readMessageEnd()
4658 
    if result.ex is not None:
4659 
      raise result.ex
4660 
    return
4661 
 
4369 rajveer 4662 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4663 
    """
4664 
    Parameters:
4665 
     - vendorId
4666 
     - itemId
4667 
     - quantity
4668 
     - estimate
4369 rajveer 4669 
     - isReminder
4303 rajveer 4670 
    """
4369 rajveer 4671 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4672 
    self.recv_markOrdersAsNotAvailabke()
4673 
 
4369 rajveer 4674 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4675 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4676 
    args = markOrdersAsNotAvailabke_args()
4677 
    args.vendorId = vendorId
4678 
    args.itemId = itemId
4679 
    args.quantity = quantity
4680 
    args.estimate = estimate
4369 rajveer 4681 
    args.isReminder = isReminder
4303 rajveer 4682 
    args.write(self._oprot)
4683 
    self._oprot.writeMessageEnd()
4684 
    self._oprot.trans.flush()
4685 
 
4686 
  def recv_markOrdersAsNotAvailabke(self, ):
4687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4688 
    if mtype == TMessageType.EXCEPTION:
4689 
      x = TApplicationException()
4690 
      x.read(self._iprot)
4691 
      self._iprot.readMessageEnd()
4692 
      raise x
4693 
    result = markOrdersAsNotAvailabke_result()
4694 
    result.read(self._iprot)
4695 
    self._iprot.readMessageEnd()
4696 
    if result.ex is not None:
4697 
      raise result.ex
4698 
    return
4699 
 
4369 rajveer 4700 
  def markOrdersAsTimeout(self, vendorId):
4701 
    """
4702 
    Parameters:
4703 
     - vendorId
4704 
    """
4705 
    self.send_markOrdersAsTimeout(vendorId)
4706 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4707 
 
4369 rajveer 4708 
  def send_markOrdersAsTimeout(self, vendorId):
4709 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4710 
    args = markOrdersAsTimeout_args()
4711 
    args.vendorId = vendorId
4712 
    args.write(self._oprot)
4713 
    self._oprot.writeMessageEnd()
4714 
    self._oprot.trans.flush()
4715 
 
4716 
  def recv_markOrdersAsTimeout(self, ):
4717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4718 
    if mtype == TMessageType.EXCEPTION:
4719 
      x = TApplicationException()
4720 
      x.read(self._iprot)
4721 
      self._iprot.readMessageEnd()
4722 
      raise x
4723 
    result = markOrdersAsTimeout_result()
4724 
    result.read(self._iprot)
4725 
    self._iprot.readMessageEnd()
4726 
    if result.success is not None:
4727 
      return result.success
4728 
    if result.ex is not None:
4729 
      raise result.ex
4730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4731 
 
4662 rajveer 4732 
  def markOrderAsLostInTransit(self, orderId):
4733 
    """
4734 
    Mark order as LOST_IN_TRANSIT
4735 
 
4736 
    Parameters:
4737 
     - orderId
4738 
    """
4739 
    self.send_markOrderAsLostInTransit(orderId)
4740 
    return self.recv_markOrderAsLostInTransit()
4741 
 
4742 
  def send_markOrderAsLostInTransit(self, orderId):
4743 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4744 
    args = markOrderAsLostInTransit_args()
4745 
    args.orderId = orderId
4746 
    args.write(self._oprot)
4747 
    self._oprot.writeMessageEnd()
4748 
    self._oprot.trans.flush()
4749 
 
4750 
  def recv_markOrderAsLostInTransit(self, ):
4751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4752 
    if mtype == TMessageType.EXCEPTION:
4753 
      x = TApplicationException()
4754 
      x.read(self._iprot)
4755 
      self._iprot.readMessageEnd()
4756 
      raise x
4757 
    result = markOrderAsLostInTransit_result()
4758 
    result.read(self._iprot)
4759 
    self._iprot.readMessageEnd()
4760 
    if result.success is not None:
4761 
      return result.success
4762 
    if result.ex is not None:
4763 
      raise result.ex
4764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4765 
 
4386 anupam.sin 4766 
  def getOrderForAwb(self, awb):
4767 
    """
4768 
    Returns the order corresponding to an AWB number
4369 rajveer 4769 
 
4386 anupam.sin 4770 
    Parameters:
4771 
     - awb
4772 
    """
4773 
    self.send_getOrderForAwb(awb)
4774 
    return self.recv_getOrderForAwb()
4775 
 
4776 
  def send_getOrderForAwb(self, awb):
4777 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4778 
    args = getOrderForAwb_args()
4779 
    args.awb = awb
4780 
    args.write(self._oprot)
4781 
    self._oprot.writeMessageEnd()
4782 
    self._oprot.trans.flush()
4783 
 
4784 
  def recv_getOrderForAwb(self, ):
4785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4786 
    if mtype == TMessageType.EXCEPTION:
4787 
      x = TApplicationException()
4788 
      x.read(self._iprot)
4789 
      self._iprot.readMessageEnd()
4790 
      raise x
4791 
    result = getOrderForAwb_result()
4792 
    result.read(self._iprot)
4793 
    self._iprot.readMessageEnd()
4794 
    if result.success is not None:
4795 
      return result.success
4796 
    if result.ex is not None:
4797 
      raise result.ex
4798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4799 
 
4910 phani.kuma 4800 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4801 
    """
4910 phani.kuma 4802 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4803 
 
4506 phani.kuma 4804 
    Parameters:
4805 
     - logistics_provider_id
4910 phani.kuma 4806 
     - order_status_list
4506 phani.kuma 4807 
    """
4910 phani.kuma 4808 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4809 
    return self.recv_getOrdersForProviderForStatus()
4810 
 
4910 phani.kuma 4811 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4812 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4813 
    args = getOrdersForProviderForStatus_args()
4814 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4815 
    args.order_status_list = order_status_list
4506 phani.kuma 4816 
    args.write(self._oprot)
4817 
    self._oprot.writeMessageEnd()
4818 
    self._oprot.trans.flush()
4819 
 
4820 
  def recv_getOrdersForProviderForStatus(self, ):
4821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4822 
    if mtype == TMessageType.EXCEPTION:
4823 
      x = TApplicationException()
4824 
      x.read(self._iprot)
4825 
      self._iprot.readMessageEnd()
4826 
      raise x
4827 
    result = getOrdersForProviderForStatus_result()
4828 
    result.read(self._iprot)
4829 
    self._iprot.readMessageEnd()
4830 
    if result.success is not None:
4831 
      return result.success
4832 
    if result.ex is not None:
4833 
      raise result.ex
4834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4835 
 
4600 varun.gupt 4836 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4837 
    """
4838 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4839 
 
4600 varun.gupt 4840 
    Parameters:
4841 
     - vendorId
4842 
     - billingDateFrom
4843 
     - billingDateTo
4844 
    """
4845 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4846 
    return self.recv_getBilledOrdersForVendor()
4847 
 
4848 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4849 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4850 
    args = getBilledOrdersForVendor_args()
4851 
    args.vendorId = vendorId
4852 
    args.billingDateFrom = billingDateFrom
4853 
    args.billingDateTo = billingDateTo
4854 
    args.write(self._oprot)
4855 
    self._oprot.writeMessageEnd()
4856 
    self._oprot.trans.flush()
4857 
 
4858 
  def recv_getBilledOrdersForVendor(self, ):
4859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4860 
    if mtype == TMessageType.EXCEPTION:
4861 
      x = TApplicationException()
4862 
      x.read(self._iprot)
4863 
      self._iprot.readMessageEnd()
4864 
      raise x
4865 
    result = getBilledOrdersForVendor_result()
4866 
    result.read(self._iprot)
4867 
    self._iprot.readMessageEnd()
4868 
    if result.success is not None:
4869 
      return result.success
4870 
    if result.ex is not None:
4871 
      raise result.ex
4872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4873 
 
4607 rajveer 4874 
  def getSlippedSippingDateOrders(self, ):
4875 
    self.send_getSlippedSippingDateOrders()
4876 
    return self.recv_getSlippedSippingDateOrders()
4877 
 
4878 
  def send_getSlippedSippingDateOrders(self, ):
4879 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4880 
    args = getSlippedSippingDateOrders_args()
4881 
    args.write(self._oprot)
4882 
    self._oprot.writeMessageEnd()
4883 
    self._oprot.trans.flush()
4884 
 
4885 
  def recv_getSlippedSippingDateOrders(self, ):
4886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4887 
    if mtype == TMessageType.EXCEPTION:
4888 
      x = TApplicationException()
4889 
      x.read(self._iprot)
4890 
      self._iprot.readMessageEnd()
4891 
      raise x
4892 
    result = getSlippedSippingDateOrders_result()
4893 
    result.read(self._iprot)
4894 
    self._iprot.readMessageEnd()
4895 
    if result.success is not None:
4896 
      return result.success
4897 
    if result.ex is not None:
4898 
      raise result.ex
4899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4900 
 
4709 rajveer 4901 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4902 
    """
4903 
    Parameters:
4904 
     - cancelDateFrom
4905 
     - cancelDateTo
4906 
    """
4907 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4908 
    return self.recv_getCancelledOrders()
4909 
 
4910 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4911 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4912 
    args = getCancelledOrders_args()
4913 
    args.cancelDateFrom = cancelDateFrom
4914 
    args.cancelDateTo = cancelDateTo
4915 
    args.write(self._oprot)
4916 
    self._oprot.writeMessageEnd()
4917 
    self._oprot.trans.flush()
4918 
 
4919 
  def recv_getCancelledOrders(self, ):
4920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4921 
    if mtype == TMessageType.EXCEPTION:
4922 
      x = TApplicationException()
4923 
      x.read(self._iprot)
4924 
      self._iprot.readMessageEnd()
4925 
      raise x
4926 
    result = getCancelledOrders_result()
4927 
    result.read(self._iprot)
4928 
    self._iprot.readMessageEnd()
4929 
    if result.success is not None:
4930 
      return result.success
4931 
    if result.ex is not None:
4932 
      raise result.ex
4933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4934 
 
4600 varun.gupt 4935 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4936 
    """
4937 
    Parameters:
4938 
     - mapAWBAndAmount
4939 
    """
4940 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4941 
    self.recv_saveBluedartSettlements()
4942 
 
4943 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4944 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4945 
    args = saveBluedartSettlements_args()
4946 
    args.mapAWBAndAmount = mapAWBAndAmount
4947 
    args.write(self._oprot)
4948 
    self._oprot.writeMessageEnd()
4949 
    self._oprot.trans.flush()
4950 
 
4951 
  def recv_saveBluedartSettlements(self, ):
4952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4953 
    if mtype == TMessageType.EXCEPTION:
4954 
      x = TApplicationException()
4955 
      x.read(self._iprot)
4956 
      self._iprot.readMessageEnd()
4957 
      raise x
4958 
    result = saveBluedartSettlements_result()
4959 
    result.read(self._iprot)
4960 
    self._iprot.readMessageEnd()
4961 
    if result.ex is not None:
4962 
      raise result.ex
4963 
    return
4964 
 
4905 varun.gupt 4965 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4966 
    """
4967 
    Parameters:
4968 
     - settlementDate
4969 
     - paymentGatewayId
4905 varun.gupt 4970 
     - referenceId
4600 varun.gupt 4971 
     - serviceTax
4972 
     - otherCharges
4973 
     - netCollection
4974 
    """
4905 varun.gupt 4975 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4976 
    self.recv_savePaymentSettlements()
4977 
 
4905 varun.gupt 4978 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4979 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4980 
    args = savePaymentSettlements_args()
4981 
    args.settlementDate = settlementDate
4982 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4983 
    args.referenceId = referenceId
4600 varun.gupt 4984 
    args.serviceTax = serviceTax
4985 
    args.otherCharges = otherCharges
4986 
    args.netCollection = netCollection
4987 
    args.write(self._oprot)
4988 
    self._oprot.writeMessageEnd()
4989 
    self._oprot.trans.flush()
4990 
 
4991 
  def recv_savePaymentSettlements(self, ):
4992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4993 
    if mtype == TMessageType.EXCEPTION:
4994 
      x = TApplicationException()
4995 
      x.read(self._iprot)
4996 
      self._iprot.readMessageEnd()
4997 
      raise x
4998 
    result = savePaymentSettlements_result()
4999 
    result.read(self._iprot)
5000 
    self._iprot.readMessageEnd()
5001 
    if result.ex is not None:
5002 
      raise result.ex
5003 
    return
5004 
 
5005 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5006 
    """
5007 
    Parameters:
5008 
     - settlementId
5009 
     - settlementDate
5010 
     - transactionDateFrom
5011 
     - transactionDateTo
5012 
     - amount
5013 
    """
5014 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5015 
    self.recv_saveEBSSettlementSummary()
5016 
 
5017 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5018 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5019 
    args = saveEBSSettlementSummary_args()
5020 
    args.settlementId = settlementId
5021 
    args.settlementDate = settlementDate
5022 
    args.transactionDateFrom = transactionDateFrom
5023 
    args.transactionDateTo = transactionDateTo
5024 
    args.amount = amount
5025 
    args.write(self._oprot)
5026 
    self._oprot.writeMessageEnd()
5027 
    self._oprot.trans.flush()
5028 
 
5029 
  def recv_saveEBSSettlementSummary(self, ):
5030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5031 
    if mtype == TMessageType.EXCEPTION:
5032 
      x = TApplicationException()
5033 
      x.read(self._iprot)
5034 
      self._iprot.readMessageEnd()
5035 
      raise x
5036 
    result = saveEBSSettlementSummary_result()
5037 
    result.read(self._iprot)
5038 
    self._iprot.readMessageEnd()
5039 
    if result.ex is not None:
5040 
      raise result.ex
5041 
    return
5042 
 
5386 phani.kuma 5043 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5044 
    """
5045 
    Parameters:
5189 varun.gupt 5046 
     - referenceId
5047 
     - isRefund
4600 varun.gupt 5048 
    """
5386 phani.kuma 5049 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5050 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5051 
 
5386 phani.kuma 5052 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5053 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5054 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5055 
    args.referenceId = referenceId
5056 
    args.isRefund = isRefund
4600 varun.gupt 5057 
    args.write(self._oprot)
5058 
    self._oprot.writeMessageEnd()
5059 
    self._oprot.trans.flush()
5060 
 
5386 phani.kuma 5061 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5063 
    if mtype == TMessageType.EXCEPTION:
5064 
      x = TApplicationException()
5065 
      x.read(self._iprot)
5066 
      self._iprot.readMessageEnd()
5067 
      raise x
5386 phani.kuma 5068 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5069 
    result.read(self._iprot)
5070 
    self._iprot.readMessageEnd()
5071 
    if result.success is not None:
5072 
      return result.success
5073 
    if result.ex is not None:
5074 
      raise result.ex
5386 phani.kuma 5075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5076 
 
5386 phani.kuma 5077 
  def getSettlementForCod(self, orderId, isRefund):
5078 
    """
5079 
    Parameters:
5080 
     - orderId
5081 
     - isRefund
5082 
    """
5083 
    self.send_getSettlementForCod(orderId, isRefund)
5084 
    return self.recv_getSettlementForCod()
5085 
 
5086 
  def send_getSettlementForCod(self, orderId, isRefund):
5087 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5088 
    args = getSettlementForCod_args()
5089 
    args.orderId = orderId
5090 
    args.isRefund = isRefund
5091 
    args.write(self._oprot)
5092 
    self._oprot.writeMessageEnd()
5093 
    self._oprot.trans.flush()
5094 
 
5095 
  def recv_getSettlementForCod(self, ):
5096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5097 
    if mtype == TMessageType.EXCEPTION:
5098 
      x = TApplicationException()
5099 
      x.read(self._iprot)
5100 
      self._iprot.readMessageEnd()
5101 
      raise x
5102 
    result = getSettlementForCod_result()
5103 
    result.read(self._iprot)
5104 
    self._iprot.readMessageEnd()
5105 
    if result.success is not None:
5106 
      return result.success
5107 
    if result.ex is not None:
5108 
      raise result.ex
5109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5110 
 
4600 varun.gupt 5111 
  def getEBSSettlementSummaries(self, ):
5112 
    self.send_getEBSSettlementSummaries()
5113 
    return self.recv_getEBSSettlementSummaries()
5114 
 
5115 
  def send_getEBSSettlementSummaries(self, ):
5116 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5117 
    args = getEBSSettlementSummaries_args()
5118 
    args.write(self._oprot)
5119 
    self._oprot.writeMessageEnd()
5120 
    self._oprot.trans.flush()
5121 
 
5122 
  def recv_getEBSSettlementSummaries(self, ):
5123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5124 
    if mtype == TMessageType.EXCEPTION:
5125 
      x = TApplicationException()
5126 
      x.read(self._iprot)
5127 
      self._iprot.readMessageEnd()
5128 
      raise x
5129 
    result = getEBSSettlementSummaries_result()
5130 
    result.read(self._iprot)
5131 
    self._iprot.readMessageEnd()
5132 
    if result.success is not None:
5133 
      return result.success
5134 
    if result.ex is not None:
5135 
      raise result.ex
5136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5137 
 
5138 
  def markEBSSettlementUploaded(self, settlementId):
5139 
    """
5140 
    Parameters:
5141 
     - settlementId
5142 
    """
5143 
    self.send_markEBSSettlementUploaded(settlementId)
5144 
    self.recv_markEBSSettlementUploaded()
5145 
 
5146 
  def send_markEBSSettlementUploaded(self, settlementId):
5147 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5148 
    args = markEBSSettlementUploaded_args()
5149 
    args.settlementId = settlementId
5150 
    args.write(self._oprot)
5151 
    self._oprot.writeMessageEnd()
5152 
    self._oprot.trans.flush()
5153 
 
5154 
  def recv_markEBSSettlementUploaded(self, ):
5155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5156 
    if mtype == TMessageType.EXCEPTION:
5157 
      x = TApplicationException()
5158 
      x.read(self._iprot)
5159 
      self._iprot.readMessageEnd()
5160 
      raise x
5161 
    result = markEBSSettlementUploaded_result()
5162 
    result.read(self._iprot)
5163 
    self._iprot.readMessageEnd()
5164 
    if result.ex is not None:
5165 
      raise result.ex
5166 
    return
5167 
 
5168 
  def getEBSSettlementDate(self, settlementId):
5169 
    """
5170 
    Parameters:
5171 
     - settlementId
5172 
    """
5173 
    self.send_getEBSSettlementDate(settlementId)
5174 
    return self.recv_getEBSSettlementDate()
5175 
 
5176 
  def send_getEBSSettlementDate(self, settlementId):
5177 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5178 
    args = getEBSSettlementDate_args()
5179 
    args.settlementId = settlementId
5180 
    args.write(self._oprot)
5181 
    self._oprot.writeMessageEnd()
5182 
    self._oprot.trans.flush()
5183 
 
5184 
  def recv_getEBSSettlementDate(self, ):
5185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5186 
    if mtype == TMessageType.EXCEPTION:
5187 
      x = TApplicationException()
5188 
      x.read(self._iprot)
5189 
      self._iprot.readMessageEnd()
5190 
      raise x
5191 
    result = getEBSSettlementDate_result()
5192 
    result.read(self._iprot)
5193 
    self._iprot.readMessageEnd()
5194 
    if result.success is not None:
5195 
      return result.success
5196 
    if result.ex is not None:
5197 
      raise result.ex
5198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5199 
 
4715 varun.gupt 5200 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5201 
    """
5202 
    Parameters:
5203 
     - settlementDateFrom
5204 
     - settlementDateTo
5205 
     - isRefund
5206 
    """
5207 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5208 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5209 
 
4715 varun.gupt 5210 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5211 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5212 
    args = getSettlementsByDate_args()
5213 
    args.settlementDateFrom = settlementDateFrom
5214 
    args.settlementDateTo = settlementDateTo
5215 
    args.isRefund = isRefund
5216 
    args.write(self._oprot)
5217 
    self._oprot.writeMessageEnd()
5218 
    self._oprot.trans.flush()
5219 
 
5220 
  def recv_getSettlementsByDate(self, ):
5221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5222 
    if mtype == TMessageType.EXCEPTION:
5223 
      x = TApplicationException()
5224 
      x.read(self._iprot)
5225 
      self._iprot.readMessageEnd()
5226 
      raise x
5227 
    result = getSettlementsByDate_result()
5228 
    result.read(self._iprot)
5229 
    self._iprot.readMessageEnd()
5230 
    if result.success is not None:
5231 
      return result.success
5232 
    if result.ex is not None:
5233 
      raise result.ex
5234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5235 
 
5236 
  def getReshippedOrderIds(self, orderIds):
5237 
    """
5238 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5239 
 
5240 
    Parameters:
5241 
     - orderIds
5242 
    """
5243 
    self.send_getReshippedOrderIds(orderIds)
5244 
    return self.recv_getReshippedOrderIds()
5245 
 
5246 
  def send_getReshippedOrderIds(self, orderIds):
5247 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5248 
    args = getReshippedOrderIds_args()
5249 
    args.orderIds = orderIds
5250 
    args.write(self._oprot)
5251 
    self._oprot.writeMessageEnd()
5252 
    self._oprot.trans.flush()
5253 
 
5254 
  def recv_getReshippedOrderIds(self, ):
5255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5256 
    if mtype == TMessageType.EXCEPTION:
5257 
      x = TApplicationException()
5258 
      x.read(self._iprot)
5259 
      self._iprot.readMessageEnd()
5260 
      raise x
5261 
    result = getReshippedOrderIds_result()
5262 
    result.read(self._iprot)
5263 
    self._iprot.readMessageEnd()
5264 
    if result.success is not None:
5265 
      return result.success
5266 
    if result.ex is not None:
5267 
      raise result.ex
5268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5269 
 
5481 phani.kuma 5270 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5271 
    """
5272 
    Parameters:
5273 
     - vendorId
5481 phani.kuma 5274 
     - onlyVendorNotPaid
5275 
     - billingDateFrom
5276 
     - billingDateTo
4875 varun.gupt 5277 
    """
5481 phani.kuma 5278 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5279 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5280 
 
5481 phani.kuma 5281 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5282 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5283 
    args = getBilledOrders_args()
4875 varun.gupt 5284 
    args.vendorId = vendorId
5481 phani.kuma 5285 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5286 
    args.billingDateFrom = billingDateFrom
5287 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5288 
    args.write(self._oprot)
5289 
    self._oprot.writeMessageEnd()
5290 
    self._oprot.trans.flush()
5291 
 
5481 phani.kuma 5292 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5294 
    if mtype == TMessageType.EXCEPTION:
5295 
      x = TApplicationException()
5296 
      x.read(self._iprot)
5297 
      self._iprot.readMessageEnd()
5298 
      raise x
5481 phani.kuma 5299 
    result = getBilledOrders_result()
4875 varun.gupt 5300 
    result.read(self._iprot)
5301 
    self._iprot.readMessageEnd()
5302 
    if result.success is not None:
5303 
      return result.success
5304 
    if result.ex is not None:
5305 
      raise result.ex
5481 phani.kuma 5306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5307 
 
5031 varun.gupt 5308 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5309 
    """
5310 
    Parameters:
5311 
     - startDate
5312 
     - endDate
5313 
    """
5314 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5315 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5316 
 
5031 varun.gupt 5317 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5318 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5319 
    args = getStatusDistributionOfOrders_args()
5320 
    args.startDate = startDate
5321 
    args.endDate = endDate
5322 
    args.write(self._oprot)
5323 
    self._oprot.writeMessageEnd()
5324 
    self._oprot.trans.flush()
5325 
 
5326 
  def recv_getStatusDistributionOfOrders(self, ):
5327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5328 
    if mtype == TMessageType.EXCEPTION:
5329 
      x = TApplicationException()
5330 
      x.read(self._iprot)
5331 
      self._iprot.readMessageEnd()
5332 
      raise x
5333 
    result = getStatusDistributionOfOrders_result()
5334 
    result.read(self._iprot)
5335 
    self._iprot.readMessageEnd()
5336 
    if result.success is not None:
5337 
      return result.success
5338 
    if result.ex is not None:
5339 
      raise result.ex
5340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5341 
 
5067 varun.gupt 5342 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5343 
    """
5344 
    Parameters:
5345 
     - status
5346 
     - startDatetime
5347 
     - endDatetime
5348 
    """
5349 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5350 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5351 
 
5067 varun.gupt 5352 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5353 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5354 
    args = getOrderIdsForStatus_args()
5355 
    args.status = status
5356 
    args.startDatetime = startDatetime
5357 
    args.endDatetime = endDatetime
5358 
    args.write(self._oprot)
5359 
    self._oprot.writeMessageEnd()
5360 
    self._oprot.trans.flush()
5361 
 
5362 
  def recv_getOrderIdsForStatus(self, ):
5363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5364 
    if mtype == TMessageType.EXCEPTION:
5365 
      x = TApplicationException()
5366 
      x.read(self._iprot)
5367 
      self._iprot.readMessageEnd()
5368 
      raise x
5369 
    result = getOrderIdsForStatus_result()
5370 
    result.read(self._iprot)
5371 
    self._iprot.readMessageEnd()
5372 
    if result.success is not None:
5373 
      return result.success
5374 
    if result.ex is not None:
5375 
      raise result.ex
5376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5377 
 
5348 anupam.sin 5378 
  def updateCODAgent(self, agent, orderId):
5379 
    """
5380 
    Updates the agent who handled the COD verification call
5381 
 
5382 
    Parameters:
5383 
     - agent
5384 
     - orderId
5385 
    """
5386 
    self.send_updateCODAgent(agent, orderId)
5387 
    self.recv_updateCODAgent()
5388 
 
5389 
  def send_updateCODAgent(self, agent, orderId):
5390 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5391 
    args = updateCODAgent_args()
5392 
    args.agent = agent
5393 
    args.orderId = orderId
5394 
    args.write(self._oprot)
5395 
    self._oprot.writeMessageEnd()
5396 
    self._oprot.trans.flush()
5397 
 
5398 
  def recv_updateCODAgent(self, ):
5399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5400 
    if mtype == TMessageType.EXCEPTION:
5401 
      x = TApplicationException()
5402 
      x.read(self._iprot)
5403 
      self._iprot.readMessageEnd()
5404 
      raise x
5405 
    result = updateCODAgent_result()
5406 
    result.read(self._iprot)
5407 
    self._iprot.readMessageEnd()
5408 
    if result.ex is not None:
5409 
      raise result.ex
5410 
    return
5411 
 
5099 varun.gupt 5412 
  def updateOrderAsPaidToVendor(self, orderId):
5413 
    """
5414 
    Parameters:
5415 
     - orderId
5416 
    """
5417 
    self.send_updateOrderAsPaidToVendor(orderId)
5418 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5419 
 
5099 varun.gupt 5420 
  def send_updateOrderAsPaidToVendor(self, orderId):
5421 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5422 
    args = updateOrderAsPaidToVendor_args()
5423 
    args.orderId = orderId
5424 
    args.write(self._oprot)
5425 
    self._oprot.writeMessageEnd()
5426 
    self._oprot.trans.flush()
5427 
 
5428 
  def recv_updateOrderAsPaidToVendor(self, ):
5429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5430 
    if mtype == TMessageType.EXCEPTION:
5431 
      x = TApplicationException()
5432 
      x.read(self._iprot)
5433 
      self._iprot.readMessageEnd()
5434 
      raise x
5435 
    result = updateOrderAsPaidToVendor_result()
5436 
    result.read(self._iprot)
5437 
    self._iprot.readMessageEnd()
5438 
    if result.ex is not None:
5439 
      raise result.ex
5440 
    return
5441 
 
5386 phani.kuma 5442 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5443 
    """
5444 
    Parameters:
5445 
     - orderId
5446 
    """
5447 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5448 
    self.recv_updateOrderOnlyAsPaidToVendor()
5449 
 
5450 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5451 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5452 
    args = updateOrderOnlyAsPaidToVendor_args()
5453 
    args.orderId = orderId
5454 
    args.write(self._oprot)
5455 
    self._oprot.writeMessageEnd()
5456 
    self._oprot.trans.flush()
5457 
 
5458 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5460 
    if mtype == TMessageType.EXCEPTION:
5461 
      x = TApplicationException()
5462 
      x.read(self._iprot)
5463 
      self._iprot.readMessageEnd()
5464 
      raise x
5465 
    result = updateOrderOnlyAsPaidToVendor_result()
5466 
    result.read(self._iprot)
5467 
    self._iprot.readMessageEnd()
5468 
    if result.ex is not None:
5469 
      raise result.ex
5470 
    return
5471 
 
5208 varun.gupt 5472 
  def getRefundedOrdersMarkedPaid(self, ):
5473 
    self.send_getRefundedOrdersMarkedPaid()
5474 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5475 
 
5208 varun.gupt 5476 
  def send_getRefundedOrdersMarkedPaid(self, ):
5477 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5478 
    args = getRefundedOrdersMarkedPaid_args()
5479 
    args.write(self._oprot)
5480 
    self._oprot.writeMessageEnd()
5481 
    self._oprot.trans.flush()
5482 
 
5483 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5485 
    if mtype == TMessageType.EXCEPTION:
5486 
      x = TApplicationException()
5487 
      x.read(self._iprot)
5488 
      self._iprot.readMessageEnd()
5489 
      raise x
5490 
    result = getRefundedOrdersMarkedPaid_result()
5491 
    result.read(self._iprot)
5492 
    self._iprot.readMessageEnd()
5493 
    if result.success is not None:
5494 
      return result.success
5495 
    if result.ex is not None:
5496 
      raise result.ex
5497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5498 
 
5447 anupam.sin 5499 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5500 
    """
5501 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5502 
 
5447 anupam.sin 5503 
 
5504 
    Parameters:
5505 
     - minOrderId
5506 
     - maxOrderId
5507 
    """
5508 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5509 
    return self.recv_getAllVerificationAgents()
5510 
 
5511 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5512 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5513 
    args = getAllVerificationAgents_args()
5514 
    args.minOrderId = minOrderId
5515 
    args.maxOrderId = maxOrderId
5516 
    args.write(self._oprot)
5517 
    self._oprot.writeMessageEnd()
5518 
    self._oprot.trans.flush()
5519 
 
5520 
  def recv_getAllVerificationAgents(self, ):
5521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5522 
    if mtype == TMessageType.EXCEPTION:
5523 
      x = TApplicationException()
5524 
      x.read(self._iprot)
5525 
      self._iprot.readMessageEnd()
5526 
      raise x
5527 
    result = getAllVerificationAgents_result()
5528 
    result.read(self._iprot)
5529 
    self._iprot.readMessageEnd()
5530 
    if result.success is not None:
5531 
      return result.success
5532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5533 
 
5527 anupam.sin 5534 
  def getAllAttributesForOrderId(self, orderId):
5535 
    """
5536 
    gets all attributes for a given orderId
5447 anupam.sin 5537 
 
5527 anupam.sin 5538 
    Parameters:
5539 
     - orderId
5540 
    """
5541 
    self.send_getAllAttributesForOrderId(orderId)
5542 
    return self.recv_getAllAttributesForOrderId()
5543 
 
5544 
  def send_getAllAttributesForOrderId(self, orderId):
5545 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5546 
    args = getAllAttributesForOrderId_args()
5547 
    args.orderId = orderId
5548 
    args.write(self._oprot)
5549 
    self._oprot.writeMessageEnd()
5550 
    self._oprot.trans.flush()
5551 
 
5552 
  def recv_getAllAttributesForOrderId(self, ):
5553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5554 
    if mtype == TMessageType.EXCEPTION:
5555 
      x = TApplicationException()
5556 
      x.read(self._iprot)
5557 
      self._iprot.readMessageEnd()
5558 
      raise x
5559 
    result = getAllAttributesForOrderId_result()
5560 
    result.read(self._iprot)
5561 
    self._iprot.readMessageEnd()
5562 
    if result.success is not None:
5563 
      return result.success
5564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5565 
 
5676 rajveer 5566 
  def setOrderAttributes(self, orderId, attributes):
5567 
    """
5568 
    sets attributes for an order
5569 
 
5570 
    Parameters:
5571 
     - orderId
5572 
     - attributes
5573 
    """
5574 
    self.send_setOrderAttributes(orderId, attributes)
5575 
    self.recv_setOrderAttributes()
5576 
 
5577 
  def send_setOrderAttributes(self, orderId, attributes):
5578 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5579 
    args = setOrderAttributes_args()
5580 
    args.orderId = orderId
5581 
    args.attributes = attributes
5582 
    args.write(self._oprot)
5583 
    self._oprot.writeMessageEnd()
5584 
    self._oprot.trans.flush()
5585 
 
5586 
  def recv_setOrderAttributes(self, ):
5587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5588 
    if mtype == TMessageType.EXCEPTION:
5589 
      x = TApplicationException()
5590 
      x.read(self._iprot)
5591 
      self._iprot.readMessageEnd()
5592 
      raise x
5593 
    result = setOrderAttributes_result()
5594 
    result.read(self._iprot)
5595 
    self._iprot.readMessageEnd()
5596 
    return
5597 
 
5527 anupam.sin 5598 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5599 
    """
5600 
    sets attributes for all orders in a transaction
5601 
 
5602 
    Parameters:
5603 
     - transactionId
5604 
     - attribute
5605 
    """
5606 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5607 
    self.recv_setOrderAttributeForTransaction()
5608 
 
5609 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5610 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5611 
    args = setOrderAttributeForTransaction_args()
5612 
    args.transactionId = transactionId
5613 
    args.attribute = attribute
5614 
    args.write(self._oprot)
5615 
    self._oprot.writeMessageEnd()
5616 
    self._oprot.trans.flush()
5617 
 
5618 
  def recv_setOrderAttributeForTransaction(self, ):
5619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5620 
    if mtype == TMessageType.EXCEPTION:
5621 
      x = TApplicationException()
5622 
      x.read(self._iprot)
5623 
      self._iprot.readMessageEnd()
5624 
      raise x
5625 
    result = setOrderAttributeForTransaction_result()
5626 
    result.read(self._iprot)
5627 
    self._iprot.readMessageEnd()
5628 
    return
5629 
 
5553 rajveer 5630 
  def getReceivePendingOrders(self, storeId):
5631 
    """
5632 
    Parameters:
5633 
     - storeId
5634 
    """
5635 
    self.send_getReceivePendingOrders(storeId)
5636 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5637 
 
5553 rajveer 5638 
  def send_getReceivePendingOrders(self, storeId):
5639 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5640 
    args = getReceivePendingOrders_args()
5641 
    args.storeId = storeId
5642 
    args.write(self._oprot)
5643 
    self._oprot.writeMessageEnd()
5644 
    self._oprot.trans.flush()
5645 
 
5646 
  def recv_getReceivePendingOrders(self, ):
5647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5648 
    if mtype == TMessageType.EXCEPTION:
5649 
      x = TApplicationException()
5650 
      x.read(self._iprot)
5651 
      self._iprot.readMessageEnd()
5652 
      raise x
5653 
    result = getReceivePendingOrders_result()
5654 
    result.read(self._iprot)
5655 
    self._iprot.readMessageEnd()
5656 
    if result.success is not None:
5657 
      return result.success
5658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5659 
 
5660 
  def getReceivedAtStoreOrders(self, storeId):
5661 
    """
5662 
    Parameters:
5663 
     - storeId
5664 
    """
5665 
    self.send_getReceivedAtStoreOrders(storeId)
5666 
    return self.recv_getReceivedAtStoreOrders()
5667 
 
5668 
  def send_getReceivedAtStoreOrders(self, storeId):
5669 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5670 
    args = getReceivedAtStoreOrders_args()
5671 
    args.storeId = storeId
5672 
    args.write(self._oprot)
5673 
    self._oprot.writeMessageEnd()
5674 
    self._oprot.trans.flush()
5675 
 
5676 
  def recv_getReceivedAtStoreOrders(self, ):
5677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5678 
    if mtype == TMessageType.EXCEPTION:
5679 
      x = TApplicationException()
5680 
      x.read(self._iprot)
5681 
      self._iprot.readMessageEnd()
5682 
      raise x
5683 
    result = getReceivedAtStoreOrders_result()
5684 
    result.read(self._iprot)
5685 
    self._iprot.readMessageEnd()
5686 
    if result.success is not None:
5687 
      return result.success
5688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5689 
 
5713 rajveer 5690 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5691 
    """
5692 
    Parameters:
5693 
     - storeId
5694 
     - fromDate
5695 
     - toDate
5696 
     - onlyCod
5697 
    """
5698 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5699 
    return self.recv_getOrdersCollectionAtStore()
5700 
 
5701 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5702 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5703 
    args = getOrdersCollectionAtStore_args()
5704 
    args.storeId = storeId
5705 
    args.fromDate = fromDate
5706 
    args.toDate = toDate
5707 
    args.onlyCod = onlyCod
5708 
    args.write(self._oprot)
5709 
    self._oprot.writeMessageEnd()
5710 
    self._oprot.trans.flush()
5711 
 
5712 
  def recv_getOrdersCollectionAtStore(self, ):
5713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5714 
    if mtype == TMessageType.EXCEPTION:
5715 
      x = TApplicationException()
5716 
      x.read(self._iprot)
5717 
      self._iprot.readMessageEnd()
5718 
      raise x
5719 
    result = getOrdersCollectionAtStore_result()
5720 
    result.read(self._iprot)
5721 
    self._iprot.readMessageEnd()
5722 
    if result.success is not None:
5723 
      return result.success
5724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5725 
 
5833 rajveer 5726 
  def getOrderAttributeValue(self, orderId, attributeName):
5727 
    """
5728 
    Parameters:
5729 
     - orderId
5730 
     - attributeName
5731 
    """
5732 
    self.send_getOrderAttributeValue(orderId, attributeName)
5733 
    return self.recv_getOrderAttributeValue()
5734 
 
5735 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5736 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5737 
    args = getOrderAttributeValue_args()
5738 
    args.orderId = orderId
5739 
    args.attributeName = attributeName
5740 
    args.write(self._oprot)
5741 
    self._oprot.writeMessageEnd()
5742 
    self._oprot.trans.flush()
5743 
 
5744 
  def recv_getOrderAttributeValue(self, ):
5745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5746 
    if mtype == TMessageType.EXCEPTION:
5747 
      x = TApplicationException()
5748 
      x.read(self._iprot)
5749 
      self._iprot.readMessageEnd()
5750 
      raise x
5751 
    result = getOrderAttributeValue_result()
5752 
    result.read(self._iprot)
5753 
    self._iprot.readMessageEnd()
5754 
    if result.success is not None:
5755 
      return result.success
5756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5757 
 
6019 rajveer 5758 
  def changeJacketNumber(self, orderId, jacketNumber):
5759 
    """
5760 
    Parameters:
5761 
     - orderId
5762 
     - jacketNumber
5763 
    """
5764 
    self.send_changeJacketNumber(orderId, jacketNumber)
5765 
    return self.recv_changeJacketNumber()
5766 
 
5767 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5768 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5769 
    args = changeJacketNumber_args()
5770 
    args.orderId = orderId
5771 
    args.jacketNumber = jacketNumber
5772 
    args.write(self._oprot)
5773 
    self._oprot.writeMessageEnd()
5774 
    self._oprot.trans.flush()
5775 
 
5776 
  def recv_changeJacketNumber(self, ):
5777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5778 
    if mtype == TMessageType.EXCEPTION:
5779 
      x = TApplicationException()
5780 
      x.read(self._iprot)
5781 
      self._iprot.readMessageEnd()
5782 
      raise x
5783 
    result = changeJacketNumber_result()
5784 
    result.read(self._iprot)
5785 
    self._iprot.readMessageEnd()
5786 
    if result.success is not None:
5787 
      return result.success
5788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5789 
 
5790 
  def markOrderAsRtoInTransit(self, orderId):
5791 
    """
5792 
    Parameters:
5793 
     - orderId
5794 
    """
5795 
    self.send_markOrderAsRtoInTransit(orderId)
5796 
    return self.recv_markOrderAsRtoInTransit()
5797 
 
5798 
  def send_markOrderAsRtoInTransit(self, orderId):
5799 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5800 
    args = markOrderAsRtoInTransit_args()
5801 
    args.orderId = orderId
5802 
    args.write(self._oprot)
5803 
    self._oprot.writeMessageEnd()
5804 
    self._oprot.trans.flush()
5805 
 
5806 
  def recv_markOrderAsRtoInTransit(self, ):
5807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5808 
    if mtype == TMessageType.EXCEPTION:
5809 
      x = TApplicationException()
5810 
      x.read(self._iprot)
5811 
      self._iprot.readMessageEnd()
5812 
      raise x
5813 
    result = markOrderAsRtoInTransit_result()
5814 
    result.read(self._iprot)
5815 
    self._iprot.readMessageEnd()
5816 
    if result.success is not None:
5817 
      return result.success
5818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5819 
 
5593 mandeep.dh 5820 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5821 
    """
5822 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5823 
    invoked while scanning IN of items.
5553 rajveer 5824 
 
5593 mandeep.dh 5825 
    Parameters:
5826 
     - itemId
5827 
     - quantity
5828 
     - fulfilmentWarehouseId
5829 
     - billingWarehouseId
5830 
    """
5831 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5832 
    self.recv_acceptOrderForItem()
5833 
 
5834 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5835 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5836 
    args = acceptOrderForItem_args()
5837 
    args.itemId = itemId
5838 
    args.quantity = quantity
5839 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5840 
    args.billingWarehouseId = billingWarehouseId
5841 
    args.write(self._oprot)
5842 
    self._oprot.writeMessageEnd()
5843 
    self._oprot.trans.flush()
5844 
 
5845 
  def recv_acceptOrderForItem(self, ):
5846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5847 
    if mtype == TMessageType.EXCEPTION:
5848 
      x = TApplicationException()
5849 
      x.read(self._iprot)
5850 
      self._iprot.readMessageEnd()
5851 
      raise x
5852 
    result = acceptOrderForItem_result()
5853 
    result.read(self._iprot)
5854 
    self._iprot.readMessageEnd()
5855 
    return
5856 
 
6000 mandeep.dh 5857 
  def createRechargeOrder(self, rechargeOrder):
5858 
    """
5859 
    Parameters:
5860 
     - rechargeOrder
5861 
    """
5862 
    self.send_createRechargeOrder(rechargeOrder)
5863 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5864 
 
6000 mandeep.dh 5865 
  def send_createRechargeOrder(self, rechargeOrder):
5866 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5867 
    args = createRechargeOrder_args()
5868 
    args.rechargeOrder = rechargeOrder
5869 
    args.write(self._oprot)
5870 
    self._oprot.writeMessageEnd()
5871 
    self._oprot.trans.flush()
5872 
 
5873 
  def recv_createRechargeOrder(self, ):
5874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5875 
    if mtype == TMessageType.EXCEPTION:
5876 
      x = TApplicationException()
5877 
      x.read(self._iprot)
5878 
      self._iprot.readMessageEnd()
5879 
      raise x
5880 
    result = createRechargeOrder_result()
5881 
    result.read(self._iprot)
5882 
    self._iprot.readMessageEnd()
5883 
    if result.success is not None:
5884 
      return result.success
5885 
    if result.ex is not None:
5886 
      raise result.ex
5887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5888 
 
6031 rajveer 5889 
  def getRechargeOrder(self, rechargeRrderId):
5890 
    """
5891 
    Parameters:
5892 
     - rechargeRrderId
5893 
    """
5894 
    self.send_getRechargeOrder(rechargeRrderId)
5895 
    return self.recv_getRechargeOrder()
5896 
 
5897 
  def send_getRechargeOrder(self, rechargeRrderId):
5898 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5899 
    args = getRechargeOrder_args()
5900 
    args.rechargeRrderId = rechargeRrderId
5901 
    args.write(self._oprot)
5902 
    self._oprot.writeMessageEnd()
5903 
    self._oprot.trans.flush()
5904 
 
5905 
  def recv_getRechargeOrder(self, ):
5906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5907 
    if mtype == TMessageType.EXCEPTION:
5908 
      x = TApplicationException()
5909 
      x.read(self._iprot)
5910 
      self._iprot.readMessageEnd()
5911 
      raise x
5912 
    result = getRechargeOrder_result()
5913 
    result.read(self._iprot)
5914 
    self._iprot.readMessageEnd()
5915 
    if result.success is not None:
5916 
      return result.success
5917 
    if result.ex is not None:
5918 
      raise result.ex
5919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5920 
 
5921 
  def getRechargeOrders(self, userId):
5922 
    """
5923 
    Parameters:
5924 
     - userId
5925 
    """
5926 
    self.send_getRechargeOrders(userId)
5927 
    return self.recv_getRechargeOrders()
5928 
 
5929 
  def send_getRechargeOrders(self, userId):
5930 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5931 
    args = getRechargeOrders_args()
5932 
    args.userId = userId
5933 
    args.write(self._oprot)
5934 
    self._oprot.writeMessageEnd()
5935 
    self._oprot.trans.flush()
5936 
 
5937 
  def recv_getRechargeOrders(self, ):
5938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5939 
    if mtype == TMessageType.EXCEPTION:
5940 
      x = TApplicationException()
5941 
      x.read(self._iprot)
5942 
      self._iprot.readMessageEnd()
5943 
      raise x
5944 
    result = getRechargeOrders_result()
5945 
    result.read(self._iprot)
5946 
    self._iprot.readMessageEnd()
5947 
    if result.success is not None:
5948 
      return result.success
5949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5950 
 
6000 mandeep.dh 5951 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5952 
    """
5953 
    Parameters:
5954 
     - rechargeOrderId
5955 
     - rechargeOrderStatus
5956 
    """
5957 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5958 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5959 
 
5960 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5961 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5962 
    args = updateRechargeOrderStatus_args()
5963 
    args.rechargeOrderId = rechargeOrderId
5964 
    args.rechargeOrderStatus = rechargeOrderStatus
5965 
    args.write(self._oprot)
5966 
    self._oprot.writeMessageEnd()
5967 
    self._oprot.trans.flush()
5968 
 
5969 
  def recv_updateRechargeOrderStatus(self, ):
5970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5971 
    if mtype == TMessageType.EXCEPTION:
5972 
      x = TApplicationException()
5973 
      x.read(self._iprot)
5974 
      self._iprot.readMessageEnd()
5975 
      raise x
5976 
    result = updateRechargeOrderStatus_result()
5977 
    result.read(self._iprot)
5978 
    self._iprot.readMessageEnd()
6031 rajveer 5979 
    if result.success is not None:
5980 
      return result.success
6000 mandeep.dh 5981 
    if result.ex is not None:
5982 
      raise result.ex
6031 rajveer 5983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5984 
 
6031 rajveer 5985 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5986 
    """
5987 
    Parameters:
6031 rajveer 5988 
     - rechargeOrderId
6000 mandeep.dh 5989 
    """
6031 rajveer 5990 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5991 
    return self.recv_activateRechargeTxn()
5992 
 
6031 rajveer 5993 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5994 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5995 
    args = activateRechargeTxn_args()
6031 rajveer 5996 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5997 
    args.write(self._oprot)
5998 
    self._oprot.writeMessageEnd()
5999 
    self._oprot.trans.flush()
6000 
 
6001 
  def recv_activateRechargeTxn(self, ):
6002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6003 
    if mtype == TMessageType.EXCEPTION:
6004 
      x = TApplicationException()
6005 
      x.read(self._iprot)
6006 
      self._iprot.readMessageEnd()
6007 
      raise x
6008 
    result = activateRechargeTxn_result()
6009 
    result.read(self._iprot)
6010 
    self._iprot.readMessageEnd()
6011 
    if result.success is not None:
6012 
      return result.success
6013 
    if result.ex is not None:
6014 
      raise result.ex
6015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6016 
 
6031 rajveer 6017 
  def getUserWallet(self, userId):
6000 mandeep.dh 6018 
    """
6019 
    Parameters:
6031 rajveer 6020 
     - userId
6000 mandeep.dh 6021 
    """
6031 rajveer 6022 
    self.send_getUserWallet(userId)
6023 
    return self.recv_getUserWallet()
6000 mandeep.dh 6024 
 
6031 rajveer 6025 
  def send_getUserWallet(self, userId):
6026 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6027 
    args = getUserWallet_args()
6028 
    args.userId = userId
6000 mandeep.dh 6029 
    args.write(self._oprot)
6030 
    self._oprot.writeMessageEnd()
6031 
    self._oprot.trans.flush()
6032 
 
6031 rajveer 6033 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6035 
    if mtype == TMessageType.EXCEPTION:
6036 
      x = TApplicationException()
6037 
      x.read(self._iprot)
6038 
      self._iprot.readMessageEnd()
6039 
      raise x
6031 rajveer 6040 
    result = getUserWallet_result()
6000 mandeep.dh 6041 
    result.read(self._iprot)
6042 
    self._iprot.readMessageEnd()
6043 
    if result.success is not None:
6044 
      return result.success
6031 rajveer 6045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6046 
 
6031 rajveer 6047 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6048 
    """
6049 
    Parameters:
6031 rajveer 6050 
     - userId
6000 mandeep.dh 6051 
    """
6031 rajveer 6052 
    self.send_getUserWalletHistory(userId)
6053 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6054 
 
6031 rajveer 6055 
  def send_getUserWalletHistory(self, userId):
6056 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6057 
    args = getUserWalletHistory_args()
6058 
    args.userId = userId
6000 mandeep.dh 6059 
    args.write(self._oprot)
6060 
    self._oprot.writeMessageEnd()
6061 
    self._oprot.trans.flush()
6062 
 
6031 rajveer 6063 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6065 
    if mtype == TMessageType.EXCEPTION:
6066 
      x = TApplicationException()
6067 
      x.read(self._iprot)
6068 
      self._iprot.readMessageEnd()
6069 
      raise x
6031 rajveer 6070 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6071 
    result.read(self._iprot)
6072 
    self._iprot.readMessageEnd()
6073 
    if result.success is not None:
6074 
      return result.success
6031 rajveer 6075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6076 
 
6050 anupam.sin 6077 
  def getRechargeOrdersForTransaction(self, txnId):
6078 
    """
6079 
    Returns a recharge order for a given transactionId
6080 
 
6081 
    Parameters:
6082 
     - txnId
6083 
    """
6084 
    self.send_getRechargeOrdersForTransaction(txnId)
6085 
    return self.recv_getRechargeOrdersForTransaction()
6086 
 
6087 
  def send_getRechargeOrdersForTransaction(self, txnId):
6088 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6089 
    args = getRechargeOrdersForTransaction_args()
6090 
    args.txnId = txnId
6091 
    args.write(self._oprot)
6092 
    self._oprot.writeMessageEnd()
6093 
    self._oprot.trans.flush()
6094 
 
6095 
  def recv_getRechargeOrdersForTransaction(self, ):
6096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6097 
    if mtype == TMessageType.EXCEPTION:
6098 
      x = TApplicationException()
6099 
      x.read(self._iprot)
6100 
      self._iprot.readMessageEnd()
6101 
      raise x
6102 
    result = getRechargeOrdersForTransaction_result()
6103 
    result.read(self._iprot)
6104 
    self._iprot.readMessageEnd()
6105 
    if result.success is not None:
6106 
      return result.success
6107 
    if result.ex is not None:
6108 
      raise result.ex
6109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6110 
 
6206 rajveer 6111 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6112 
    """
6113 
    Parameters:
6114 
     - rechargeType
6206 rajveer 6115 
     - onlyActive
6048 rajveer 6116 
    """
6206 rajveer 6117 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6118 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6119 
 
6206 rajveer 6120 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6121 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6122 
    args = getServiceProviders_args()
6123 
    args.rechargeType = rechargeType
6206 rajveer 6124 
    args.onlyActive = onlyActive
6048 rajveer 6125 
    args.write(self._oprot)
6126 
    self._oprot.writeMessageEnd()
6127 
    self._oprot.trans.flush()
6128 
 
6129 
  def recv_getServiceProviders(self, ):
6130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6131 
    if mtype == TMessageType.EXCEPTION:
6132 
      x = TApplicationException()
6133 
      x.read(self._iprot)
6134 
      self._iprot.readMessageEnd()
6135 
      raise x
6136 
    result = getServiceProviders_result()
6137 
    result.read(self._iprot)
6138 
    self._iprot.readMessageEnd()
6139 
    if result.success is not None:
6140 
      return result.success
6141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6142 
 
6049 rajveer 6143 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6144 
    """
6145 
    Parameters:
6049 rajveer 6146 
     - rechargeType
6048 rajveer 6147 
     - deviceNumber
6148 
    """
6049 rajveer 6149 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6150 
    return self.recv_getServiceProviderForDevice()
6151 
 
6049 rajveer 6152 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6153 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6154 
    args = getServiceProviderForDevice_args()
6049 rajveer 6155 
    args.rechargeType = rechargeType
6048 rajveer 6156 
    args.deviceNumber = deviceNumber
6157 
    args.write(self._oprot)
6158 
    self._oprot.writeMessageEnd()
6159 
    self._oprot.trans.flush()
6160 
 
6161 
  def recv_getServiceProviderForDevice(self, ):
6162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6163 
    if mtype == TMessageType.EXCEPTION:
6164 
      x = TApplicationException()
6165 
      x.read(self._iprot)
6166 
      self._iprot.readMessageEnd()
6167 
      raise x
6168 
    result = getServiceProviderForDevice_result()
6169 
    result.read(self._iprot)
6170 
    self._iprot.readMessageEnd()
6171 
    if result.success is not None:
6172 
      return result.success
6173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6174 
 
6269 rajveer 6175 
  def validateRecharge(self, rechargeType, deviceNumber):
6176 
    """
6177 
    Parameters:
6178 
     - rechargeType
6179 
     - deviceNumber
6180 
    """
6181 
    self.send_validateRecharge(rechargeType, deviceNumber)
6182 
    return self.recv_validateRecharge()
6183 
 
6184 
  def send_validateRecharge(self, rechargeType, deviceNumber):
6185 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6186 
    args = validateRecharge_args()
6187 
    args.rechargeType = rechargeType
6188 
    args.deviceNumber = deviceNumber
6189 
    args.write(self._oprot)
6190 
    self._oprot.writeMessageEnd()
6191 
    self._oprot.trans.flush()
6192 
 
6193 
  def recv_validateRecharge(self, ):
6194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6195 
    if mtype == TMessageType.EXCEPTION:
6196 
      x = TApplicationException()
6197 
      x.read(self._iprot)
6198 
      self._iprot.readMessageEnd()
6199 
      raise x
6200 
    result = validateRecharge_result()
6201 
    result.read(self._iprot)
6202 
    self._iprot.readMessageEnd()
6203 
    if result.success is not None:
6204 
      return result.success
6205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6206 
 
6094 rajveer 6207 
  def getRechargeOrdersForDevice(self, deviceNumber):
6208 
    """
6209 
    Parameters:
6210 
     - deviceNumber
6211 
    """
6212 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6213 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6214 
 
6094 rajveer 6215 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6216 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6217 
    args = getRechargeOrdersForDevice_args()
6218 
    args.deviceNumber = deviceNumber
6219 
    args.write(self._oprot)
6220 
    self._oprot.writeMessageEnd()
6221 
    self._oprot.trans.flush()
6222 
 
6223 
  def recv_getRechargeOrdersForDevice(self, ):
6224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6225 
    if mtype == TMessageType.EXCEPTION:
6226 
      x = TApplicationException()
6227 
      x.read(self._iprot)
6228 
      self._iprot.readMessageEnd()
6229 
      raise x
6230 
    result = getRechargeOrdersForDevice_result()
6231 
    result.read(self._iprot)
6232 
    self._iprot.readMessageEnd()
6233 
    if result.success is not None:
6234 
      return result.success
6235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6236 
 
6237 
  def addAmountToWallet(self, userId, orderId, amount):
6238 
    """
6239 
    Parameters:
6240 
     - userId
6241 
     - orderId
6242 
     - amount
6243 
    """
6244 
    self.send_addAmountToWallet(userId, orderId, amount)
6245 
    self.recv_addAmountToWallet()
6246 
 
6247 
  def send_addAmountToWallet(self, userId, orderId, amount):
6248 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6249 
    args = addAmountToWallet_args()
6250 
    args.userId = userId
6251 
    args.orderId = orderId
6252 
    args.amount = amount
6253 
    args.write(self._oprot)
6254 
    self._oprot.writeMessageEnd()
6255 
    self._oprot.trans.flush()
6256 
 
6257 
  def recv_addAmountToWallet(self, ):
6258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6259 
    if mtype == TMessageType.EXCEPTION:
6260 
      x = TApplicationException()
6261 
      x.read(self._iprot)
6262 
      self._iprot.readMessageEnd()
6263 
      raise x
6264 
    result = addAmountToWallet_result()
6265 
    result.read(self._iprot)
6266 
    self._iprot.readMessageEnd()
6267 
    return
6268 
 
6188 rajveer 6269 
  def getRechargeStatistics(self, ):
6270 
    self.send_getRechargeStatistics()
6271 
    return self.recv_getRechargeStatistics()
6272 
 
6273 
  def send_getRechargeStatistics(self, ):
6274 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6275 
    args = getRechargeStatistics_args()
6276 
    args.write(self._oprot)
6277 
    self._oprot.writeMessageEnd()
6278 
    self._oprot.trans.flush()
6279 
 
6280 
  def recv_getRechargeStatistics(self, ):
6281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6282 
    if mtype == TMessageType.EXCEPTION:
6283 
      x = TApplicationException()
6284 
      x.read(self._iprot)
6285 
      self._iprot.readMessageEnd()
6286 
      raise x
6287 
    result = getRechargeStatistics_result()
6288 
    result.read(self._iprot)
6289 
    self._iprot.readMessageEnd()
6290 
    if result.success is not None:
6291 
      return result.success
6292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6293 
 
6154 rajveer 6294 
  def getRechargeOrdersForStatus(self, status):
6295 
    """
6296 
    Parameters:
6297 
     - status
6298 
    """
6299 
    self.send_getRechargeOrdersForStatus(status)
6300 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6301 
 
6154 rajveer 6302 
  def send_getRechargeOrdersForStatus(self, status):
6303 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6304 
    args = getRechargeOrdersForStatus_args()
6305 
    args.status = status
6306 
    args.write(self._oprot)
6307 
    self._oprot.writeMessageEnd()
6308 
    self._oprot.trans.flush()
6309 
 
6310 
  def recv_getRechargeOrdersForStatus(self, ):
6311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6312 
    if mtype == TMessageType.EXCEPTION:
6313 
      x = TApplicationException()
6314 
      x.read(self._iprot)
6315 
      self._iprot.readMessageEnd()
6316 
      raise x
6317 
    result = getRechargeOrdersForStatus_result()
6318 
    result.read(self._iprot)
6319 
    self._iprot.readMessageEnd()
6320 
    if result.success is not None:
6321 
      return result.success
6322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6323 
 
6159 rajveer 6324 
  def getPlansForOperator(self, operatorId):
6325 
    """
6326 
    Parameters:
6327 
     - operatorId
6328 
    """
6329 
    self.send_getPlansForOperator(operatorId)
6330 
    return self.recv_getPlansForOperator()
6154 rajveer 6331 
 
6159 rajveer 6332 
  def send_getPlansForOperator(self, operatorId):
6333 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6334 
    args = getPlansForOperator_args()
6335 
    args.operatorId = operatorId
6336 
    args.write(self._oprot)
6337 
    self._oprot.writeMessageEnd()
6338 
    self._oprot.trans.flush()
6339 
 
6340 
  def recv_getPlansForOperator(self, ):
6341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6342 
    if mtype == TMessageType.EXCEPTION:
6343 
      x = TApplicationException()
6344 
      x.read(self._iprot)
6345 
      self._iprot.readMessageEnd()
6346 
      raise x
6347 
    result = getPlansForOperator_result()
6348 
    result.read(self._iprot)
6349 
    self._iprot.readMessageEnd()
6350 
    if result.success is not None:
6351 
      return result.success
6352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6353 
 
6289 anupam.sin 6354 
  def getRechargeDenominations(self, operatorId, circleName, denominationType):
6355 
    """
6356 
    Returns denominations for a given operator and circle
6159 rajveer 6357 
 
6289 anupam.sin 6358 
    Parameters:
6359 
     - operatorId
6360 
     - circleName
6361 
     - denominationType
6362 
    """
6363 
    self.send_getRechargeDenominations(operatorId, circleName, denominationType)
6364 
    return self.recv_getRechargeDenominations()
6365 
 
6366 
  def send_getRechargeDenominations(self, operatorId, circleName, denominationType):
6367 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6368 
    args = getRechargeDenominations_args()
6369 
    args.operatorId = operatorId
6370 
    args.circleName = circleName
6371 
    args.denominationType = denominationType
6372 
    args.write(self._oprot)
6373 
    self._oprot.writeMessageEnd()
6374 
    self._oprot.trans.flush()
6375 
 
6376 
  def recv_getRechargeDenominations(self, ):
6377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6378 
    if mtype == TMessageType.EXCEPTION:
6379 
      x = TApplicationException()
6380 
      x.read(self._iprot)
6381 
      self._iprot.readMessageEnd()
6382 
      raise x
6383 
    result = getRechargeDenominations_result()
6384 
    result.read(self._iprot)
6385 
    self._iprot.readMessageEnd()
6386 
    if result.success is not None:
6387 
      return result.success
6388 
    if result.ex is not None:
6389 
      raise result.ex
6390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6391 
 
6392 
 
3376 rajveer 6393 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6394 
  def __init__(self, handler):
3376 rajveer 6395 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6396 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6397 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6398 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6399 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6400 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6401 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6402 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6403 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6404 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6405 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6406 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6407 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6408 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6409 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6410 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6411 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6412 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6413 
    self._processMap["createOrder"] = Processor.process_createOrder
6414 
    self._processMap["getOrder"] = Processor.process_getOrder
6415 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6416 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6417 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6418 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6419 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6420 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6421 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6422 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6423 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6424 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6425 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6426 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6427 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6428 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6429 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6430 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6431 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6432 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6433 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6434 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6435 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6436 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6437 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6438 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6439 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6440 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6441 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6442 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6443 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6444 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6445 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6446 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6447 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6448 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6449 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6450 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6451 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6452 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6453 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6454 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6455 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6456 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6457 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6458 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6459 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6460 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6461 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6462 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6463 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6464 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6465 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6466 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6467 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6468 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6469 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6470 
    self._processMap["changeItem"] = Processor.process_changeItem
6471 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6472 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6473 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6474 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6475 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6476 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6477 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6478 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6479 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6480 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6481 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6482 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6483 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6484 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6485 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6486 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6487 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6488 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6489 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6490 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6491 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6492 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6493 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6494 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6495 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6496 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6497 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6498 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6499 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6500 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6501 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6502 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6503 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6504 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6505 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6506 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6507 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6508 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6509 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6510 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6511 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6512 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6513 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6514 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6515 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6516 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6517 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6518 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6519 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6520 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6521 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6522 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6523 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6524 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6525 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6526 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6527 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6528 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6529 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6530 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6531 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6532 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6533 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6534 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6535 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6536 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6537 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6538 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6539 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
94 ashish 6540 
 
6541 
  def process(self, iprot, oprot):
6542 
    (name, type, seqid) = iprot.readMessageBegin()
6543 
    if name not in self._processMap:
6544 
      iprot.skip(TType.STRUCT)
6545 
      iprot.readMessageEnd()
6546 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6547 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6548 
      x.write(oprot)
6549 
      oprot.writeMessageEnd()
6550 
      oprot.trans.flush()
6551 
      return
6552 
    else:
6553 
      self._processMap[name](self, seqid, iprot, oprot)
6554 
    return True
6555 
 
6556 
  def process_createTransaction(self, seqid, iprot, oprot):
6557 
    args = createTransaction_args()
6558 
    args.read(iprot)
6559 
    iprot.readMessageEnd()
6560 
    result = createTransaction_result()
6561 
    try:
132 ashish 6562 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6563 
    except TransactionServiceException, ex:
6564 
      result.ex = ex
6565 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6566 
    result.write(oprot)
6567 
    oprot.writeMessageEnd()
6568 
    oprot.trans.flush()
6569 
 
6570 
  def process_getTransaction(self, seqid, iprot, oprot):
6571 
    args = getTransaction_args()
6572 
    args.read(iprot)
6573 
    iprot.readMessageEnd()
6574 
    result = getTransaction_result()
6575 
    try:
6576 
      result.success = self._handler.getTransaction(args.id)
6577 
    except TransactionServiceException, ex:
6578 
      result.ex = ex
6579 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6580 
    result.write(oprot)
6581 
    oprot.writeMessageEnd()
6582 
    oprot.trans.flush()
6583 
 
6584 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6585 
    args = getTransactionsForCustomer_args()
6586 
    args.read(iprot)
6587 
    iprot.readMessageEnd()
6588 
    result = getTransactionsForCustomer_result()
6589 
    try:
6590 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6591 
    except TransactionServiceException, ex:
6592 
      result.ex = ex
6593 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6597 
 
132 ashish 6598 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6599 
    args = getTransactionsForShoppingCartId_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getTransactionsForShoppingCartId_result()
6603 
    try:
6604 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6605 
    except TransactionServiceException, ex:
6606 
      result.ex = ex
6607 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
6611 
 
94 ashish 6612 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6613 
    args = getTransactionStatus_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = getTransactionStatus_result()
6617 
    try:
6618 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6619 
    except TransactionServiceException, ex:
6620 
      result.ex = ex
6621 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6622 
    result.write(oprot)
6623 
    oprot.writeMessageEnd()
6624 
    oprot.trans.flush()
6625 
 
6626 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6627 
    args = changeTransactionStatus_args()
6628 
    args.read(iprot)
6629 
    iprot.readMessageEnd()
6630 
    result = changeTransactionStatus_result()
6631 
    try:
5527 anupam.sin 6632 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6633 
    except TransactionServiceException, ex:
6634 
      result.ex = ex
6635 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6636 
    result.write(oprot)
6637 
    oprot.writeMessageEnd()
6638 
    oprot.trans.flush()
6639 
 
1398 varun.gupt 6640 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6641 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6642 
    args.read(iprot)
6643 
    iprot.readMessageEnd()
1398 varun.gupt 6644 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6645 
    try:
1398 varun.gupt 6646 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6647 
    except TransactionServiceException, ex:
6648 
      result.ex = ex
1398 varun.gupt 6649 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6650 
    result.write(oprot)
6651 
    oprot.writeMessageEnd()
6652 
    oprot.trans.flush()
6653 
 
483 rajveer 6654 
  def process_getAllOrders(self, seqid, iprot, oprot):
6655 
    args = getAllOrders_args()
94 ashish 6656 
    args.read(iprot)
6657 
    iprot.readMessageEnd()
483 rajveer 6658 
    result = getAllOrders_result()
94 ashish 6659 
    try:
4801 anupam.sin 6660 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6661 
    except TransactionServiceException, ex:
6662 
      result.ex = ex
483 rajveer 6663 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6664 
    result.write(oprot)
6665 
    oprot.writeMessageEnd()
6666 
    oprot.trans.flush()
6667 
 
4133 chandransh 6668 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6669 
    args = getOrdersInBatch_args()
6670 
    args.read(iprot)
6671 
    iprot.readMessageEnd()
6672 
    result = getOrdersInBatch_result()
6673 
    try:
6674 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6675 
    except TransactionServiceException, ex:
6676 
      result.ex = ex
6677 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6678 
    result.write(oprot)
6679 
    oprot.writeMessageEnd()
6680 
    oprot.trans.flush()
6681 
 
6682 
  def process_getOrderCount(self, seqid, iprot, oprot):
6683 
    args = getOrderCount_args()
6684 
    args.read(iprot)
6685 
    iprot.readMessageEnd()
6686 
    result = getOrderCount_result()
6687 
    try:
6688 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6689 
    except TransactionServiceException, ex:
6690 
      result.ex = ex
6691 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6692 
    result.write(oprot)
6693 
    oprot.writeMessageEnd()
6694 
    oprot.trans.flush()
6695 
 
999 varun.gupt 6696 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6697 
    args = getOrdersByBillingDate_args()
6698 
    args.read(iprot)
6699 
    iprot.readMessageEnd()
6700 
    result = getOrdersByBillingDate_result()
6701 
    try:
6702 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6703 
    except TransactionServiceException, ex:
6704 
      result.ex = ex
6705 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6706 
    result.write(oprot)
6707 
    oprot.writeMessageEnd()
6708 
    oprot.trans.flush()
6709 
 
3427 chandransh 6710 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6711 
    args = getOrdersByShippingDate_args()
6712 
    args.read(iprot)
6713 
    iprot.readMessageEnd()
6714 
    result = getOrdersByShippingDate_result()
6715 
    try:
3451 chandransh 6716 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6717 
    except TransactionServiceException, ex:
6718 
      result.ex = ex
6719 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
6723 
 
1382 varun.gupt 6724 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6725 
    args = getReturnableOrdersForCustomer_args()
6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
6728 
    result = getReturnableOrdersForCustomer_result()
6729 
    try:
6730 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6731 
    except TransactionServiceException, ex:
6732 
      result.ex = ex
6733 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
6737 
 
6738 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6739 
    args = getCancellableOrdersForCustomer_args()
6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
6742 
    result = getCancellableOrdersForCustomer_result()
6743 
    try:
6744 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6745 
    except TransactionServiceException, ex:
6746 
      result.ex = ex
6747 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
483 rajveer 6752 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6753 
    args = changeOrderStatus_args()
94 ashish 6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
483 rajveer 6756 
    result = changeOrderStatus_result()
94 ashish 6757 
    try:
483 rajveer 6758 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6759 
    except TransactionServiceException, ex:
6760 
      result.ex = ex
483 rajveer 6761 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
6765 
 
483 rajveer 6766 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6767 
    args = getOrdersForTransaction_args()
94 ashish 6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
483 rajveer 6770 
    result = getOrdersForTransaction_result()
94 ashish 6771 
    try:
1528 ankur.sing 6772 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6773 
    except TransactionServiceException, ex:
6774 
      result.ex = ex
483 rajveer 6775 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6776 
    result.write(oprot)
6777 
    oprot.writeMessageEnd()
6778 
    oprot.trans.flush()
6779 
 
483 rajveer 6780 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6781 
    args = getOrdersForCustomer_args()
94 ashish 6782 
    args.read(iprot)
6783 
    iprot.readMessageEnd()
483 rajveer 6784 
    result = getOrdersForCustomer_result()
94 ashish 6785 
    try:
3014 chandransh 6786 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6787 
    except TransactionServiceException, ex:
6788 
      result.ex = ex
483 rajveer 6789 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6790 
    result.write(oprot)
6791 
    oprot.writeMessageEnd()
6792 
    oprot.trans.flush()
6793 
 
483 rajveer 6794 
  def process_createOrder(self, seqid, iprot, oprot):
6795 
    args = createOrder_args()
94 ashish 6796 
    args.read(iprot)
6797 
    iprot.readMessageEnd()
483 rajveer 6798 
    result = createOrder_result()
94 ashish 6799 
    try:
483 rajveer 6800 
      result.success = self._handler.createOrder(args.order)
94 ashish 6801 
    except TransactionServiceException, ex:
6802 
      result.ex = ex
483 rajveer 6803 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6804 
    result.write(oprot)
6805 
    oprot.writeMessageEnd()
6806 
    oprot.trans.flush()
6807 
 
483 rajveer 6808 
  def process_getOrder(self, seqid, iprot, oprot):
6809 
    args = getOrder_args()
94 ashish 6810 
    args.read(iprot)
6811 
    iprot.readMessageEnd()
483 rajveer 6812 
    result = getOrder_result()
94 ashish 6813 
    try:
483 rajveer 6814 
      result.success = self._handler.getOrder(args.id)
94 ashish 6815 
    except TransactionServiceException, ex:
6816 
      result.ex = ex
483 rajveer 6817 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6818 
    result.write(oprot)
6819 
    oprot.writeMessageEnd()
6820 
    oprot.trans.flush()
6821 
 
483 rajveer 6822 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6823 
    args = getLineItemsForOrder_args()
94 ashish 6824 
    args.read(iprot)
6825 
    iprot.readMessageEnd()
483 rajveer 6826 
    result = getLineItemsForOrder_result()
94 ashish 6827 
    try:
483 rajveer 6828 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6829 
    except TransactionServiceException, ex:
6830 
      result.ex = ex
483 rajveer 6831 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6832 
    result.write(oprot)
6833 
    oprot.writeMessageEnd()
6834 
    oprot.trans.flush()
6835 
 
4999 phani.kuma 6836 
  def process_getOrderList(self, seqid, iprot, oprot):
6837 
    args = getOrderList_args()
6838 
    args.read(iprot)
6839 
    iprot.readMessageEnd()
6840 
    result = getOrderList_result()
6841 
    result.success = self._handler.getOrderList(args.order_ids)
6842 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6843 
    result.write(oprot)
6844 
    oprot.writeMessageEnd()
6845 
    oprot.trans.flush()
6846 
 
5386 phani.kuma 6847 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6848 
    args = getOrderListForVendor_args()
6849 
    args.read(iprot)
6850 
    iprot.readMessageEnd()
6851 
    result = getOrderListForVendor_result()
6852 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6853 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6854 
    result.write(oprot)
6855 
    oprot.writeMessageEnd()
6856 
    oprot.trans.flush()
6857 
 
1528 ankur.sing 6858 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6859 
    args = getOrderForCustomer_args()
6860 
    args.read(iprot)
6861 
    iprot.readMessageEnd()
6862 
    result = getOrderForCustomer_result()
6863 
    try:
6864 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6865 
    except TransactionServiceException, ex:
6866 
      result.ex = ex
6867 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6868 
    result.write(oprot)
6869 
    oprot.writeMessageEnd()
6870 
    oprot.trans.flush()
6871 
 
3064 chandransh 6872 
  def process_getAlerts(self, seqid, iprot, oprot):
6873 
    args = getAlerts_args()
6874 
    args.read(iprot)
6875 
    iprot.readMessageEnd()
6876 
    result = getAlerts_result()
4444 rajveer 6877 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6878 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
6882 
 
4394 rajveer 6883 
  def process_addAlert(self, seqid, iprot, oprot):
6884 
    args = addAlert_args()
3064 chandransh 6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
4394 rajveer 6887 
    result = addAlert_result()
4444 rajveer 6888 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6889 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6890 
    result.write(oprot)
6891 
    oprot.writeMessageEnd()
6892 
    oprot.trans.flush()
6893 
 
4444 rajveer 6894 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6895 
    args = markAlertsAsSeen_args()
6896 
    args.read(iprot)
6897 
    iprot.readMessageEnd()
6898 
    result = markAlertsAsSeen_result()
6899 
    self._handler.markAlertsAsSeen(args.warehouseId)
6900 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6901 
    result.write(oprot)
6902 
    oprot.writeMessageEnd()
6903 
    oprot.trans.flush()
6904 
 
3064 chandransh 6905 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6906 
    args = getValidOrderCount_args()
6907 
    args.read(iprot)
6908 
    iprot.readMessageEnd()
6909 
    result = getValidOrderCount_result()
6910 
    result.success = self._handler.getValidOrderCount()
6911 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6912 
    result.write(oprot)
6913 
    oprot.writeMessageEnd()
6914 
    oprot.trans.flush()
6915 
 
6916 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6917 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6918 
    args.read(iprot)
6919 
    iprot.readMessageEnd()
6920 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6921 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6922 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6923 
    result.write(oprot)
6924 
    oprot.writeMessageEnd()
6925 
    oprot.trans.flush()
6926 
 
6927 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6928 
    args = getValidOrdersAmountRange_args()
6929 
    args.read(iprot)
6930 
    iprot.readMessageEnd()
6931 
    result = getValidOrdersAmountRange_result()
6932 
    result.success = self._handler.getValidOrdersAmountRange()
6933 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6934 
    result.write(oprot)
6935 
    oprot.writeMessageEnd()
6936 
    oprot.trans.flush()
6937 
 
6938 
  def process_getValidOrders(self, seqid, iprot, oprot):
6939 
    args = getValidOrders_args()
6940 
    args.read(iprot)
6941 
    iprot.readMessageEnd()
6942 
    result = getValidOrders_result()
5874 rajveer 6943 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6944 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6945 
    result.write(oprot)
6946 
    oprot.writeMessageEnd()
6947 
    oprot.trans.flush()
6948 
 
1220 chandransh 6949 
  def process_batchOrders(self, seqid, iprot, oprot):
6950 
    args = batchOrders_args()
6951 
    args.read(iprot)
6952 
    iprot.readMessageEnd()
6953 
    result = batchOrders_result()
6954 
    try:
6955 
      result.success = self._handler.batchOrders(args.warehouseId)
6956 
    except TransactionServiceException, ex:
6957 
      result.ex = ex
6958 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6959 
    result.write(oprot)
6960 
    oprot.writeMessageEnd()
6961 
    oprot.trans.flush()
6962 
 
1208 chandransh 6963 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6964 
    args = markOrderAsOutOfStock_args()
6965 
    args.read(iprot)
6966 
    iprot.readMessageEnd()
6967 
    result = markOrderAsOutOfStock_result()
6968 
    try:
6969 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6970 
    except TransactionServiceException, ex:
6971 
      result.ex = ex
6972 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6973 
    result.write(oprot)
6974 
    oprot.writeMessageEnd()
6975 
    oprot.trans.flush()
6976 
 
3064 chandransh 6977 
  def process_verifyOrder(self, seqid, iprot, oprot):
6978 
    args = verifyOrder_args()
759 chandransh 6979 
    args.read(iprot)
6980 
    iprot.readMessageEnd()
3064 chandransh 6981 
    result = verifyOrder_result()
759 chandransh 6982 
    try:
3064 chandransh 6983 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6984 
    except TransactionServiceException, ex:
6985 
      result.ex = ex
3064 chandransh 6986 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6987 
    result.write(oprot)
6988 
    oprot.writeMessageEnd()
6989 
    oprot.trans.flush()
6990 
 
3064 chandransh 6991 
  def process_acceptOrder(self, seqid, iprot, oprot):
6992 
    args = acceptOrder_args()
1113 chandransh 6993 
    args.read(iprot)
6994 
    iprot.readMessageEnd()
3064 chandransh 6995 
    result = acceptOrder_result()
1113 chandransh 6996 
    try:
3064 chandransh 6997 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6998 
    except TransactionServiceException, ex:
6999 
      result.ex = ex
3064 chandransh 7000 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7001 
    result.write(oprot)
7002 
    oprot.writeMessageEnd()
7003 
    oprot.trans.flush()
7004 
 
3064 chandransh 7005 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7006 
    args = addBillingDetails_args()
1135 chandransh 7007 
    args.read(iprot)
7008 
    iprot.readMessageEnd()
3064 chandransh 7009 
    result = addBillingDetails_result()
1135 chandransh 7010 
    try:
5110 mandeep.dh 7011 
      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 7012 
    except TransactionServiceException, ex:
7013 
      result.ex = ex
3064 chandransh 7014 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7015 
    result.write(oprot)
7016 
    oprot.writeMessageEnd()
7017 
    oprot.trans.flush()
7018 
 
4579 rajveer 7019 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7020 
    args = addInvoiceNumber_args()
7021 
    args.read(iprot)
7022 
    iprot.readMessageEnd()
7023 
    result = addInvoiceNumber_result()
7024 
    try:
4763 rajveer 7025 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7026 
    except TransactionServiceException, ex:
7027 
      result.ex = ex
7028 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7029 
    result.write(oprot)
7030 
    oprot.writeMessageEnd()
7031 
    oprot.trans.flush()
7032 
 
4410 rajveer 7033 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7034 
    args = markOrdersAsShippedFromWarehouse_args()
7035 
    args.read(iprot)
7036 
    iprot.readMessageEnd()
7037 
    result = markOrdersAsShippedFromWarehouse_result()
7038 
    try:
4789 rajveer 7039 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7040 
    except TransactionServiceException, ex:
7041 
      result.ex = ex
7042 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7043 
    result.write(oprot)
7044 
    oprot.writeMessageEnd()
7045 
    oprot.trans.flush()
7046 
 
5676 rajveer 7047 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7048 
    args = markOrdersAsReturnedFromStore_args()
7049 
    args.read(iprot)
7050 
    iprot.readMessageEnd()
7051 
    result = markOrdersAsReturnedFromStore_result()
7052 
    try:
5713 rajveer 7053 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7054 
    except TransactionServiceException, ex:
7055 
      result.ex = ex
7056 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7057 
    result.write(oprot)
7058 
    oprot.writeMessageEnd()
7059 
    oprot.trans.flush()
7060 
 
3064 chandransh 7061 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7062 
    args = markOrdersAsPickedUp_args()
304 ashish 7063 
    args.read(iprot)
7064 
    iprot.readMessageEnd()
3064 chandransh 7065 
    result = markOrdersAsPickedUp_result()
7066 
    try:
4910 phani.kuma 7067 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7068 
    except TransactionServiceException, ex:
7069 
      result.ex = ex
7070 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7071 
    result.write(oprot)
7072 
    oprot.writeMessageEnd()
7073 
    oprot.trans.flush()
94 ashish 7074 
 
4910 phani.kuma 7075 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7076 
    args = getOrdersNotPickedUp_args()
7077 
    args.read(iprot)
7078 
    iprot.readMessageEnd()
7079 
    result = getOrdersNotPickedUp_result()
7080 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7081 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7082 
    result.write(oprot)
7083 
    oprot.writeMessageEnd()
7084 
    oprot.trans.flush()
7085 
 
3064 chandransh 7086 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7087 
    args = markOrdersAsDelivered_args()
304 ashish 7088 
    args.read(iprot)
7089 
    iprot.readMessageEnd()
3064 chandransh 7090 
    result = markOrdersAsDelivered_result()
7091 
    try:
7092 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7093 
    except TransactionServiceException, ex:
7094 
      result.ex = ex
7095 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7096 
    result.write(oprot)
7097 
    oprot.writeMessageEnd()
7098 
    oprot.trans.flush()
7099 
 
4910 phani.kuma 7100 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7101 
    args = markAsRTOrders_args()
1596 ankur.sing 7102 
    args.read(iprot)
7103 
    iprot.readMessageEnd()
4910 phani.kuma 7104 
    result = markAsRTOrders_result()
3064 chandransh 7105 
    try:
4910 phani.kuma 7106 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7107 
    except TransactionServiceException, ex:
7108 
      result.ex = ex
4910 phani.kuma 7109 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7110 
    result.write(oprot)
7111 
    oprot.writeMessageEnd()
7112 
    oprot.trans.flush()
304 ashish 7113 
 
4910 phani.kuma 7114 
  def process_getRTOrders(self, seqid, iprot, oprot):
7115 
    args = getRTOrders_args()
7116 
    args.read(iprot)
7117 
    iprot.readMessageEnd()
7118 
    result = getRTOrders_result()
7119 
    result.success = self._handler.getRTOrders(args.providerId)
7120 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7121 
    result.write(oprot)
7122 
    oprot.writeMessageEnd()
7123 
    oprot.trans.flush()
7124 
 
3064 chandransh 7125 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7126 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7127 
    args.read(iprot)
7128 
    iprot.readMessageEnd()
3064 chandransh 7129 
    result = updateNonDeliveryReason_result()
7130 
    try:
4910 phani.kuma 7131 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7132 
    except TransactionServiceException, ex:
7133 
      result.ex = ex
7134 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
1596 ankur.sing 7138 
 
4910 phani.kuma 7139 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7140 
    args = getNonDeliveredOrdersbyCourier_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = getNonDeliveredOrdersbyCourier_result()
7144 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7145 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7146 
    result.write(oprot)
7147 
    oprot.writeMessageEnd()
7148 
    oprot.trans.flush()
7149 
 
7150 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7151 
    args = markOrdersAsLocalConnected_args()
7152 
    args.read(iprot)
7153 
    iprot.readMessageEnd()
7154 
    result = markOrdersAsLocalConnected_result()
7155 
    try:
7156 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7157 
    except TransactionServiceException, ex:
7158 
      result.ex = ex
7159 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
7163 
 
7164 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7165 
    args = getOrdersNotLocalConnected_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getOrdersNotLocalConnected_result()
7169 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7170 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
7174 
 
7175 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7176 
    args = markOrdersAsDestinationCityReached_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = markOrdersAsDestinationCityReached_result()
7180 
    try:
7181 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7182 
    except TransactionServiceException, ex:
7183 
      result.ex = ex
7184 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7185 
    result.write(oprot)
7186 
    oprot.writeMessageEnd()
7187 
    oprot.trans.flush()
7188 
 
7189 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7190 
    args = markOrdersAsFirstDeliveryAttempted_args()
7191 
    args.read(iprot)
7192 
    iprot.readMessageEnd()
7193 
    result = markOrdersAsFirstDeliveryAttempted_result()
7194 
    try:
7195 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7196 
    except TransactionServiceException, ex:
7197 
      result.ex = ex
7198 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7199 
    result.write(oprot)
7200 
    oprot.writeMessageEnd()
7201 
    oprot.trans.flush()
7202 
 
3064 chandransh 7203 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7204 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7205 
    args.read(iprot)
7206 
    iprot.readMessageEnd()
3064 chandransh 7207 
    result = getUndeliveredOrders_result()
7208 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7209 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7210 
    result.write(oprot)
7211 
    oprot.writeMessageEnd()
7212 
    oprot.trans.flush()
7213 
 
4783 phani.kuma 7214 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7215 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7216 
    args.read(iprot)
7217 
    iprot.readMessageEnd()
7218 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7219 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7220 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7221 
    result.write(oprot)
7222 
    oprot.writeMessageEnd()
7223 
    oprot.trans.flush()
7224 
 
2536 chandransh 7225 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7226 
    args = toggleDOAFlag_args()
7227 
    args.read(iprot)
7228 
    iprot.readMessageEnd()
7229 
    result = toggleDOAFlag_result()
7230 
    try:
7231 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7232 
    except TransactionServiceException, ex:
7233 
      result.ex = ex
7234 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7235 
    result.write(oprot)
7236 
    oprot.writeMessageEnd()
7237 
    oprot.trans.flush()
1886 ankur.sing 7238 
 
4712 rajveer 7239 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7240 
    args = markOrderAsDelivered_args()
7241 
    args.read(iprot)
7242 
    iprot.readMessageEnd()
7243 
    result = markOrderAsDelivered_result()
7244 
    try:
7245 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7246 
    except TransactionServiceException, ex:
7247 
      result.ex = ex
7248 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7249 
    result.write(oprot)
7250 
    oprot.writeMessageEnd()
7251 
    oprot.trans.flush()
7252 
 
5553 rajveer 7253 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7254 
    args = markOrderAsReceivedAtStore_args()
7255 
    args.read(iprot)
7256 
    iprot.readMessageEnd()
7257 
    result = markOrderAsReceivedAtStore_result()
7258 
    try:
7259 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7260 
    except TransactionServiceException, ex:
7261 
      result.ex = ex
7262 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7263 
    result.write(oprot)
7264 
    oprot.writeMessageEnd()
7265 
    oprot.trans.flush()
7266 
 
4454 rajveer 7267 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7268 
    args = markOrderDoaRequestReceived_args()
7269 
    args.read(iprot)
7270 
    iprot.readMessageEnd()
7271 
    result = markOrderDoaRequestReceived_result()
7272 
    try:
7273 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7274 
    except TransactionServiceException, ex:
7275 
      result.ex = ex
7276 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7277 
    result.write(oprot)
7278 
    oprot.writeMessageEnd()
7279 
    oprot.trans.flush()
7280 
 
7281 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7282 
    args = markOrderDoaRequestAuthorized_args()
7283 
    args.read(iprot)
7284 
    iprot.readMessageEnd()
7285 
    result = markOrderDoaRequestAuthorized_result()
7286 
    try:
7287 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7288 
    except TransactionServiceException, ex:
7289 
      result.ex = ex
7290 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7291 
    result.write(oprot)
7292 
    oprot.writeMessageEnd()
7293 
    oprot.trans.flush()
7294 
 
4488 rajveer 7295 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7296 
    args = markOrderReturnRequestReceived_args()
7297 
    args.read(iprot)
7298 
    iprot.readMessageEnd()
7299 
    result = markOrderReturnRequestReceived_result()
7300 
    try:
7301 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7302 
    except TransactionServiceException, ex:
7303 
      result.ex = ex
7304 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7305 
    result.write(oprot)
7306 
    oprot.writeMessageEnd()
7307 
    oprot.trans.flush()
7308 
 
7309 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7310 
    args = markOrderReturnRequestAuthorized_args()
7311 
    args.read(iprot)
7312 
    iprot.readMessageEnd()
7313 
    result = markOrderReturnRequestAuthorized_result()
7314 
    try:
7315 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7316 
    except TransactionServiceException, ex:
7317 
      result.ex = ex
7318 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7319 
    result.write(oprot)
7320 
    oprot.writeMessageEnd()
7321 
    oprot.trans.flush()
7322 
 
2536 chandransh 7323 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7324 
    args = requestPickupNumber_args()
7325 
    args.read(iprot)
7326 
    iprot.readMessageEnd()
7327 
    result = requestPickupNumber_result()
7328 
    try:
4579 rajveer 7329 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7330 
    except TransactionServiceException, ex:
7331 
      result.ex = ex
7332 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7336 
 
7337 
  def process_authorizePickup(self, seqid, iprot, oprot):
7338 
    args = authorizePickup_args()
7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
7341 
    result = authorizePickup_result()
7342 
    try:
4602 rajveer 7343 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7344 
    except TransactionServiceException, ex:
7345 
      result.ex = ex
7346 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
7350 
 
2764 chandransh 7351 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7352 
    args = markDoasAsPickedUp_args()
7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
7355 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7356 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7357 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7358 
    result.write(oprot)
7359 
    oprot.writeMessageEnd()
7360 
    oprot.trans.flush()
7361 
 
4910 phani.kuma 7362 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7363 
    args = getDoasNotPickedUp_args()
7364 
    args.read(iprot)
7365 
    iprot.readMessageEnd()
7366 
    result = getDoasNotPickedUp_result()
7367 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7368 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7369 
    result.write(oprot)
7370 
    oprot.writeMessageEnd()
7371 
    oprot.trans.flush()
7372 
 
4741 phani.kuma 7373 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7374 
    args = markReturnOrdersAsPickedUp_args()
7375 
    args.read(iprot)
7376 
    iprot.readMessageEnd()
7377 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7378 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7379 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7380 
    result.write(oprot)
7381 
    oprot.writeMessageEnd()
7382 
    oprot.trans.flush()
7383 
 
4910 phani.kuma 7384 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7385 
    args = getReturnOrdersNotPickedUp_args()
7386 
    args.read(iprot)
7387 
    iprot.readMessageEnd()
7388 
    result = getReturnOrdersNotPickedUp_result()
7389 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7390 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7391 
    result.write(oprot)
7392 
    oprot.writeMessageEnd()
7393 
    oprot.trans.flush()
7394 
 
2616 chandransh 7395 
  def process_receiveReturn(self, seqid, iprot, oprot):
7396 
    args = receiveReturn_args()
2591 chandransh 7397 
    args.read(iprot)
7398 
    iprot.readMessageEnd()
2616 chandransh 7399 
    result = receiveReturn_result()
2591 chandransh 7400 
    try:
4479 rajveer 7401 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7402 
    except TransactionServiceException, ex:
7403 
      result.ex = ex
2616 chandransh 7404 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7405 
    result.write(oprot)
7406 
    oprot.writeMessageEnd()
7407 
    oprot.trans.flush()
2536 chandransh 7408 
 
2591 chandransh 7409 
  def process_validateDoa(self, seqid, iprot, oprot):
7410 
    args = validateDoa_args()
7411 
    args.read(iprot)
7412 
    iprot.readMessageEnd()
7413 
    result = validateDoa_result()
7414 
    try:
7415 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7416 
    except TransactionServiceException, ex:
7417 
      result.ex = ex
7418 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7419 
    result.write(oprot)
7420 
    oprot.writeMessageEnd()
7421 
    oprot.trans.flush()
7422 
 
4495 rajveer 7423 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7424 
    args = validateReturnProduct_args()
7425 
    args.read(iprot)
7426 
    iprot.readMessageEnd()
7427 
    result = validateReturnProduct_result()
7428 
    try:
7429 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7430 
    except TransactionServiceException, ex:
7431 
      result.ex = ex
7432 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7433 
    result.write(oprot)
7434 
    oprot.writeMessageEnd()
7435 
    oprot.trans.flush()
7436 
 
2616 chandransh 7437 
  def process_reshipOrder(self, seqid, iprot, oprot):
7438 
    args = reshipOrder_args()
7439 
    args.read(iprot)
7440 
    iprot.readMessageEnd()
7441 
    result = reshipOrder_result()
7442 
    try:
7443 
      result.success = self._handler.reshipOrder(args.orderId)
7444 
    except TransactionServiceException, ex:
7445 
      result.ex = ex
7446 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7447 
    result.write(oprot)
7448 
    oprot.writeMessageEnd()
7449 
    oprot.trans.flush()
2591 chandransh 7450 
 
2616 chandransh 7451 
  def process_refundOrder(self, seqid, iprot, oprot):
7452 
    args = refundOrder_args()
7453 
    args.read(iprot)
7454 
    iprot.readMessageEnd()
7455 
    result = refundOrder_result()
7456 
    try:
3226 chandransh 7457 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7458 
    except TransactionServiceException, ex:
7459 
      result.ex = ex
7460 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7461 
    result.write(oprot)
7462 
    oprot.writeMessageEnd()
7463 
    oprot.trans.flush()
7464 
 
2690 chandransh 7465 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7466 
    args = getReturnOrders_args()
7467 
    args.read(iprot)
7468 
    iprot.readMessageEnd()
7469 
    result = getReturnOrders_result()
7470 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7471 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7472 
    result.write(oprot)
7473 
    oprot.writeMessageEnd()
7474 
    oprot.trans.flush()
2616 chandransh 7475 
 
5481 phani.kuma 7476 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7477 
    args = getAllReturnOrders_args()
7478 
    args.read(iprot)
7479 
    iprot.readMessageEnd()
7480 
    result = getAllReturnOrders_result()
7481 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7482 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7483 
    result.write(oprot)
7484 
    oprot.writeMessageEnd()
7485 
    oprot.trans.flush()
7486 
 
2700 chandransh 7487 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7488 
    args = getReturnOrder_args()
7489 
    args.read(iprot)
7490 
    iprot.readMessageEnd()
7491 
    result = getReturnOrder_result()
7492 
    try:
7493 
      result.success = self._handler.getReturnOrder(args.id)
7494 
    except TransactionServiceException, ex:
7495 
      result.ex = ex
7496 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7497 
    result.write(oprot)
7498 
    oprot.writeMessageEnd()
7499 
    oprot.trans.flush()
7500 
 
2690 chandransh 7501 
  def process_processReturn(self, seqid, iprot, oprot):
7502 
    args = processReturn_args()
7503 
    args.read(iprot)
7504 
    iprot.readMessageEnd()
7505 
    result = processReturn_result()
7506 
    try:
7507 
      self._handler.processReturn(args.returnOrderId)
7508 
    except TransactionServiceException, ex:
7509 
      result.ex = ex
7510 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7511 
    result.write(oprot)
7512 
    oprot.writeMessageEnd()
7513 
    oprot.trans.flush()
7514 
 
3451 chandransh 7515 
  def process_updateWeight(self, seqid, iprot, oprot):
7516 
    args = updateWeight_args()
7517 
    args.read(iprot)
7518 
    iprot.readMessageEnd()
7519 
    result = updateWeight_result()
7520 
    try:
7521 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7522 
    except TransactionServiceException, ex:
7523 
      result.ex = ex
7524 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7525 
    result.write(oprot)
7526 
    oprot.writeMessageEnd()
7527 
    oprot.trans.flush()
2819 chandransh 7528 
 
3469 chandransh 7529 
  def process_changeItem(self, seqid, iprot, oprot):
7530 
    args = changeItem_args()
7531 
    args.read(iprot)
7532 
    iprot.readMessageEnd()
7533 
    result = changeItem_result()
7534 
    try:
7535 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7536 
    except TransactionServiceException, ex:
7537 
      result.ex = ex
7538 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7539 
    result.write(oprot)
7540 
    oprot.writeMessageEnd()
7541 
    oprot.trans.flush()
3451 chandransh 7542 
 
3469 chandransh 7543 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7544 
    args = shiftToWarehouse_args()
7545 
    args.read(iprot)
7546 
    iprot.readMessageEnd()
7547 
    result = shiftToWarehouse_result()
7548 
    try:
7549 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7550 
    except TransactionServiceException, ex:
7551 
      result.ex = ex
7552 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7553 
    result.write(oprot)
7554 
    oprot.writeMessageEnd()
7555 
    oprot.trans.flush()
7556 
 
3553 chandransh 7557 
  def process_addDelayReason(self, seqid, iprot, oprot):
7558 
    args = addDelayReason_args()
7559 
    args.read(iprot)
7560 
    iprot.readMessageEnd()
7561 
    result = addDelayReason_result()
7562 
    try:
4647 rajveer 7563 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7564 
    except TransactionServiceException, ex:
7565 
      result.ex = ex
7566 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7567 
    result.write(oprot)
7568 
    oprot.writeMessageEnd()
7569 
    oprot.trans.flush()
3469 chandransh 7570 
 
3956 chandransh 7571 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7572 
    args = reconcileCodCollection_args()
7573 
    args.read(iprot)
7574 
    iprot.readMessageEnd()
7575 
    result = reconcileCodCollection_result()
7576 
    try:
7577 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7578 
    except TransactionServiceException, ex:
7579 
      result.ex = ex
7580 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7581 
    result.write(oprot)
7582 
    oprot.writeMessageEnd()
7583 
    oprot.trans.flush()
3553 chandransh 7584 
 
4008 mandeep.dh 7585 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7586 
    args = getTransactionsRequiringExtraProcessing_args()
7587 
    args.read(iprot)
7588 
    iprot.readMessageEnd()
7589 
    result = getTransactionsRequiringExtraProcessing_result()
7590 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7591 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7592 
    result.write(oprot)
7593 
    oprot.writeMessageEnd()
7594 
    oprot.trans.flush()
3956 chandransh 7595 
 
4008 mandeep.dh 7596 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7597 
    args = markTransactionAsProcessed_args()
7598 
    args.read(iprot)
7599 
    iprot.readMessageEnd()
7600 
    result = markTransactionAsProcessed_result()
7601 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7602 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7603 
    result.write(oprot)
7604 
    oprot.writeMessageEnd()
7605 
    oprot.trans.flush()
7606 
 
4018 chandransh 7607 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7608 
    args = getItemWiseRiskyOrdersCount_args()
7609 
    args.read(iprot)
7610 
    iprot.readMessageEnd()
7611 
    result = getItemWiseRiskyOrdersCount_result()
7612 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7613 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7614 
    result.write(oprot)
7615 
    oprot.writeMessageEnd()
7616 
    oprot.trans.flush()
4008 mandeep.dh 7617 
 
4295 varun.gupt 7618 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7619 
    args = getOrdersForItemIds_args()
7620 
    args.read(iprot)
7621 
    iprot.readMessageEnd()
7622 
    result = getOrdersForItemIds_result()
7623 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7624 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7625 
    result.write(oprot)
7626 
    oprot.writeMessageEnd()
7627 
    oprot.trans.flush()
7628 
 
4247 rajveer 7629 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7630 
    args = markOrderCancellationRequestReceived_args()
7631 
    args.read(iprot)
7632 
    iprot.readMessageEnd()
7633 
    result = markOrderCancellationRequestReceived_result()
7634 
    try:
7635 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7636 
    except TransactionServiceException, ex:
7637 
      result.ex = ex
7638 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7639 
    result.write(oprot)
7640 
    oprot.writeMessageEnd()
7641 
    oprot.trans.flush()
4018 chandransh 7642 
 
4247 rajveer 7643 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7644 
    args = markOrderCancellationRequestConfirmed_args()
7645 
    args.read(iprot)
7646 
    iprot.readMessageEnd()
7647 
    result = markOrderCancellationRequestConfirmed_result()
7648 
    try:
7649 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7650 
    except TransactionServiceException, ex:
7651 
      result.ex = ex
7652 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7653 
    result.write(oprot)
7654 
    oprot.writeMessageEnd()
7655 
    oprot.trans.flush()
7656 
 
7657 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7658 
    args = markOrderCancellationRequestDenied_args()
7659 
    args.read(iprot)
7660 
    iprot.readMessageEnd()
7661 
    result = markOrderCancellationRequestDenied_result()
7662 
    try:
7663 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7664 
    except TransactionServiceException, ex:
7665 
      result.ex = ex
7666 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7667 
    result.write(oprot)
7668 
    oprot.writeMessageEnd()
7669 
    oprot.trans.flush()
7670 
 
4258 rajveer 7671 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7672 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7673 
    args.read(iprot)
7674 
    iprot.readMessageEnd()
4258 rajveer 7675 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7676 
    try:
4258 rajveer 7677 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7678 
    except TransactionServiceException, ex:
7679 
      result.ex = ex
4258 rajveer 7680 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7681 
    result.write(oprot)
7682 
    oprot.writeMessageEnd()
7683 
    oprot.trans.flush()
7684 
 
4259 anupam.sin 7685 
  def process_refundTransaction(self, seqid, iprot, oprot):
7686 
    args = refundTransaction_args()
7687 
    args.read(iprot)
7688 
    iprot.readMessageEnd()
7689 
    result = refundTransaction_result()
7690 
    try:
7691 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7692 
    except TransactionServiceException, ex:
7693 
      result.ex = ex
7694 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7695 
    result.write(oprot)
7696 
    oprot.writeMessageEnd()
7697 
    oprot.trans.flush()
4247 rajveer 7698 
 
4324 mandeep.dh 7699 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7700 
    args = updateShipmentAddress_args()
7701 
    args.read(iprot)
7702 
    iprot.readMessageEnd()
7703 
    result = updateShipmentAddress_result()
7704 
    try:
7705 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7706 
    except TransactionServiceException, ex:
7707 
      result.ex = ex
7708 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7709 
    result.write(oprot)
7710 
    oprot.writeMessageEnd()
7711 
    oprot.trans.flush()
7712 
 
4285 rajveer 7713 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7714 
    args = acceptOrdersForItemId_args()
7715 
    args.read(iprot)
7716 
    iprot.readMessageEnd()
7717 
    result = acceptOrdersForItemId_result()
7718 
    try:
7719 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7720 
    except TransactionServiceException, ex:
7721 
      result.ex = ex
7722 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7723 
    result.write(oprot)
7724 
    oprot.writeMessageEnd()
7725 
    oprot.trans.flush()
4259 anupam.sin 7726 
 
4303 rajveer 7727 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7728 
    args = markOrdersAsPORaised_args()
7729 
    args.read(iprot)
7730 
    iprot.readMessageEnd()
7731 
    result = markOrdersAsPORaised_result()
7732 
    try:
4369 rajveer 7733 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7734 
    except TransactionServiceException, ex:
7735 
      result.ex = ex
7736 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7737 
    result.write(oprot)
7738 
    oprot.writeMessageEnd()
7739 
    oprot.trans.flush()
4285 rajveer 7740 
 
4303 rajveer 7741 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7742 
    args = markOrdersAsReversalInitiated_args()
7743 
    args.read(iprot)
7744 
    iprot.readMessageEnd()
7745 
    result = markOrdersAsReversalInitiated_result()
7746 
    try:
4369 rajveer 7747 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7748 
    except TransactionServiceException, ex:
7749 
      result.ex = ex
7750 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7751 
    result.write(oprot)
7752 
    oprot.writeMessageEnd()
7753 
    oprot.trans.flush()
7754 
 
7755 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7756 
    args = markOrdersAsNotAvailabke_args()
7757 
    args.read(iprot)
7758 
    iprot.readMessageEnd()
7759 
    result = markOrdersAsNotAvailabke_result()
7760 
    try:
4369 rajveer 7761 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7762 
    except TransactionServiceException, ex:
7763 
      result.ex = ex
7764 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7765 
    result.write(oprot)
7766 
    oprot.writeMessageEnd()
7767 
    oprot.trans.flush()
7768 
 
4369 rajveer 7769 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7770 
    args = markOrdersAsTimeout_args()
7771 
    args.read(iprot)
7772 
    iprot.readMessageEnd()
7773 
    result = markOrdersAsTimeout_result()
7774 
    try:
7775 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7776 
    except TransactionServiceException, ex:
7777 
      result.ex = ex
7778 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
4303 rajveer 7782 
 
4662 rajveer 7783 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7784 
    args = markOrderAsLostInTransit_args()
7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
7787 
    result = markOrderAsLostInTransit_result()
7788 
    try:
7789 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7790 
    except TransactionServiceException, ex:
7791 
      result.ex = ex
7792 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
4386 anupam.sin 7797 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7798 
    args = getOrderForAwb_args()
7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
7801 
    result = getOrderForAwb_result()
7802 
    try:
7803 
      result.success = self._handler.getOrderForAwb(args.awb)
7804 
    except TransactionServiceException, ex:
7805 
      result.ex = ex
7806 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
4369 rajveer 7810 
 
4506 phani.kuma 7811 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7812 
    args = getOrdersForProviderForStatus_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = getOrdersForProviderForStatus_result()
7816 
    try:
4910 phani.kuma 7817 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7818 
    except TransactionServiceException, ex:
7819 
      result.ex = ex
7820 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
4386 anupam.sin 7824 
 
4600 varun.gupt 7825 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7826 
    args = getBilledOrdersForVendor_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = getBilledOrdersForVendor_result()
7830 
    try:
7831 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7832 
    except TransactionServiceException, ex:
7833 
      result.ex = ex
7834 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
4506 phani.kuma 7838 
 
4607 rajveer 7839 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7840 
    args = getSlippedSippingDateOrders_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = getSlippedSippingDateOrders_result()
7844 
    try:
7845 
      result.success = self._handler.getSlippedSippingDateOrders()
7846 
    except TransactionServiceException, ex:
7847 
      result.ex = ex
7848 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
7852 
 
4709 rajveer 7853 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7854 
    args = getCancelledOrders_args()
7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
7857 
    result = getCancelledOrders_result()
7858 
    try:
7859 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7860 
    except TransactionServiceException, ex:
7861 
      result.ex = ex
7862 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
4600 varun.gupt 7867 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7868 
    args = saveBluedartSettlements_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = saveBluedartSettlements_result()
7872 
    try:
7873 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7874 
    except TransactionServiceException, ex:
7875 
      result.ex = ex
7876 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
7880 
 
7881 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7882 
    args = savePaymentSettlements_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = savePaymentSettlements_result()
7886 
    try:
4905 varun.gupt 7887 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7888 
    except TransactionServiceException, ex:
7889 
      result.ex = ex
7890 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7891 
    result.write(oprot)
7892 
    oprot.writeMessageEnd()
7893 
    oprot.trans.flush()
7894 
 
7895 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7896 
    args = saveEBSSettlementSummary_args()
7897 
    args.read(iprot)
7898 
    iprot.readMessageEnd()
7899 
    result = saveEBSSettlementSummary_result()
7900 
    try:
7901 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7902 
    except TransactionServiceException, ex:
7903 
      result.ex = ex
7904 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7905 
    result.write(oprot)
7906 
    oprot.writeMessageEnd()
7907 
    oprot.trans.flush()
7908 
 
5386 phani.kuma 7909 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7910 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7911 
    args.read(iprot)
7912 
    iprot.readMessageEnd()
5386 phani.kuma 7913 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7914 
    try:
5386 phani.kuma 7915 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7916 
    except TransactionServiceException, ex:
7917 
      result.ex = ex
5386 phani.kuma 7918 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7919 
    result.write(oprot)
7920 
    oprot.writeMessageEnd()
7921 
    oprot.trans.flush()
7922 
 
5386 phani.kuma 7923 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7924 
    args = getSettlementForCod_args()
7925 
    args.read(iprot)
7926 
    iprot.readMessageEnd()
7927 
    result = getSettlementForCod_result()
7928 
    try:
7929 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7930 
    except TransactionServiceException, ex:
7931 
      result.ex = ex
7932 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7933 
    result.write(oprot)
7934 
    oprot.writeMessageEnd()
7935 
    oprot.trans.flush()
7936 
 
4600 varun.gupt 7937 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7938 
    args = getEBSSettlementSummaries_args()
7939 
    args.read(iprot)
7940 
    iprot.readMessageEnd()
7941 
    result = getEBSSettlementSummaries_result()
7942 
    try:
7943 
      result.success = self._handler.getEBSSettlementSummaries()
7944 
    except TransactionServiceException, ex:
7945 
      result.ex = ex
7946 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
7951 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7952 
    args = markEBSSettlementUploaded_args()
7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
7955 
    result = markEBSSettlementUploaded_result()
7956 
    try:
7957 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7958 
    except TransactionServiceException, ex:
7959 
      result.ex = ex
7960 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
7964 
 
7965 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7966 
    args = getEBSSettlementDate_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = getEBSSettlementDate_result()
7970 
    try:
7971 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7972 
    except TransactionServiceException, ex:
7973 
      result.ex = ex
7974 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
4715 varun.gupt 7979 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7980 
    args = getSettlementsByDate_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = getSettlementsByDate_result()
7984 
    try:
7985 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7986 
    except TransactionServiceException, ex:
7987 
      result.ex = ex
7988 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
4600 varun.gupt 7992 
 
4715 varun.gupt 7993 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7994 
    args = getReshippedOrderIds_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = getReshippedOrderIds_result()
7998 
    try:
7999 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8000 
    except TransactionServiceException, ex:
8001 
      result.ex = ex
8002 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8003 
    result.write(oprot)
8004 
    oprot.writeMessageEnd()
8005 
    oprot.trans.flush()
8006 
 
5481 phani.kuma 8007 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8008 
    args = getBilledOrders_args()
4875 varun.gupt 8009 
    args.read(iprot)
8010 
    iprot.readMessageEnd()
5481 phani.kuma 8011 
    result = getBilledOrders_result()
4875 varun.gupt 8012 
    try:
5481 phani.kuma 8013 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8014 
    except TransactionServiceException, ex:
8015 
      result.ex = ex
5481 phani.kuma 8016 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
4757 mandeep.dh 8020 
 
5031 varun.gupt 8021 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8022 
    args = getStatusDistributionOfOrders_args()
8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
8025 
    result = getStatusDistributionOfOrders_result()
8026 
    try:
8027 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8028 
    except TransactionServiceException, ex:
8029 
      result.ex = ex
8030 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
4875 varun.gupt 8034 
 
5067 varun.gupt 8035 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8036 
    args = getOrderIdsForStatus_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = getOrderIdsForStatus_result()
8040 
    try:
8041 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8042 
    except TransactionServiceException, ex:
8043 
      result.ex = ex
8044 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8045 
    result.write(oprot)
8046 
    oprot.writeMessageEnd()
8047 
    oprot.trans.flush()
5031 varun.gupt 8048 
 
5348 anupam.sin 8049 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8050 
    args = updateCODAgent_args()
8051 
    args.read(iprot)
8052 
    iprot.readMessageEnd()
8053 
    result = updateCODAgent_result()
8054 
    try:
8055 
      self._handler.updateCODAgent(args.agent, args.orderId)
8056 
    except TransactionServiceException, ex:
8057 
      result.ex = ex
8058 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8059 
    result.write(oprot)
8060 
    oprot.writeMessageEnd()
8061 
    oprot.trans.flush()
8062 
 
5099 varun.gupt 8063 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8064 
    args = updateOrderAsPaidToVendor_args()
8065 
    args.read(iprot)
8066 
    iprot.readMessageEnd()
8067 
    result = updateOrderAsPaidToVendor_result()
8068 
    try:
8069 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8070 
    except TransactionServiceException, ex:
8071 
      result.ex = ex
8072 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8073 
    result.write(oprot)
8074 
    oprot.writeMessageEnd()
8075 
    oprot.trans.flush()
5067 varun.gupt 8076 
 
5386 phani.kuma 8077 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8078 
    args = updateOrderOnlyAsPaidToVendor_args()
8079 
    args.read(iprot)
8080 
    iprot.readMessageEnd()
8081 
    result = updateOrderOnlyAsPaidToVendor_result()
8082 
    try:
8083 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8084 
    except TransactionServiceException, ex:
8085 
      result.ex = ex
8086 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8087 
    result.write(oprot)
8088 
    oprot.writeMessageEnd()
8089 
    oprot.trans.flush()
8090 
 
5208 varun.gupt 8091 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8092 
    args = getRefundedOrdersMarkedPaid_args()
8093 
    args.read(iprot)
8094 
    iprot.readMessageEnd()
8095 
    result = getRefundedOrdersMarkedPaid_result()
8096 
    try:
8097 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8098 
    except TransactionServiceException, ex:
8099 
      result.ex = ex
8100 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8101 
    result.write(oprot)
8102 
    oprot.writeMessageEnd()
8103 
    oprot.trans.flush()
5099 varun.gupt 8104 
 
5447 anupam.sin 8105 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8106 
    args = getAllVerificationAgents_args()
8107 
    args.read(iprot)
8108 
    iprot.readMessageEnd()
8109 
    result = getAllVerificationAgents_result()
8110 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8111 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8112 
    result.write(oprot)
8113 
    oprot.writeMessageEnd()
8114 
    oprot.trans.flush()
5208 varun.gupt 8115 
 
5527 anupam.sin 8116 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8117 
    args = getAllAttributesForOrderId_args()
8118 
    args.read(iprot)
8119 
    iprot.readMessageEnd()
8120 
    result = getAllAttributesForOrderId_result()
8121 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8122 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8123 
    result.write(oprot)
8124 
    oprot.writeMessageEnd()
8125 
    oprot.trans.flush()
5447 anupam.sin 8126 
 
5676 rajveer 8127 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8128 
    args = setOrderAttributes_args()
8129 
    args.read(iprot)
8130 
    iprot.readMessageEnd()
8131 
    result = setOrderAttributes_result()
8132 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8133 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8134 
    result.write(oprot)
8135 
    oprot.writeMessageEnd()
8136 
    oprot.trans.flush()
8137 
 
5527 anupam.sin 8138 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8139 
    args = setOrderAttributeForTransaction_args()
8140 
    args.read(iprot)
8141 
    iprot.readMessageEnd()
8142 
    result = setOrderAttributeForTransaction_result()
8143 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8144 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
5553 rajveer 8149 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8150 
    args = getReceivePendingOrders_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = getReceivePendingOrders_result()
8154 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8155 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8156 
    result.write(oprot)
8157 
    oprot.writeMessageEnd()
8158 
    oprot.trans.flush()
5527 anupam.sin 8159 
 
5553 rajveer 8160 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8161 
    args = getReceivedAtStoreOrders_args()
8162 
    args.read(iprot)
8163 
    iprot.readMessageEnd()
8164 
    result = getReceivedAtStoreOrders_result()
8165 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8166 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8167 
    result.write(oprot)
8168 
    oprot.writeMessageEnd()
8169 
    oprot.trans.flush()
8170 
 
5713 rajveer 8171 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8172 
    args = getOrdersCollectionAtStore_args()
8173 
    args.read(iprot)
8174 
    iprot.readMessageEnd()
8175 
    result = getOrdersCollectionAtStore_result()
8176 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8177 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8178 
    result.write(oprot)
8179 
    oprot.writeMessageEnd()
8180 
    oprot.trans.flush()
8181 
 
5833 rajveer 8182 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8183 
    args = getOrderAttributeValue_args()
8184 
    args.read(iprot)
8185 
    iprot.readMessageEnd()
8186 
    result = getOrderAttributeValue_result()
8187 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8188 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8189 
    result.write(oprot)
8190 
    oprot.writeMessageEnd()
8191 
    oprot.trans.flush()
8192 
 
6019 rajveer 8193 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8194 
    args = changeJacketNumber_args()
8195 
    args.read(iprot)
8196 
    iprot.readMessageEnd()
8197 
    result = changeJacketNumber_result()
8198 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8199 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8200 
    result.write(oprot)
8201 
    oprot.writeMessageEnd()
8202 
    oprot.trans.flush()
8203 
 
8204 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8205 
    args = markOrderAsRtoInTransit_args()
8206 
    args.read(iprot)
8207 
    iprot.readMessageEnd()
8208 
    result = markOrderAsRtoInTransit_result()
8209 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8210 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
5593 mandeep.dh 8215 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8216 
    args = acceptOrderForItem_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = acceptOrderForItem_result()
8220 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8221 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8222 
    result.write(oprot)
8223 
    oprot.writeMessageEnd()
8224 
    oprot.trans.flush()
5553 rajveer 8225 
 
6000 mandeep.dh 8226 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8227 
    args = createRechargeOrder_args()
8228 
    args.read(iprot)
8229 
    iprot.readMessageEnd()
8230 
    result = createRechargeOrder_result()
8231 
    try:
8232 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8233 
    except TransactionServiceException, ex:
8234 
      result.ex = ex
8235 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8236 
    result.write(oprot)
8237 
    oprot.writeMessageEnd()
8238 
    oprot.trans.flush()
5593 mandeep.dh 8239 
 
6031 rajveer 8240 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8241 
    args = getRechargeOrder_args()
8242 
    args.read(iprot)
8243 
    iprot.readMessageEnd()
8244 
    result = getRechargeOrder_result()
8245 
    try:
8246 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8247 
    except TransactionServiceException, ex:
8248 
      result.ex = ex
8249 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8250 
    result.write(oprot)
8251 
    oprot.writeMessageEnd()
8252 
    oprot.trans.flush()
8253 
 
8254 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8255 
    args = getRechargeOrders_args()
8256 
    args.read(iprot)
8257 
    iprot.readMessageEnd()
8258 
    result = getRechargeOrders_result()
8259 
    result.success = self._handler.getRechargeOrders(args.userId)
8260 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8261 
    result.write(oprot)
8262 
    oprot.writeMessageEnd()
8263 
    oprot.trans.flush()
8264 
 
6000 mandeep.dh 8265 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8266 
    args = updateRechargeOrderStatus_args()
8267 
    args.read(iprot)
8268 
    iprot.readMessageEnd()
8269 
    result = updateRechargeOrderStatus_result()
8270 
    try:
6031 rajveer 8271 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8272 
    except TransactionServiceException, ex:
8273 
      result.ex = ex
8274 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
8278 
 
8279 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8280 
    args = activateRechargeTxn_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = activateRechargeTxn_result()
8284 
    try:
6031 rajveer 8285 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8286 
    except TransactionServiceException, ex:
8287 
      result.ex = ex
8288 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
8292 
 
6031 rajveer 8293 
  def process_getUserWallet(self, seqid, iprot, oprot):
8294 
    args = getUserWallet_args()
6000 mandeep.dh 8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
6031 rajveer 8297 
    result = getUserWallet_result()
8298 
    result.success = self._handler.getUserWallet(args.userId)
8299 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8300 
    result.write(oprot)
8301 
    oprot.writeMessageEnd()
8302 
    oprot.trans.flush()
8303 
 
6031 rajveer 8304 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8305 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8306 
    args.read(iprot)
8307 
    iprot.readMessageEnd()
6031 rajveer 8308 
    result = getUserWalletHistory_result()
8309 
    result.success = self._handler.getUserWalletHistory(args.userId)
8310 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8311 
    result.write(oprot)
8312 
    oprot.writeMessageEnd()
8313 
    oprot.trans.flush()
8314 
 
6050 anupam.sin 8315 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8316 
    args = getRechargeOrdersForTransaction_args()
8317 
    args.read(iprot)
8318 
    iprot.readMessageEnd()
8319 
    result = getRechargeOrdersForTransaction_result()
8320 
    try:
8321 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8322 
    except TransactionServiceException, ex:
8323 
      result.ex = ex
8324 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8325 
    result.write(oprot)
8326 
    oprot.writeMessageEnd()
8327 
    oprot.trans.flush()
8328 
 
6048 rajveer 8329 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8330 
    args = getServiceProviders_args()
8331 
    args.read(iprot)
8332 
    iprot.readMessageEnd()
8333 
    result = getServiceProviders_result()
6206 rajveer 8334 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8335 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
6000 mandeep.dh 8339 
 
6048 rajveer 8340 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8341 
    args = getServiceProviderForDevice_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = getServiceProviderForDevice_result()
6049 rajveer 8345 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8346 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8347 
    result.write(oprot)
8348 
    oprot.writeMessageEnd()
8349 
    oprot.trans.flush()
8350 
 
6269 rajveer 8351 
  def process_validateRecharge(self, seqid, iprot, oprot):
8352 
    args = validateRecharge_args()
8353 
    args.read(iprot)
8354 
    iprot.readMessageEnd()
8355 
    result = validateRecharge_result()
8356 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber)
8357 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8358 
    result.write(oprot)
8359 
    oprot.writeMessageEnd()
8360 
    oprot.trans.flush()
8361 
 
6094 rajveer 8362 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8363 
    args = getRechargeOrdersForDevice_args()
8364 
    args.read(iprot)
8365 
    iprot.readMessageEnd()
8366 
    result = getRechargeOrdersForDevice_result()
8367 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8368 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8369 
    result.write(oprot)
8370 
    oprot.writeMessageEnd()
8371 
    oprot.trans.flush()
6048 rajveer 8372 
 
6094 rajveer 8373 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8374 
    args = addAmountToWallet_args()
8375 
    args.read(iprot)
8376 
    iprot.readMessageEnd()
8377 
    result = addAmountToWallet_result()
8378 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8379 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8380 
    result.write(oprot)
8381 
    oprot.writeMessageEnd()
8382 
    oprot.trans.flush()
8383 
 
6188 rajveer 8384 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8385 
    args = getRechargeStatistics_args()
8386 
    args.read(iprot)
8387 
    iprot.readMessageEnd()
8388 
    result = getRechargeStatistics_result()
8389 
    result.success = self._handler.getRechargeStatistics()
8390 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8391 
    result.write(oprot)
8392 
    oprot.writeMessageEnd()
8393 
    oprot.trans.flush()
8394 
 
6154 rajveer 8395 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8396 
    args = getRechargeOrdersForStatus_args()
8397 
    args.read(iprot)
8398 
    iprot.readMessageEnd()
8399 
    result = getRechargeOrdersForStatus_result()
8400 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8401 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
6094 rajveer 8405 
 
6159 rajveer 8406 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8407 
    args = getPlansForOperator_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = getPlansForOperator_result()
8411 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8412 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
6154 rajveer 8416 
 
6289 anupam.sin 8417 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8418 
    args = getRechargeDenominations_args()
8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
8421 
    result = getRechargeDenominations_result()
8422 
    try:
8423 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleName, args.denominationType)
8424 
    except TransactionServiceException, ex:
8425 
      result.ex = ex
8426 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8427 
    result.write(oprot)
8428 
    oprot.writeMessageEnd()
8429 
    oprot.trans.flush()
6159 rajveer 8430 
 
6289 anupam.sin 8431 
 
94 ashish 8432 
# HELPER FUNCTIONS AND STRUCTURES
8433 
 
8434 
class createTransaction_args:
8435 
  """
8436 
  Attributes:
8437 
   - transaction
8438 
  """
8439 
 
8440 
  thrift_spec = (
8441 
    None, # 0
8442 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8443 
  )
8444 
 
8445 
  def __init__(self, transaction=None,):
8446 
    self.transaction = transaction
8447 
 
8448 
  def read(self, iprot):
8449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8451 
      return
8452 
    iprot.readStructBegin()
8453 
    while True:
8454 
      (fname, ftype, fid) = iprot.readFieldBegin()
8455 
      if ftype == TType.STOP:
8456 
        break
8457 
      if fid == 1:
8458 
        if ftype == TType.STRUCT:
8459 
          self.transaction = Transaction()
8460 
          self.transaction.read(iprot)
8461 
        else:
8462 
          iprot.skip(ftype)
8463 
      else:
8464 
        iprot.skip(ftype)
8465 
      iprot.readFieldEnd()
8466 
    iprot.readStructEnd()
8467 
 
8468 
  def write(self, oprot):
8469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8471 
      return
8472 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8473 
    if self.transaction is not None:
94 ashish 8474 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8475 
      self.transaction.write(oprot)
8476 
      oprot.writeFieldEnd()
8477 
    oprot.writeFieldStop()
8478 
    oprot.writeStructEnd()
8479 
 
3431 rajveer 8480 
  def validate(self):
8481 
    return
8482 
 
8483 
 
94 ashish 8484 
  def __repr__(self):
8485 
    L = ['%s=%r' % (key, value)
8486 
      for key, value in self.__dict__.iteritems()]
8487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8488 
 
8489 
  def __eq__(self, other):
8490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8491 
 
8492 
  def __ne__(self, other):
8493 
    return not (self == other)
8494 
 
8495 
class createTransaction_result:
8496 
  """
8497 
  Attributes:
132 ashish 8498 
   - success
94 ashish 8499 
   - ex
8500 
  """
8501 
 
8502 
  thrift_spec = (
132 ashish 8503 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8505 
  )
8506 
 
132 ashish 8507 
  def __init__(self, success=None, ex=None,):
8508 
    self.success = success
94 ashish 8509 
    self.ex = ex
8510 
 
8511 
  def read(self, iprot):
8512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8514 
      return
8515 
    iprot.readStructBegin()
8516 
    while True:
8517 
      (fname, ftype, fid) = iprot.readFieldBegin()
8518 
      if ftype == TType.STOP:
8519 
        break
132 ashish 8520 
      if fid == 0:
8521 
        if ftype == TType.I64:
8522 
          self.success = iprot.readI64();
8523 
        else:
8524 
          iprot.skip(ftype)
8525 
      elif fid == 1:
94 ashish 8526 
        if ftype == TType.STRUCT:
8527 
          self.ex = TransactionServiceException()
8528 
          self.ex.read(iprot)
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('createTransaction_result')
3431 rajveer 8541 
    if self.success is not None:
132 ashish 8542 
      oprot.writeFieldBegin('success', TType.I64, 0)
8543 
      oprot.writeI64(self.success)
8544 
      oprot.writeFieldEnd()
3431 rajveer 8545 
    if self.ex is not None:
94 ashish 8546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8547 
      self.ex.write(oprot)
8548 
      oprot.writeFieldEnd()
8549 
    oprot.writeFieldStop()
8550 
    oprot.writeStructEnd()
8551 
 
3431 rajveer 8552 
  def validate(self):
8553 
    return
8554 
 
8555 
 
94 ashish 8556 
  def __repr__(self):
8557 
    L = ['%s=%r' % (key, value)
8558 
      for key, value in self.__dict__.iteritems()]
8559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8560 
 
8561 
  def __eq__(self, other):
8562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8563 
 
8564 
  def __ne__(self, other):
8565 
    return not (self == other)
8566 
 
8567 
class getTransaction_args:
8568 
  """
8569 
  Attributes:
8570 
   - id
8571 
  """
8572 
 
8573 
  thrift_spec = (
8574 
    None, # 0
8575 
    (1, TType.I64, 'id', None, None, ), # 1
8576 
  )
8577 
 
8578 
  def __init__(self, id=None,):
8579 
    self.id = id
8580 
 
8581 
  def read(self, iprot):
8582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8584 
      return
8585 
    iprot.readStructBegin()
8586 
    while True:
8587 
      (fname, ftype, fid) = iprot.readFieldBegin()
8588 
      if ftype == TType.STOP:
8589 
        break
8590 
      if fid == 1:
8591 
        if ftype == TType.I64:
8592 
          self.id = iprot.readI64();
8593 
        else:
8594 
          iprot.skip(ftype)
8595 
      else:
8596 
        iprot.skip(ftype)
8597 
      iprot.readFieldEnd()
8598 
    iprot.readStructEnd()
8599 
 
8600 
  def write(self, oprot):
8601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8603 
      return
8604 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8605 
    if self.id is not None:
94 ashish 8606 
      oprot.writeFieldBegin('id', TType.I64, 1)
8607 
      oprot.writeI64(self.id)
8608 
      oprot.writeFieldEnd()
8609 
    oprot.writeFieldStop()
8610 
    oprot.writeStructEnd()
8611 
 
3431 rajveer 8612 
  def validate(self):
8613 
    return
8614 
 
8615 
 
94 ashish 8616 
  def __repr__(self):
8617 
    L = ['%s=%r' % (key, value)
8618 
      for key, value in self.__dict__.iteritems()]
8619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8620 
 
8621 
  def __eq__(self, other):
8622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8623 
 
8624 
  def __ne__(self, other):
8625 
    return not (self == other)
8626 
 
8627 
class getTransaction_result:
8628 
  """
8629 
  Attributes:
8630 
   - success
8631 
   - ex
8632 
  """
8633 
 
8634 
  thrift_spec = (
8635 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8637 
  )
8638 
 
8639 
  def __init__(self, success=None, ex=None,):
8640 
    self.success = success
8641 
    self.ex = ex
8642 
 
8643 
  def read(self, iprot):
8644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8646 
      return
8647 
    iprot.readStructBegin()
8648 
    while True:
8649 
      (fname, ftype, fid) = iprot.readFieldBegin()
8650 
      if ftype == TType.STOP:
8651 
        break
8652 
      if fid == 0:
8653 
        if ftype == TType.STRUCT:
8654 
          self.success = Transaction()
8655 
          self.success.read(iprot)
8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      elif fid == 1:
8659 
        if ftype == TType.STRUCT:
8660 
          self.ex = TransactionServiceException()
8661 
          self.ex.read(iprot)
8662 
        else:
8663 
          iprot.skip(ftype)
8664 
      else:
8665 
        iprot.skip(ftype)
8666 
      iprot.readFieldEnd()
8667 
    iprot.readStructEnd()
8668 
 
8669 
  def write(self, oprot):
8670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8672 
      return
8673 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8674 
    if self.success is not None:
94 ashish 8675 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8676 
      self.success.write(oprot)
8677 
      oprot.writeFieldEnd()
3431 rajveer 8678 
    if self.ex is not None:
94 ashish 8679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8680 
      self.ex.write(oprot)
8681 
      oprot.writeFieldEnd()
8682 
    oprot.writeFieldStop()
8683 
    oprot.writeStructEnd()
8684 
 
3431 rajveer 8685 
  def validate(self):
8686 
    return
8687 
 
8688 
 
94 ashish 8689 
  def __repr__(self):
8690 
    L = ['%s=%r' % (key, value)
8691 
      for key, value in self.__dict__.iteritems()]
8692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8693 
 
8694 
  def __eq__(self, other):
8695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8696 
 
8697 
  def __ne__(self, other):
8698 
    return not (self == other)
8699 
 
8700 
class getTransactionsForCustomer_args:
8701 
  """
8702 
  Attributes:
8703 
   - customerId
8704 
   - from_date
8705 
   - to_date
8706 
   - status
8707 
  """
8708 
 
8709 
  thrift_spec = (
8710 
    None, # 0
8711 
    (1, TType.I64, 'customerId', None, None, ), # 1
8712 
    (2, TType.I64, 'from_date', None, None, ), # 2
8713 
    (3, TType.I64, 'to_date', None, None, ), # 3
8714 
    (4, TType.I32, 'status', None, None, ), # 4
8715 
  )
8716 
 
8717 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8718 
    self.customerId = customerId
8719 
    self.from_date = from_date
8720 
    self.to_date = to_date
8721 
    self.status = status
8722 
 
8723 
  def read(self, iprot):
8724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8726 
      return
8727 
    iprot.readStructBegin()
8728 
    while True:
8729 
      (fname, ftype, fid) = iprot.readFieldBegin()
8730 
      if ftype == TType.STOP:
8731 
        break
8732 
      if fid == 1:
8733 
        if ftype == TType.I64:
8734 
          self.customerId = iprot.readI64();
8735 
        else:
8736 
          iprot.skip(ftype)
8737 
      elif fid == 2:
8738 
        if ftype == TType.I64:
8739 
          self.from_date = iprot.readI64();
8740 
        else:
8741 
          iprot.skip(ftype)
8742 
      elif fid == 3:
8743 
        if ftype == TType.I64:
8744 
          self.to_date = iprot.readI64();
8745 
        else:
8746 
          iprot.skip(ftype)
8747 
      elif fid == 4:
8748 
        if ftype == TType.I32:
8749 
          self.status = iprot.readI32();
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8762 
    if self.customerId is not None:
94 ashish 8763 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8764 
      oprot.writeI64(self.customerId)
8765 
      oprot.writeFieldEnd()
3431 rajveer 8766 
    if self.from_date is not None:
94 ashish 8767 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8768 
      oprot.writeI64(self.from_date)
8769 
      oprot.writeFieldEnd()
3431 rajveer 8770 
    if self.to_date is not None:
94 ashish 8771 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8772 
      oprot.writeI64(self.to_date)
8773 
      oprot.writeFieldEnd()
3431 rajveer 8774 
    if self.status is not None:
94 ashish 8775 
      oprot.writeFieldBegin('status', TType.I32, 4)
8776 
      oprot.writeI32(self.status)
8777 
      oprot.writeFieldEnd()
8778 
    oprot.writeFieldStop()
8779 
    oprot.writeStructEnd()
8780 
 
3431 rajveer 8781 
  def validate(self):
8782 
    return
8783 
 
8784 
 
94 ashish 8785 
  def __repr__(self):
8786 
    L = ['%s=%r' % (key, value)
8787 
      for key, value in self.__dict__.iteritems()]
8788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8789 
 
8790 
  def __eq__(self, other):
8791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8792 
 
8793 
  def __ne__(self, other):
8794 
    return not (self == other)
8795 
 
8796 
class getTransactionsForCustomer_result:
8797 
  """
8798 
  Attributes:
8799 
   - success
8800 
   - ex
8801 
  """
8802 
 
8803 
  thrift_spec = (
8804 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8806 
  )
8807 
 
8808 
  def __init__(self, success=None, ex=None,):
8809 
    self.success = success
8810 
    self.ex = ex
8811 
 
8812 
  def read(self, iprot):
8813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8815 
      return
8816 
    iprot.readStructBegin()
8817 
    while True:
8818 
      (fname, ftype, fid) = iprot.readFieldBegin()
8819 
      if ftype == TType.STOP:
8820 
        break
8821 
      if fid == 0:
8822 
        if ftype == TType.LIST:
8823 
          self.success = []
6188 rajveer 8824 
          (_etype109, _size106) = iprot.readListBegin()
8825 
          for _i110 in xrange(_size106):
8826 
            _elem111 = Transaction()
8827 
            _elem111.read(iprot)
8828 
            self.success.append(_elem111)
94 ashish 8829 
          iprot.readListEnd()
8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      elif fid == 1:
8833 
        if ftype == TType.STRUCT:
8834 
          self.ex = TransactionServiceException()
8835 
          self.ex.read(iprot)
8836 
        else:
8837 
          iprot.skip(ftype)
8838 
      else:
8839 
        iprot.skip(ftype)
8840 
      iprot.readFieldEnd()
8841 
    iprot.readStructEnd()
8842 
 
8843 
  def write(self, oprot):
8844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8846 
      return
8847 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8848 
    if self.success is not None:
94 ashish 8849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8850 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8851 
      for iter112 in self.success:
8852 
        iter112.write(oprot)
94 ashish 8853 
      oprot.writeListEnd()
8854 
      oprot.writeFieldEnd()
3431 rajveer 8855 
    if self.ex is not None:
94 ashish 8856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8857 
      self.ex.write(oprot)
8858 
      oprot.writeFieldEnd()
8859 
    oprot.writeFieldStop()
8860 
    oprot.writeStructEnd()
8861 
 
3431 rajveer 8862 
  def validate(self):
8863 
    return
8864 
 
8865 
 
94 ashish 8866 
  def __repr__(self):
8867 
    L = ['%s=%r' % (key, value)
8868 
      for key, value in self.__dict__.iteritems()]
8869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8870 
 
8871 
  def __eq__(self, other):
8872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8873 
 
8874 
  def __ne__(self, other):
8875 
    return not (self == other)
8876 
 
132 ashish 8877 
class getTransactionsForShoppingCartId_args:
8878 
  """
8879 
  Attributes:
8880 
   - shoppingCartId
8881 
  """
8882 
 
8883 
  thrift_spec = (
8884 
    None, # 0
8885 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8886 
  )
8887 
 
8888 
  def __init__(self, shoppingCartId=None,):
8889 
    self.shoppingCartId = shoppingCartId
8890 
 
8891 
  def read(self, iprot):
8892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8894 
      return
8895 
    iprot.readStructBegin()
8896 
    while True:
8897 
      (fname, ftype, fid) = iprot.readFieldBegin()
8898 
      if ftype == TType.STOP:
8899 
        break
8900 
      if fid == 1:
8901 
        if ftype == TType.I64:
8902 
          self.shoppingCartId = iprot.readI64();
8903 
        else:
8904 
          iprot.skip(ftype)
8905 
      else:
8906 
        iprot.skip(ftype)
8907 
      iprot.readFieldEnd()
8908 
    iprot.readStructEnd()
8909 
 
8910 
  def write(self, oprot):
8911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8913 
      return
8914 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8915 
    if self.shoppingCartId is not None:
132 ashish 8916 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8917 
      oprot.writeI64(self.shoppingCartId)
8918 
      oprot.writeFieldEnd()
8919 
    oprot.writeFieldStop()
8920 
    oprot.writeStructEnd()
8921 
 
3431 rajveer 8922 
  def validate(self):
8923 
    return
8924 
 
8925 
 
132 ashish 8926 
  def __repr__(self):
8927 
    L = ['%s=%r' % (key, value)
8928 
      for key, value in self.__dict__.iteritems()]
8929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8930 
 
8931 
  def __eq__(self, other):
8932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8933 
 
8934 
  def __ne__(self, other):
8935 
    return not (self == other)
8936 
 
8937 
class getTransactionsForShoppingCartId_result:
8938 
  """
8939 
  Attributes:
8940 
   - success
8941 
   - ex
8942 
  """
8943 
 
8944 
  thrift_spec = (
8945 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8947 
  )
8948 
 
8949 
  def __init__(self, success=None, ex=None,):
8950 
    self.success = success
8951 
    self.ex = ex
8952 
 
8953 
  def read(self, iprot):
8954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8956 
      return
8957 
    iprot.readStructBegin()
8958 
    while True:
8959 
      (fname, ftype, fid) = iprot.readFieldBegin()
8960 
      if ftype == TType.STOP:
8961 
        break
8962 
      if fid == 0:
8963 
        if ftype == TType.LIST:
8964 
          self.success = []
6188 rajveer 8965 
          (_etype116, _size113) = iprot.readListBegin()
8966 
          for _i117 in xrange(_size113):
8967 
            _elem118 = Transaction()
8968 
            _elem118.read(iprot)
8969 
            self.success.append(_elem118)
132 ashish 8970 
          iprot.readListEnd()
8971 
        else:
8972 
          iprot.skip(ftype)
8973 
      elif fid == 1:
8974 
        if ftype == TType.STRUCT:
8975 
          self.ex = TransactionServiceException()
8976 
          self.ex.read(iprot)
8977 
        else:
8978 
          iprot.skip(ftype)
8979 
      else:
8980 
        iprot.skip(ftype)
8981 
      iprot.readFieldEnd()
8982 
    iprot.readStructEnd()
8983 
 
8984 
  def write(self, oprot):
8985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8987 
      return
8988 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8989 
    if self.success is not None:
132 ashish 8990 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8991 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8992 
      for iter119 in self.success:
8993 
        iter119.write(oprot)
132 ashish 8994 
      oprot.writeListEnd()
8995 
      oprot.writeFieldEnd()
3431 rajveer 8996 
    if self.ex is not None:
132 ashish 8997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8998 
      self.ex.write(oprot)
8999 
      oprot.writeFieldEnd()
9000 
    oprot.writeFieldStop()
9001 
    oprot.writeStructEnd()
9002 
 
3431 rajveer 9003 
  def validate(self):
9004 
    return
9005 
 
9006 
 
132 ashish 9007 
  def __repr__(self):
9008 
    L = ['%s=%r' % (key, value)
9009 
      for key, value in self.__dict__.iteritems()]
9010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9011 
 
9012 
  def __eq__(self, other):
9013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9014 
 
9015 
  def __ne__(self, other):
9016 
    return not (self == other)
9017 
 
94 ashish 9018 
class getTransactionStatus_args:
9019 
  """
9020 
  Attributes:
9021 
   - transactionId
9022 
  """
9023 
 
9024 
  thrift_spec = (
9025 
    None, # 0
9026 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9027 
  )
9028 
 
9029 
  def __init__(self, transactionId=None,):
9030 
    self.transactionId = transactionId
9031 
 
9032 
  def read(self, iprot):
9033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9035 
      return
9036 
    iprot.readStructBegin()
9037 
    while True:
9038 
      (fname, ftype, fid) = iprot.readFieldBegin()
9039 
      if ftype == TType.STOP:
9040 
        break
9041 
      if fid == 1:
9042 
        if ftype == TType.I64:
9043 
          self.transactionId = iprot.readI64();
9044 
        else:
9045 
          iprot.skip(ftype)
9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
9055 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9056 
    if self.transactionId is not None:
94 ashish 9057 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9058 
      oprot.writeI64(self.transactionId)
9059 
      oprot.writeFieldEnd()
9060 
    oprot.writeFieldStop()
9061 
    oprot.writeStructEnd()
9062 
 
3431 rajveer 9063 
  def validate(self):
9064 
    return
9065 
 
9066 
 
94 ashish 9067 
  def __repr__(self):
9068 
    L = ['%s=%r' % (key, value)
9069 
      for key, value in self.__dict__.iteritems()]
9070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9071 
 
9072 
  def __eq__(self, other):
9073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9074 
 
9075 
  def __ne__(self, other):
9076 
    return not (self == other)
9077 
 
9078 
class getTransactionStatus_result:
9079 
  """
9080 
  Attributes:
9081 
   - success
9082 
   - ex
9083 
  """
9084 
 
9085 
  thrift_spec = (
9086 
    (0, TType.I32, 'success', None, None, ), # 0
9087 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9088 
  )
9089 
 
9090 
  def __init__(self, success=None, ex=None,):
9091 
    self.success = success
9092 
    self.ex = ex
9093 
 
9094 
  def read(self, iprot):
9095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9097 
      return
9098 
    iprot.readStructBegin()
9099 
    while True:
9100 
      (fname, ftype, fid) = iprot.readFieldBegin()
9101 
      if ftype == TType.STOP:
9102 
        break
9103 
      if fid == 0:
9104 
        if ftype == TType.I32:
9105 
          self.success = iprot.readI32();
9106 
        else:
9107 
          iprot.skip(ftype)
9108 
      elif fid == 1:
9109 
        if ftype == TType.STRUCT:
9110 
          self.ex = TransactionServiceException()
9111 
          self.ex.read(iprot)
9112 
        else:
9113 
          iprot.skip(ftype)
9114 
      else:
9115 
        iprot.skip(ftype)
9116 
      iprot.readFieldEnd()
9117 
    iprot.readStructEnd()
9118 
 
9119 
  def write(self, oprot):
9120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9122 
      return
9123 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9124 
    if self.success is not None:
94 ashish 9125 
      oprot.writeFieldBegin('success', TType.I32, 0)
9126 
      oprot.writeI32(self.success)
9127 
      oprot.writeFieldEnd()
3431 rajveer 9128 
    if self.ex is not None:
94 ashish 9129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9130 
      self.ex.write(oprot)
9131 
      oprot.writeFieldEnd()
9132 
    oprot.writeFieldStop()
9133 
    oprot.writeStructEnd()
9134 
 
3431 rajveer 9135 
  def validate(self):
9136 
    return
9137 
 
9138 
 
94 ashish 9139 
  def __repr__(self):
9140 
    L = ['%s=%r' % (key, value)
9141 
      for key, value in self.__dict__.iteritems()]
9142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9143 
 
9144 
  def __eq__(self, other):
9145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9146 
 
9147 
  def __ne__(self, other):
9148 
    return not (self == other)
9149 
 
9150 
class changeTransactionStatus_args:
9151 
  """
9152 
  Attributes:
9153 
   - transactionId
9154 
   - status
9155 
   - description
5527 anupam.sin 9156 
   - pickUp
9157 
   - orderType
94 ashish 9158 
  """
9159 
 
9160 
  thrift_spec = (
9161 
    None, # 0
9162 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9163 
    (2, TType.I32, 'status', None, None, ), # 2
9164 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9165 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9166 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9167 
  )
9168 
 
5527 anupam.sin 9169 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9170 
    self.transactionId = transactionId
9171 
    self.status = status
9172 
    self.description = description
5527 anupam.sin 9173 
    self.pickUp = pickUp
9174 
    self.orderType = orderType
94 ashish 9175 
 
9176 
  def read(self, iprot):
9177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9179 
      return
9180 
    iprot.readStructBegin()
9181 
    while True:
9182 
      (fname, ftype, fid) = iprot.readFieldBegin()
9183 
      if ftype == TType.STOP:
9184 
        break
9185 
      if fid == 1:
9186 
        if ftype == TType.I64:
9187 
          self.transactionId = iprot.readI64();
9188 
        else:
9189 
          iprot.skip(ftype)
9190 
      elif fid == 2:
9191 
        if ftype == TType.I32:
9192 
          self.status = iprot.readI32();
9193 
        else:
9194 
          iprot.skip(ftype)
9195 
      elif fid == 3:
9196 
        if ftype == TType.STRING:
9197 
          self.description = iprot.readString();
9198 
        else:
9199 
          iprot.skip(ftype)
5387 rajveer 9200 
      elif fid == 4:
5527 anupam.sin 9201 
        if ftype == TType.I64:
9202 
          self.pickUp = iprot.readI64();
5387 rajveer 9203 
        else:
9204 
          iprot.skip(ftype)
5527 anupam.sin 9205 
      elif fid == 5:
9206 
        if ftype == TType.I32:
9207 
          self.orderType = iprot.readI32();
9208 
        else:
9209 
          iprot.skip(ftype)
94 ashish 9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9220 
    if self.transactionId is not None:
94 ashish 9221 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9222 
      oprot.writeI64(self.transactionId)
9223 
      oprot.writeFieldEnd()
3431 rajveer 9224 
    if self.status is not None:
94 ashish 9225 
      oprot.writeFieldBegin('status', TType.I32, 2)
9226 
      oprot.writeI32(self.status)
9227 
      oprot.writeFieldEnd()
3431 rajveer 9228 
    if self.description is not None:
94 ashish 9229 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9230 
      oprot.writeString(self.description)
9231 
      oprot.writeFieldEnd()
5527 anupam.sin 9232 
    if self.pickUp is not None:
9233 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9234 
      oprot.writeI64(self.pickUp)
5387 rajveer 9235 
      oprot.writeFieldEnd()
5527 anupam.sin 9236 
    if self.orderType is not None:
9237 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9238 
      oprot.writeI32(self.orderType)
9239 
      oprot.writeFieldEnd()
94 ashish 9240 
    oprot.writeFieldStop()
9241 
    oprot.writeStructEnd()
9242 
 
3431 rajveer 9243 
  def validate(self):
9244 
    return
9245 
 
9246 
 
94 ashish 9247 
  def __repr__(self):
9248 
    L = ['%s=%r' % (key, value)
9249 
      for key, value in self.__dict__.iteritems()]
9250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9251 
 
9252 
  def __eq__(self, other):
9253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9254 
 
9255 
  def __ne__(self, other):
9256 
    return not (self == other)
9257 
 
9258 
class changeTransactionStatus_result:
9259 
  """
9260 
  Attributes:
9261 
   - success
9262 
   - ex
9263 
  """
9264 
 
9265 
  thrift_spec = (
9266 
    (0, TType.BOOL, 'success', None, None, ), # 0
9267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9268 
  )
9269 
 
9270 
  def __init__(self, success=None, ex=None,):
9271 
    self.success = success
9272 
    self.ex = ex
9273 
 
9274 
  def read(self, iprot):
9275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9277 
      return
9278 
    iprot.readStructBegin()
9279 
    while True:
9280 
      (fname, ftype, fid) = iprot.readFieldBegin()
9281 
      if ftype == TType.STOP:
9282 
        break
9283 
      if fid == 0:
9284 
        if ftype == TType.BOOL:
9285 
          self.success = iprot.readBool();
9286 
        else:
9287 
          iprot.skip(ftype)
9288 
      elif fid == 1:
9289 
        if ftype == TType.STRUCT:
9290 
          self.ex = TransactionServiceException()
9291 
          self.ex.read(iprot)
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
9303 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9304 
    if self.success is not None:
94 ashish 9305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9306 
      oprot.writeBool(self.success)
9307 
      oprot.writeFieldEnd()
3431 rajveer 9308 
    if self.ex is not None:
94 ashish 9309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9310 
      self.ex.write(oprot)
9311 
      oprot.writeFieldEnd()
9312 
    oprot.writeFieldStop()
9313 
    oprot.writeStructEnd()
9314 
 
3431 rajveer 9315 
  def validate(self):
9316 
    return
9317 
 
9318 
 
94 ashish 9319 
  def __repr__(self):
9320 
    L = ['%s=%r' % (key, value)
9321 
      for key, value in self.__dict__.iteritems()]
9322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9323 
 
9324 
  def __eq__(self, other):
9325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9326 
 
9327 
  def __ne__(self, other):
9328 
    return not (self == other)
9329 
 
1398 varun.gupt 9330 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9331 
  """
9332 
  Attributes:
9333 
   - transactionId
9334 
  """
9335 
 
9336 
  thrift_spec = (
9337 
    None, # 0
9338 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9339 
  )
9340 
 
9341 
  def __init__(self, transactionId=None,):
9342 
    self.transactionId = transactionId
9343 
 
9344 
  def read(self, iprot):
9345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9347 
      return
9348 
    iprot.readStructBegin()
9349 
    while True:
9350 
      (fname, ftype, fid) = iprot.readFieldBegin()
9351 
      if ftype == TType.STOP:
9352 
        break
9353 
      if fid == 1:
9354 
        if ftype == TType.I64:
9355 
          self.transactionId = iprot.readI64();
9356 
        else:
9357 
          iprot.skip(ftype)
9358 
      else:
9359 
        iprot.skip(ftype)
9360 
      iprot.readFieldEnd()
9361 
    iprot.readStructEnd()
9362 
 
9363 
  def write(self, oprot):
9364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9366 
      return
1398 varun.gupt 9367 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9368 
    if self.transactionId is not None:
1382 varun.gupt 9369 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9370 
      oprot.writeI64(self.transactionId)
9371 
      oprot.writeFieldEnd()
9372 
    oprot.writeFieldStop()
9373 
    oprot.writeStructEnd()
9374 
 
3431 rajveer 9375 
  def validate(self):
9376 
    return
9377 
 
9378 
 
1382 varun.gupt 9379 
  def __repr__(self):
9380 
    L = ['%s=%r' % (key, value)
9381 
      for key, value in self.__dict__.iteritems()]
9382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9383 
 
9384 
  def __eq__(self, other):
9385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9386 
 
9387 
  def __ne__(self, other):
9388 
    return not (self == other)
9389 
 
1398 varun.gupt 9390 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9391 
  """
9392 
  Attributes:
9393 
   - success
9394 
   - ex
9395 
  """
9396 
 
9397 
  thrift_spec = (
9398 
    (0, TType.BOOL, 'success', None, None, ), # 0
9399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9400 
  )
9401 
 
9402 
  def __init__(self, success=None, ex=None,):
9403 
    self.success = success
9404 
    self.ex = ex
9405 
 
9406 
  def read(self, iprot):
9407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9409 
      return
9410 
    iprot.readStructBegin()
9411 
    while True:
9412 
      (fname, ftype, fid) = iprot.readFieldBegin()
9413 
      if ftype == TType.STOP:
9414 
        break
9415 
      if fid == 0:
9416 
        if ftype == TType.BOOL:
9417 
          self.success = iprot.readBool();
9418 
        else:
9419 
          iprot.skip(ftype)
9420 
      elif fid == 1:
9421 
        if ftype == TType.STRUCT:
9422 
          self.ex = TransactionServiceException()
9423 
          self.ex.read(iprot)
9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      else:
9427 
        iprot.skip(ftype)
9428 
      iprot.readFieldEnd()
9429 
    iprot.readStructEnd()
9430 
 
9431 
  def write(self, oprot):
9432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9434 
      return
1398 varun.gupt 9435 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9436 
    if self.success is not None:
1382 varun.gupt 9437 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9438 
      oprot.writeBool(self.success)
9439 
      oprot.writeFieldEnd()
3431 rajveer 9440 
    if self.ex is not None:
1382 varun.gupt 9441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9442 
      self.ex.write(oprot)
9443 
      oprot.writeFieldEnd()
9444 
    oprot.writeFieldStop()
9445 
    oprot.writeStructEnd()
9446 
 
3431 rajveer 9447 
  def validate(self):
9448 
    return
9449 
 
9450 
 
1382 varun.gupt 9451 
  def __repr__(self):
9452 
    L = ['%s=%r' % (key, value)
9453 
      for key, value in self.__dict__.iteritems()]
9454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9455 
 
9456 
  def __eq__(self, other):
9457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9458 
 
9459 
  def __ne__(self, other):
9460 
    return not (self == other)
9461 
 
483 rajveer 9462 
class getAllOrders_args:
94 ashish 9463 
  """
9464 
  Attributes:
4801 anupam.sin 9465 
   - statuses
483 rajveer 9466 
   - from_date
9467 
   - to_date
9468 
   - warehouse_id
94 ashish 9469 
  """
9470 
 
9471 
  thrift_spec = (
9472 
    None, # 0
4801 anupam.sin 9473 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9474 
    (2, TType.I64, 'from_date', None, None, ), # 2
9475 
    (3, TType.I64, 'to_date', None, None, ), # 3
9476 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9477 
  )
9478 
 
4801 anupam.sin 9479 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9480 
    self.statuses = statuses
483 rajveer 9481 
    self.from_date = from_date
9482 
    self.to_date = to_date
9483 
    self.warehouse_id = warehouse_id
94 ashish 9484 
 
9485 
  def read(self, iprot):
9486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9488 
      return
9489 
    iprot.readStructBegin()
9490 
    while True:
9491 
      (fname, ftype, fid) = iprot.readFieldBegin()
9492 
      if ftype == TType.STOP:
9493 
        break
9494 
      if fid == 1:
4801 anupam.sin 9495 
        if ftype == TType.LIST:
9496 
          self.statuses = []
6188 rajveer 9497 
          (_etype123, _size120) = iprot.readListBegin()
9498 
          for _i124 in xrange(_size120):
9499 
            _elem125 = iprot.readI32();
9500 
            self.statuses.append(_elem125)
4801 anupam.sin 9501 
          iprot.readListEnd()
94 ashish 9502 
        else:
9503 
          iprot.skip(ftype)
483 rajveer 9504 
      elif fid == 2:
9505 
        if ftype == TType.I64:
9506 
          self.from_date = iprot.readI64();
94 ashish 9507 
        else:
9508 
          iprot.skip(ftype)
483 rajveer 9509 
      elif fid == 3:
9510 
        if ftype == TType.I64:
9511 
          self.to_date = iprot.readI64();
94 ashish 9512 
        else:
9513 
          iprot.skip(ftype)
483 rajveer 9514 
      elif fid == 4:
94 ashish 9515 
        if ftype == TType.I64:
483 rajveer 9516 
          self.warehouse_id = iprot.readI64();
94 ashish 9517 
        else:
9518 
          iprot.skip(ftype)
9519 
      else:
9520 
        iprot.skip(ftype)
9521 
      iprot.readFieldEnd()
9522 
    iprot.readStructEnd()
9523 
 
9524 
  def write(self, oprot):
9525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9527 
      return
483 rajveer 9528 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9529 
    if self.statuses is not None:
9530 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9531 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9532 
      for iter126 in self.statuses:
9533 
        oprot.writeI32(iter126)
4801 anupam.sin 9534 
      oprot.writeListEnd()
94 ashish 9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.from_date is not None:
483 rajveer 9537 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9538 
      oprot.writeI64(self.from_date)
94 ashish 9539 
      oprot.writeFieldEnd()
3431 rajveer 9540 
    if self.to_date is not None:
483 rajveer 9541 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9542 
      oprot.writeI64(self.to_date)
94 ashish 9543 
      oprot.writeFieldEnd()
3431 rajveer 9544 
    if self.warehouse_id is not None:
483 rajveer 9545 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9546 
      oprot.writeI64(self.warehouse_id)
94 ashish 9547 
      oprot.writeFieldEnd()
9548 
    oprot.writeFieldStop()
9549 
    oprot.writeStructEnd()
9550 
 
3431 rajveer 9551 
  def validate(self):
9552 
    return
9553 
 
9554 
 
94 ashish 9555 
  def __repr__(self):
9556 
    L = ['%s=%r' % (key, value)
9557 
      for key, value in self.__dict__.iteritems()]
9558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9559 
 
9560 
  def __eq__(self, other):
9561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9562 
 
9563 
  def __ne__(self, other):
9564 
    return not (self == other)
9565 
 
483 rajveer 9566 
class getAllOrders_result:
94 ashish 9567 
  """
9568 
  Attributes:
9569 
   - success
9570 
   - ex
9571 
  """
9572 
 
9573 
  thrift_spec = (
483 rajveer 9574 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9575 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9576 
  )
9577 
 
9578 
  def __init__(self, success=None, ex=None,):
9579 
    self.success = success
9580 
    self.ex = ex
9581 
 
9582 
  def read(self, iprot):
9583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9585 
      return
9586 
    iprot.readStructBegin()
9587 
    while True:
9588 
      (fname, ftype, fid) = iprot.readFieldBegin()
9589 
      if ftype == TType.STOP:
9590 
        break
9591 
      if fid == 0:
483 rajveer 9592 
        if ftype == TType.LIST:
9593 
          self.success = []
6188 rajveer 9594 
          (_etype130, _size127) = iprot.readListBegin()
9595 
          for _i131 in xrange(_size127):
9596 
            _elem132 = Order()
9597 
            _elem132.read(iprot)
9598 
            self.success.append(_elem132)
483 rajveer 9599 
          iprot.readListEnd()
94 ashish 9600 
        else:
9601 
          iprot.skip(ftype)
9602 
      elif fid == 1:
9603 
        if ftype == TType.STRUCT:
9604 
          self.ex = TransactionServiceException()
9605 
          self.ex.read(iprot)
9606 
        else:
9607 
          iprot.skip(ftype)
9608 
      else:
9609 
        iprot.skip(ftype)
9610 
      iprot.readFieldEnd()
9611 
    iprot.readStructEnd()
9612 
 
9613 
  def write(self, oprot):
9614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9616 
      return
483 rajveer 9617 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9618 
    if self.success is not None:
483 rajveer 9619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9621 
      for iter133 in self.success:
9622 
        iter133.write(oprot)
483 rajveer 9623 
      oprot.writeListEnd()
94 ashish 9624 
      oprot.writeFieldEnd()
3431 rajveer 9625 
    if self.ex is not None:
94 ashish 9626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9627 
      self.ex.write(oprot)
9628 
      oprot.writeFieldEnd()
9629 
    oprot.writeFieldStop()
9630 
    oprot.writeStructEnd()
9631 
 
3431 rajveer 9632 
  def validate(self):
9633 
    return
9634 
 
9635 
 
94 ashish 9636 
  def __repr__(self):
9637 
    L = ['%s=%r' % (key, value)
9638 
      for key, value in self.__dict__.iteritems()]
9639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9640 
 
9641 
  def __eq__(self, other):
9642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9643 
 
9644 
  def __ne__(self, other):
9645 
    return not (self == other)
9646 
 
4133 chandransh 9647 
class getOrdersInBatch_args:
9648 
  """
9649 
  Attributes:
9650 
   - statuses
9651 
   - offset
9652 
   - limit
9653 
   - warehouse_id
9654 
  """
9655 
 
9656 
  thrift_spec = (
9657 
    None, # 0
9658 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9659 
    (2, TType.I64, 'offset', None, None, ), # 2
9660 
    (3, TType.I64, 'limit', None, None, ), # 3
9661 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9662 
  )
9663 
 
9664 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9665 
    self.statuses = statuses
9666 
    self.offset = offset
9667 
    self.limit = limit
9668 
    self.warehouse_id = warehouse_id
9669 
 
9670 
  def read(self, iprot):
9671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9673 
      return
9674 
    iprot.readStructBegin()
9675 
    while True:
9676 
      (fname, ftype, fid) = iprot.readFieldBegin()
9677 
      if ftype == TType.STOP:
9678 
        break
9679 
      if fid == 1:
9680 
        if ftype == TType.LIST:
9681 
          self.statuses = []
6188 rajveer 9682 
          (_etype137, _size134) = iprot.readListBegin()
9683 
          for _i138 in xrange(_size134):
9684 
            _elem139 = iprot.readI32();
9685 
            self.statuses.append(_elem139)
4133 chandransh 9686 
          iprot.readListEnd()
9687 
        else:
9688 
          iprot.skip(ftype)
9689 
      elif fid == 2:
9690 
        if ftype == TType.I64:
9691 
          self.offset = iprot.readI64();
9692 
        else:
9693 
          iprot.skip(ftype)
9694 
      elif fid == 3:
9695 
        if ftype == TType.I64:
9696 
          self.limit = iprot.readI64();
9697 
        else:
9698 
          iprot.skip(ftype)
9699 
      elif fid == 4:
9700 
        if ftype == TType.I64:
9701 
          self.warehouse_id = iprot.readI64();
9702 
        else:
9703 
          iprot.skip(ftype)
9704 
      else:
9705 
        iprot.skip(ftype)
9706 
      iprot.readFieldEnd()
9707 
    iprot.readStructEnd()
9708 
 
9709 
  def write(self, oprot):
9710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9712 
      return
9713 
    oprot.writeStructBegin('getOrdersInBatch_args')
9714 
    if self.statuses is not None:
9715 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9716 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9717 
      for iter140 in self.statuses:
9718 
        oprot.writeI32(iter140)
4133 chandransh 9719 
      oprot.writeListEnd()
9720 
      oprot.writeFieldEnd()
9721 
    if self.offset is not None:
9722 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9723 
      oprot.writeI64(self.offset)
9724 
      oprot.writeFieldEnd()
9725 
    if self.limit is not None:
9726 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9727 
      oprot.writeI64(self.limit)
9728 
      oprot.writeFieldEnd()
9729 
    if self.warehouse_id is not None:
9730 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9731 
      oprot.writeI64(self.warehouse_id)
9732 
      oprot.writeFieldEnd()
9733 
    oprot.writeFieldStop()
9734 
    oprot.writeStructEnd()
9735 
 
9736 
  def validate(self):
9737 
    return
9738 
 
9739 
 
9740 
  def __repr__(self):
9741 
    L = ['%s=%r' % (key, value)
9742 
      for key, value in self.__dict__.iteritems()]
9743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9744 
 
9745 
  def __eq__(self, other):
9746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9747 
 
9748 
  def __ne__(self, other):
9749 
    return not (self == other)
9750 
 
9751 
class getOrdersInBatch_result:
9752 
  """
9753 
  Attributes:
9754 
   - success
9755 
   - ex
9756 
  """
9757 
 
9758 
  thrift_spec = (
9759 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9761 
  )
9762 
 
9763 
  def __init__(self, success=None, ex=None,):
9764 
    self.success = success
9765 
    self.ex = ex
9766 
 
9767 
  def read(self, iprot):
9768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9770 
      return
9771 
    iprot.readStructBegin()
9772 
    while True:
9773 
      (fname, ftype, fid) = iprot.readFieldBegin()
9774 
      if ftype == TType.STOP:
9775 
        break
9776 
      if fid == 0:
9777 
        if ftype == TType.LIST:
9778 
          self.success = []
6188 rajveer 9779 
          (_etype144, _size141) = iprot.readListBegin()
9780 
          for _i145 in xrange(_size141):
9781 
            _elem146 = Order()
9782 
            _elem146.read(iprot)
9783 
            self.success.append(_elem146)
4133 chandransh 9784 
          iprot.readListEnd()
9785 
        else:
9786 
          iprot.skip(ftype)
9787 
      elif fid == 1:
9788 
        if ftype == TType.STRUCT:
9789 
          self.ex = TransactionServiceException()
9790 
          self.ex.read(iprot)
9791 
        else:
9792 
          iprot.skip(ftype)
9793 
      else:
9794 
        iprot.skip(ftype)
9795 
      iprot.readFieldEnd()
9796 
    iprot.readStructEnd()
9797 
 
9798 
  def write(self, oprot):
9799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9801 
      return
9802 
    oprot.writeStructBegin('getOrdersInBatch_result')
9803 
    if self.success is not None:
9804 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9805 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9806 
      for iter147 in self.success:
9807 
        iter147.write(oprot)
4133 chandransh 9808 
      oprot.writeListEnd()
9809 
      oprot.writeFieldEnd()
9810 
    if self.ex is not None:
9811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9812 
      self.ex.write(oprot)
9813 
      oprot.writeFieldEnd()
9814 
    oprot.writeFieldStop()
9815 
    oprot.writeStructEnd()
9816 
 
9817 
  def validate(self):
9818 
    return
9819 
 
9820 
 
9821 
  def __repr__(self):
9822 
    L = ['%s=%r' % (key, value)
9823 
      for key, value in self.__dict__.iteritems()]
9824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9825 
 
9826 
  def __eq__(self, other):
9827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9828 
 
9829 
  def __ne__(self, other):
9830 
    return not (self == other)
9831 
 
9832 
class getOrderCount_args:
9833 
  """
9834 
  Attributes:
9835 
   - statuses
9836 
   - warehouseId
9837 
  """
9838 
 
9839 
  thrift_spec = (
9840 
    None, # 0
9841 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9842 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9843 
  )
9844 
 
9845 
  def __init__(self, statuses=None, warehouseId=None,):
9846 
    self.statuses = statuses
9847 
    self.warehouseId = warehouseId
9848 
 
9849 
  def read(self, iprot):
9850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9852 
      return
9853 
    iprot.readStructBegin()
9854 
    while True:
9855 
      (fname, ftype, fid) = iprot.readFieldBegin()
9856 
      if ftype == TType.STOP:
9857 
        break
9858 
      if fid == 1:
9859 
        if ftype == TType.LIST:
9860 
          self.statuses = []
6188 rajveer 9861 
          (_etype151, _size148) = iprot.readListBegin()
9862 
          for _i152 in xrange(_size148):
9863 
            _elem153 = iprot.readI32();
9864 
            self.statuses.append(_elem153)
4133 chandransh 9865 
          iprot.readListEnd()
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      elif fid == 2:
9869 
        if ftype == TType.I64:
9870 
          self.warehouseId = iprot.readI64();
9871 
        else:
9872 
          iprot.skip(ftype)
9873 
      else:
9874 
        iprot.skip(ftype)
9875 
      iprot.readFieldEnd()
9876 
    iprot.readStructEnd()
9877 
 
9878 
  def write(self, oprot):
9879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9881 
      return
9882 
    oprot.writeStructBegin('getOrderCount_args')
9883 
    if self.statuses is not None:
9884 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9885 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9886 
      for iter154 in self.statuses:
9887 
        oprot.writeI32(iter154)
4133 chandransh 9888 
      oprot.writeListEnd()
9889 
      oprot.writeFieldEnd()
9890 
    if self.warehouseId is not None:
9891 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9892 
      oprot.writeI64(self.warehouseId)
9893 
      oprot.writeFieldEnd()
9894 
    oprot.writeFieldStop()
9895 
    oprot.writeStructEnd()
9896 
 
9897 
  def validate(self):
9898 
    return
9899 
 
9900 
 
9901 
  def __repr__(self):
9902 
    L = ['%s=%r' % (key, value)
9903 
      for key, value in self.__dict__.iteritems()]
9904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9905 
 
9906 
  def __eq__(self, other):
9907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9908 
 
9909 
  def __ne__(self, other):
9910 
    return not (self == other)
9911 
 
9912 
class getOrderCount_result:
9913 
  """
9914 
  Attributes:
9915 
   - success
9916 
   - ex
9917 
  """
9918 
 
9919 
  thrift_spec = (
9920 
    (0, TType.I32, 'success', None, None, ), # 0
9921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9922 
  )
9923 
 
9924 
  def __init__(self, success=None, ex=None,):
9925 
    self.success = success
9926 
    self.ex = ex
9927 
 
9928 
  def read(self, iprot):
9929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9931 
      return
9932 
    iprot.readStructBegin()
9933 
    while True:
9934 
      (fname, ftype, fid) = iprot.readFieldBegin()
9935 
      if ftype == TType.STOP:
9936 
        break
9937 
      if fid == 0:
9938 
        if ftype == TType.I32:
9939 
          self.success = iprot.readI32();
9940 
        else:
9941 
          iprot.skip(ftype)
9942 
      elif fid == 1:
9943 
        if ftype == TType.STRUCT:
9944 
          self.ex = TransactionServiceException()
9945 
          self.ex.read(iprot)
9946 
        else:
9947 
          iprot.skip(ftype)
9948 
      else:
9949 
        iprot.skip(ftype)
9950 
      iprot.readFieldEnd()
9951 
    iprot.readStructEnd()
9952 
 
9953 
  def write(self, oprot):
9954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9956 
      return
9957 
    oprot.writeStructBegin('getOrderCount_result')
9958 
    if self.success is not None:
9959 
      oprot.writeFieldBegin('success', TType.I32, 0)
9960 
      oprot.writeI32(self.success)
9961 
      oprot.writeFieldEnd()
9962 
    if self.ex is not None:
9963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9964 
      self.ex.write(oprot)
9965 
      oprot.writeFieldEnd()
9966 
    oprot.writeFieldStop()
9967 
    oprot.writeStructEnd()
9968 
 
9969 
  def validate(self):
9970 
    return
9971 
 
9972 
 
9973 
  def __repr__(self):
9974 
    L = ['%s=%r' % (key, value)
9975 
      for key, value in self.__dict__.iteritems()]
9976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9977 
 
9978 
  def __eq__(self, other):
9979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9980 
 
9981 
  def __ne__(self, other):
9982 
    return not (self == other)
9983 
 
999 varun.gupt 9984 
class getOrdersByBillingDate_args:
9985 
  """
9986 
  Attributes:
9987 
   - status
9988 
   - start_billing_date
9989 
   - end_billing_date
9990 
   - warehouse_id
9991 
  """
9992 
 
9993 
  thrift_spec = (
9994 
    None, # 0
9995 
    (1, TType.I32, 'status', None, None, ), # 1
9996 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9997 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9998 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9999 
  )
10000 
 
10001 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10002 
    self.status = status
10003 
    self.start_billing_date = start_billing_date
10004 
    self.end_billing_date = end_billing_date
10005 
    self.warehouse_id = warehouse_id
10006 
 
10007 
  def read(self, iprot):
10008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10010 
      return
10011 
    iprot.readStructBegin()
10012 
    while True:
10013 
      (fname, ftype, fid) = iprot.readFieldBegin()
10014 
      if ftype == TType.STOP:
10015 
        break
10016 
      if fid == 1:
10017 
        if ftype == TType.I32:
10018 
          self.status = iprot.readI32();
10019 
        else:
10020 
          iprot.skip(ftype)
10021 
      elif fid == 2:
10022 
        if ftype == TType.I64:
10023 
          self.start_billing_date = iprot.readI64();
10024 
        else:
10025 
          iprot.skip(ftype)
10026 
      elif fid == 3:
10027 
        if ftype == TType.I64:
10028 
          self.end_billing_date = iprot.readI64();
10029 
        else:
10030 
          iprot.skip(ftype)
10031 
      elif fid == 4:
10032 
        if ftype == TType.I64:
10033 
          self.warehouse_id = iprot.readI64();
10034 
        else:
10035 
          iprot.skip(ftype)
10036 
      else:
10037 
        iprot.skip(ftype)
10038 
      iprot.readFieldEnd()
10039 
    iprot.readStructEnd()
10040 
 
10041 
  def write(self, oprot):
10042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10044 
      return
10045 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10046 
    if self.status is not None:
999 varun.gupt 10047 
      oprot.writeFieldBegin('status', TType.I32, 1)
10048 
      oprot.writeI32(self.status)
10049 
      oprot.writeFieldEnd()
3431 rajveer 10050 
    if self.start_billing_date is not None:
999 varun.gupt 10051 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10052 
      oprot.writeI64(self.start_billing_date)
10053 
      oprot.writeFieldEnd()
3431 rajveer 10054 
    if self.end_billing_date is not None:
999 varun.gupt 10055 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10056 
      oprot.writeI64(self.end_billing_date)
10057 
      oprot.writeFieldEnd()
3431 rajveer 10058 
    if self.warehouse_id is not None:
999 varun.gupt 10059 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10060 
      oprot.writeI64(self.warehouse_id)
10061 
      oprot.writeFieldEnd()
10062 
    oprot.writeFieldStop()
10063 
    oprot.writeStructEnd()
10064 
 
3431 rajveer 10065 
  def validate(self):
10066 
    return
10067 
 
10068 
 
999 varun.gupt 10069 
  def __repr__(self):
10070 
    L = ['%s=%r' % (key, value)
10071 
      for key, value in self.__dict__.iteritems()]
10072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10073 
 
10074 
  def __eq__(self, other):
10075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10076 
 
10077 
  def __ne__(self, other):
10078 
    return not (self == other)
10079 
 
10080 
class getOrdersByBillingDate_result:
10081 
  """
10082 
  Attributes:
10083 
   - success
10084 
   - ex
10085 
  """
10086 
 
10087 
  thrift_spec = (
10088 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10089 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10090 
  )
10091 
 
10092 
  def __init__(self, success=None, ex=None,):
10093 
    self.success = success
10094 
    self.ex = ex
10095 
 
10096 
  def read(self, iprot):
10097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10099 
      return
10100 
    iprot.readStructBegin()
10101 
    while True:
10102 
      (fname, ftype, fid) = iprot.readFieldBegin()
10103 
      if ftype == TType.STOP:
10104 
        break
10105 
      if fid == 0:
10106 
        if ftype == TType.LIST:
10107 
          self.success = []
6188 rajveer 10108 
          (_etype158, _size155) = iprot.readListBegin()
10109 
          for _i159 in xrange(_size155):
10110 
            _elem160 = Order()
10111 
            _elem160.read(iprot)
10112 
            self.success.append(_elem160)
999 varun.gupt 10113 
          iprot.readListEnd()
10114 
        else:
10115 
          iprot.skip(ftype)
10116 
      elif fid == 1:
10117 
        if ftype == TType.STRUCT:
10118 
          self.ex = TransactionServiceException()
10119 
          self.ex.read(iprot)
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      else:
10123 
        iprot.skip(ftype)
10124 
      iprot.readFieldEnd()
10125 
    iprot.readStructEnd()
10126 
 
10127 
  def write(self, oprot):
10128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10130 
      return
10131 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10132 
    if self.success is not None:
999 varun.gupt 10133 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10134 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10135 
      for iter161 in self.success:
10136 
        iter161.write(oprot)
999 varun.gupt 10137 
      oprot.writeListEnd()
10138 
      oprot.writeFieldEnd()
3431 rajveer 10139 
    if self.ex is not None:
999 varun.gupt 10140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10141 
      self.ex.write(oprot)
10142 
      oprot.writeFieldEnd()
10143 
    oprot.writeFieldStop()
10144 
    oprot.writeStructEnd()
10145 
 
3431 rajveer 10146 
  def validate(self):
10147 
    return
10148 
 
10149 
 
999 varun.gupt 10150 
  def __repr__(self):
10151 
    L = ['%s=%r' % (key, value)
10152 
      for key, value in self.__dict__.iteritems()]
10153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10154 
 
10155 
  def __eq__(self, other):
10156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10157 
 
10158 
  def __ne__(self, other):
10159 
    return not (self == other)
10160 
 
3427 chandransh 10161 
class getOrdersByShippingDate_args:
10162 
  """
10163 
  Attributes:
10164 
   - fromShippingDate
10165 
   - toShippingDate
10166 
   - providerId
10167 
   - warehouseId
3451 chandransh 10168 
   - cod
3427 chandransh 10169 
  """
10170 
 
10171 
  thrift_spec = (
10172 
    None, # 0
10173 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10174 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10175 
    (3, TType.I64, 'providerId', None, None, ), # 3
10176 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10177 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10178 
  )
10179 
 
3451 chandransh 10180 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10181 
    self.fromShippingDate = fromShippingDate
10182 
    self.toShippingDate = toShippingDate
10183 
    self.providerId = providerId
10184 
    self.warehouseId = warehouseId
3451 chandransh 10185 
    self.cod = cod
3427 chandransh 10186 
 
10187 
  def read(self, iprot):
10188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10190 
      return
10191 
    iprot.readStructBegin()
10192 
    while True:
10193 
      (fname, ftype, fid) = iprot.readFieldBegin()
10194 
      if ftype == TType.STOP:
10195 
        break
10196 
      if fid == 1:
10197 
        if ftype == TType.I64:
10198 
          self.fromShippingDate = iprot.readI64();
10199 
        else:
10200 
          iprot.skip(ftype)
10201 
      elif fid == 2:
10202 
        if ftype == TType.I64:
10203 
          self.toShippingDate = iprot.readI64();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      elif fid == 3:
10207 
        if ftype == TType.I64:
10208 
          self.providerId = iprot.readI64();
10209 
        else:
10210 
          iprot.skip(ftype)
10211 
      elif fid == 4:
10212 
        if ftype == TType.I64:
10213 
          self.warehouseId = iprot.readI64();
10214 
        else:
10215 
          iprot.skip(ftype)
3451 chandransh 10216 
      elif fid == 5:
10217 
        if ftype == TType.BOOL:
10218 
          self.cod = iprot.readBool();
10219 
        else:
10220 
          iprot.skip(ftype)
3427 chandransh 10221 
      else:
10222 
        iprot.skip(ftype)
10223 
      iprot.readFieldEnd()
10224 
    iprot.readStructEnd()
10225 
 
10226 
  def write(self, oprot):
10227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10229 
      return
10230 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10231 
    if self.fromShippingDate is not None:
3427 chandransh 10232 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10233 
      oprot.writeI64(self.fromShippingDate)
10234 
      oprot.writeFieldEnd()
3431 rajveer 10235 
    if self.toShippingDate is not None:
3427 chandransh 10236 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10237 
      oprot.writeI64(self.toShippingDate)
10238 
      oprot.writeFieldEnd()
3431 rajveer 10239 
    if self.providerId is not None:
3427 chandransh 10240 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10241 
      oprot.writeI64(self.providerId)
10242 
      oprot.writeFieldEnd()
3431 rajveer 10243 
    if self.warehouseId is not None:
3427 chandransh 10244 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10245 
      oprot.writeI64(self.warehouseId)
10246 
      oprot.writeFieldEnd()
3451 chandransh 10247 
    if self.cod is not None:
10248 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10249 
      oprot.writeBool(self.cod)
10250 
      oprot.writeFieldEnd()
3427 chandransh 10251 
    oprot.writeFieldStop()
10252 
    oprot.writeStructEnd()
10253 
 
3431 rajveer 10254 
  def validate(self):
10255 
    return
10256 
 
10257 
 
3427 chandransh 10258 
  def __repr__(self):
10259 
    L = ['%s=%r' % (key, value)
10260 
      for key, value in self.__dict__.iteritems()]
10261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10262 
 
10263 
  def __eq__(self, other):
10264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10265 
 
10266 
  def __ne__(self, other):
10267 
    return not (self == other)
10268 
 
10269 
class getOrdersByShippingDate_result:
10270 
  """
10271 
  Attributes:
10272 
   - success
10273 
   - ex
10274 
  """
10275 
 
10276 
  thrift_spec = (
10277 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10279 
  )
10280 
 
10281 
  def __init__(self, success=None, ex=None,):
10282 
    self.success = success
10283 
    self.ex = ex
10284 
 
10285 
  def read(self, iprot):
10286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10288 
      return
10289 
    iprot.readStructBegin()
10290 
    while True:
10291 
      (fname, ftype, fid) = iprot.readFieldBegin()
10292 
      if ftype == TType.STOP:
10293 
        break
10294 
      if fid == 0:
10295 
        if ftype == TType.LIST:
10296 
          self.success = []
6188 rajveer 10297 
          (_etype165, _size162) = iprot.readListBegin()
10298 
          for _i166 in xrange(_size162):
10299 
            _elem167 = Order()
10300 
            _elem167.read(iprot)
10301 
            self.success.append(_elem167)
3427 chandransh 10302 
          iprot.readListEnd()
10303 
        else:
10304 
          iprot.skip(ftype)
10305 
      elif fid == 1:
10306 
        if ftype == TType.STRUCT:
10307 
          self.ex = TransactionServiceException()
10308 
          self.ex.read(iprot)
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
10320 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10321 
    if self.success is not None:
3427 chandransh 10322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10324 
      for iter168 in self.success:
10325 
        iter168.write(oprot)
3427 chandransh 10326 
      oprot.writeListEnd()
10327 
      oprot.writeFieldEnd()
3431 rajveer 10328 
    if self.ex is not None:
3427 chandransh 10329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10330 
      self.ex.write(oprot)
10331 
      oprot.writeFieldEnd()
10332 
    oprot.writeFieldStop()
10333 
    oprot.writeStructEnd()
10334 
 
3431 rajveer 10335 
  def validate(self):
10336 
    return
10337 
 
10338 
 
3427 chandransh 10339 
  def __repr__(self):
10340 
    L = ['%s=%r' % (key, value)
10341 
      for key, value in self.__dict__.iteritems()]
10342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10343 
 
10344 
  def __eq__(self, other):
10345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10346 
 
10347 
  def __ne__(self, other):
10348 
    return not (self == other)
10349 
 
1382 varun.gupt 10350 
class getReturnableOrdersForCustomer_args:
10351 
  """
10352 
  Attributes:
10353 
   - customer_id
10354 
   - limit
10355 
  """
10356 
 
10357 
  thrift_spec = (
10358 
    None, # 0
10359 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10360 
    (2, TType.I64, 'limit', None, None, ), # 2
10361 
  )
10362 
 
10363 
  def __init__(self, customer_id=None, limit=None,):
10364 
    self.customer_id = customer_id
10365 
    self.limit = limit
10366 
 
10367 
  def read(self, iprot):
10368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10370 
      return
10371 
    iprot.readStructBegin()
10372 
    while True:
10373 
      (fname, ftype, fid) = iprot.readFieldBegin()
10374 
      if ftype == TType.STOP:
10375 
        break
10376 
      if fid == 1:
10377 
        if ftype == TType.I64:
10378 
          self.customer_id = iprot.readI64();
10379 
        else:
10380 
          iprot.skip(ftype)
10381 
      elif fid == 2:
10382 
        if ftype == TType.I64:
10383 
          self.limit = iprot.readI64();
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
10395 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10396 
    if self.customer_id is not None:
1382 varun.gupt 10397 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10398 
      oprot.writeI64(self.customer_id)
10399 
      oprot.writeFieldEnd()
3431 rajveer 10400 
    if self.limit is not None:
1382 varun.gupt 10401 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10402 
      oprot.writeI64(self.limit)
10403 
      oprot.writeFieldEnd()
10404 
    oprot.writeFieldStop()
10405 
    oprot.writeStructEnd()
10406 
 
3431 rajveer 10407 
  def validate(self):
10408 
    return
10409 
 
10410 
 
1382 varun.gupt 10411 
  def __repr__(self):
10412 
    L = ['%s=%r' % (key, value)
10413 
      for key, value in self.__dict__.iteritems()]
10414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10415 
 
10416 
  def __eq__(self, other):
10417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10418 
 
10419 
  def __ne__(self, other):
10420 
    return not (self == other)
10421 
 
10422 
class getReturnableOrdersForCustomer_result:
10423 
  """
10424 
  Attributes:
10425 
   - success
10426 
   - ex
10427 
  """
10428 
 
10429 
  thrift_spec = (
10430 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10432 
  )
10433 
 
10434 
  def __init__(self, success=None, ex=None,):
10435 
    self.success = success
10436 
    self.ex = ex
10437 
 
10438 
  def read(self, iprot):
10439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10441 
      return
10442 
    iprot.readStructBegin()
10443 
    while True:
10444 
      (fname, ftype, fid) = iprot.readFieldBegin()
10445 
      if ftype == TType.STOP:
10446 
        break
10447 
      if fid == 0:
10448 
        if ftype == TType.LIST:
10449 
          self.success = []
6188 rajveer 10450 
          (_etype172, _size169) = iprot.readListBegin()
10451 
          for _i173 in xrange(_size169):
10452 
            _elem174 = iprot.readI64();
10453 
            self.success.append(_elem174)
1382 varun.gupt 10454 
          iprot.readListEnd()
10455 
        else:
10456 
          iprot.skip(ftype)
10457 
      elif fid == 1:
10458 
        if ftype == TType.STRUCT:
10459 
          self.ex = TransactionServiceException()
10460 
          self.ex.read(iprot)
10461 
        else:
10462 
          iprot.skip(ftype)
10463 
      else:
10464 
        iprot.skip(ftype)
10465 
      iprot.readFieldEnd()
10466 
    iprot.readStructEnd()
10467 
 
10468 
  def write(self, oprot):
10469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10471 
      return
10472 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10473 
    if self.success is not None:
1382 varun.gupt 10474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10475 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10476 
      for iter175 in self.success:
10477 
        oprot.writeI64(iter175)
1382 varun.gupt 10478 
      oprot.writeListEnd()
10479 
      oprot.writeFieldEnd()
3431 rajveer 10480 
    if self.ex is not None:
1382 varun.gupt 10481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10482 
      self.ex.write(oprot)
10483 
      oprot.writeFieldEnd()
10484 
    oprot.writeFieldStop()
10485 
    oprot.writeStructEnd()
10486 
 
3431 rajveer 10487 
  def validate(self):
10488 
    return
10489 
 
10490 
 
1382 varun.gupt 10491 
  def __repr__(self):
10492 
    L = ['%s=%r' % (key, value)
10493 
      for key, value in self.__dict__.iteritems()]
10494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10495 
 
10496 
  def __eq__(self, other):
10497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10498 
 
10499 
  def __ne__(self, other):
10500 
    return not (self == other)
10501 
 
10502 
class getCancellableOrdersForCustomer_args:
10503 
  """
10504 
  Attributes:
10505 
   - customer_id
10506 
   - limit
10507 
  """
10508 
 
10509 
  thrift_spec = (
10510 
    None, # 0
10511 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10512 
    (2, TType.I64, 'limit', None, None, ), # 2
10513 
  )
10514 
 
10515 
  def __init__(self, customer_id=None, limit=None,):
10516 
    self.customer_id = customer_id
10517 
    self.limit = limit
10518 
 
10519 
  def read(self, iprot):
10520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10522 
      return
10523 
    iprot.readStructBegin()
10524 
    while True:
10525 
      (fname, ftype, fid) = iprot.readFieldBegin()
10526 
      if ftype == TType.STOP:
10527 
        break
10528 
      if fid == 1:
10529 
        if ftype == TType.I64:
10530 
          self.customer_id = iprot.readI64();
10531 
        else:
10532 
          iprot.skip(ftype)
10533 
      elif fid == 2:
10534 
        if ftype == TType.I64:
10535 
          self.limit = iprot.readI64();
10536 
        else:
10537 
          iprot.skip(ftype)
10538 
      else:
10539 
        iprot.skip(ftype)
10540 
      iprot.readFieldEnd()
10541 
    iprot.readStructEnd()
10542 
 
10543 
  def write(self, oprot):
10544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10546 
      return
10547 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10548 
    if self.customer_id is not None:
1382 varun.gupt 10549 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10550 
      oprot.writeI64(self.customer_id)
10551 
      oprot.writeFieldEnd()
3431 rajveer 10552 
    if self.limit is not None:
1382 varun.gupt 10553 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10554 
      oprot.writeI64(self.limit)
10555 
      oprot.writeFieldEnd()
10556 
    oprot.writeFieldStop()
10557 
    oprot.writeStructEnd()
10558 
 
3431 rajveer 10559 
  def validate(self):
10560 
    return
10561 
 
10562 
 
1382 varun.gupt 10563 
  def __repr__(self):
10564 
    L = ['%s=%r' % (key, value)
10565 
      for key, value in self.__dict__.iteritems()]
10566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10567 
 
10568 
  def __eq__(self, other):
10569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10570 
 
10571 
  def __ne__(self, other):
10572 
    return not (self == other)
10573 
 
10574 
class getCancellableOrdersForCustomer_result:
10575 
  """
10576 
  Attributes:
10577 
   - success
10578 
   - ex
10579 
  """
10580 
 
10581 
  thrift_spec = (
10582 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10584 
  )
10585 
 
10586 
  def __init__(self, success=None, ex=None,):
10587 
    self.success = success
10588 
    self.ex = ex
10589 
 
10590 
  def read(self, iprot):
10591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10593 
      return
10594 
    iprot.readStructBegin()
10595 
    while True:
10596 
      (fname, ftype, fid) = iprot.readFieldBegin()
10597 
      if ftype == TType.STOP:
10598 
        break
10599 
      if fid == 0:
10600 
        if ftype == TType.LIST:
10601 
          self.success = []
6188 rajveer 10602 
          (_etype179, _size176) = iprot.readListBegin()
10603 
          for _i180 in xrange(_size176):
10604 
            _elem181 = iprot.readI64();
10605 
            self.success.append(_elem181)
1382 varun.gupt 10606 
          iprot.readListEnd()
10607 
        else:
10608 
          iprot.skip(ftype)
10609 
      elif fid == 1:
10610 
        if ftype == TType.STRUCT:
10611 
          self.ex = TransactionServiceException()
10612 
          self.ex.read(iprot)
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      else:
10616 
        iprot.skip(ftype)
10617 
      iprot.readFieldEnd()
10618 
    iprot.readStructEnd()
10619 
 
10620 
  def write(self, oprot):
10621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10623 
      return
10624 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10625 
    if self.success is not None:
1382 varun.gupt 10626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10627 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10628 
      for iter182 in self.success:
10629 
        oprot.writeI64(iter182)
1382 varun.gupt 10630 
      oprot.writeListEnd()
10631 
      oprot.writeFieldEnd()
3431 rajveer 10632 
    if self.ex is not None:
1382 varun.gupt 10633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10634 
      self.ex.write(oprot)
10635 
      oprot.writeFieldEnd()
10636 
    oprot.writeFieldStop()
10637 
    oprot.writeStructEnd()
10638 
 
3431 rajveer 10639 
  def validate(self):
10640 
    return
10641 
 
10642 
 
1382 varun.gupt 10643 
  def __repr__(self):
10644 
    L = ['%s=%r' % (key, value)
10645 
      for key, value in self.__dict__.iteritems()]
10646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10647 
 
10648 
  def __eq__(self, other):
10649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10650 
 
10651 
  def __ne__(self, other):
10652 
    return not (self == other)
10653 
 
483 rajveer 10654 
class changeOrderStatus_args:
94 ashish 10655 
  """
10656 
  Attributes:
483 rajveer 10657 
   - orderId
10658 
   - status
10659 
   - description
94 ashish 10660 
  """
10661 
 
10662 
  thrift_spec = (
10663 
    None, # 0
483 rajveer 10664 
    (1, TType.I64, 'orderId', None, None, ), # 1
10665 
    (2, TType.I32, 'status', None, None, ), # 2
10666 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10667 
  )
10668 
 
483 rajveer 10669 
  def __init__(self, orderId=None, status=None, description=None,):
10670 
    self.orderId = orderId
10671 
    self.status = status
10672 
    self.description = description
94 ashish 10673 
 
10674 
  def read(self, iprot):
10675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10677 
      return
10678 
    iprot.readStructBegin()
10679 
    while True:
10680 
      (fname, ftype, fid) = iprot.readFieldBegin()
10681 
      if ftype == TType.STOP:
10682 
        break
10683 
      if fid == 1:
10684 
        if ftype == TType.I64:
483 rajveer 10685 
          self.orderId = iprot.readI64();
94 ashish 10686 
        else:
10687 
          iprot.skip(ftype)
10688 
      elif fid == 2:
483 rajveer 10689 
        if ftype == TType.I32:
10690 
          self.status = iprot.readI32();
94 ashish 10691 
        else:
10692 
          iprot.skip(ftype)
483 rajveer 10693 
      elif fid == 3:
10694 
        if ftype == TType.STRING:
10695 
          self.description = iprot.readString();
10696 
        else:
10697 
          iprot.skip(ftype)
94 ashish 10698 
      else:
10699 
        iprot.skip(ftype)
10700 
      iprot.readFieldEnd()
10701 
    iprot.readStructEnd()
10702 
 
10703 
  def write(self, oprot):
10704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10706 
      return
483 rajveer 10707 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10708 
    if self.orderId is not None:
483 rajveer 10709 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10710 
      oprot.writeI64(self.orderId)
94 ashish 10711 
      oprot.writeFieldEnd()
3431 rajveer 10712 
    if self.status is not None:
483 rajveer 10713 
      oprot.writeFieldBegin('status', TType.I32, 2)
10714 
      oprot.writeI32(self.status)
94 ashish 10715 
      oprot.writeFieldEnd()
3431 rajveer 10716 
    if self.description is not None:
483 rajveer 10717 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10718 
      oprot.writeString(self.description)
10719 
      oprot.writeFieldEnd()
94 ashish 10720 
    oprot.writeFieldStop()
10721 
    oprot.writeStructEnd()
10722 
 
3431 rajveer 10723 
  def validate(self):
10724 
    return
10725 
 
10726 
 
94 ashish 10727 
  def __repr__(self):
10728 
    L = ['%s=%r' % (key, value)
10729 
      for key, value in self.__dict__.iteritems()]
10730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10731 
 
10732 
  def __eq__(self, other):
10733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10734 
 
10735 
  def __ne__(self, other):
10736 
    return not (self == other)
10737 
 
483 rajveer 10738 
class changeOrderStatus_result:
94 ashish 10739 
  """
10740 
  Attributes:
10741 
   - success
10742 
   - ex
10743 
  """
10744 
 
10745 
  thrift_spec = (
10746 
    (0, TType.BOOL, 'success', None, None, ), # 0
10747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10748 
  )
10749 
 
10750 
  def __init__(self, success=None, ex=None,):
10751 
    self.success = success
10752 
    self.ex = ex
10753 
 
10754 
  def read(self, iprot):
10755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10757 
      return
10758 
    iprot.readStructBegin()
10759 
    while True:
10760 
      (fname, ftype, fid) = iprot.readFieldBegin()
10761 
      if ftype == TType.STOP:
10762 
        break
10763 
      if fid == 0:
10764 
        if ftype == TType.BOOL:
10765 
          self.success = iprot.readBool();
10766 
        else:
10767 
          iprot.skip(ftype)
10768 
      elif fid == 1:
10769 
        if ftype == TType.STRUCT:
10770 
          self.ex = TransactionServiceException()
10771 
          self.ex.read(iprot)
10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      else:
10775 
        iprot.skip(ftype)
10776 
      iprot.readFieldEnd()
10777 
    iprot.readStructEnd()
10778 
 
10779 
  def write(self, oprot):
10780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10782 
      return
483 rajveer 10783 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10784 
    if self.success is not None:
94 ashish 10785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10786 
      oprot.writeBool(self.success)
10787 
      oprot.writeFieldEnd()
3431 rajveer 10788 
    if self.ex is not None:
94 ashish 10789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10790 
      self.ex.write(oprot)
10791 
      oprot.writeFieldEnd()
10792 
    oprot.writeFieldStop()
10793 
    oprot.writeStructEnd()
10794 
 
3431 rajveer 10795 
  def validate(self):
10796 
    return
10797 
 
10798 
 
94 ashish 10799 
  def __repr__(self):
10800 
    L = ['%s=%r' % (key, value)
10801 
      for key, value in self.__dict__.iteritems()]
10802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10803 
 
10804 
  def __eq__(self, other):
10805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10806 
 
10807 
  def __ne__(self, other):
10808 
    return not (self == other)
10809 
 
3064 chandransh 10810 
class getOrdersForTransaction_args:
494 rajveer 10811 
  """
10812 
  Attributes:
3064 chandransh 10813 
   - transactionId
10814 
   - customerId
494 rajveer 10815 
  """
10816 
 
10817 
  thrift_spec = (
10818 
    None, # 0
3064 chandransh 10819 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10820 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10821 
  )
10822 
 
3064 chandransh 10823 
  def __init__(self, transactionId=None, customerId=None,):
10824 
    self.transactionId = transactionId
10825 
    self.customerId = customerId
494 rajveer 10826 
 
10827 
  def read(self, iprot):
10828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10830 
      return
10831 
    iprot.readStructBegin()
10832 
    while True:
10833 
      (fname, ftype, fid) = iprot.readFieldBegin()
10834 
      if ftype == TType.STOP:
10835 
        break
10836 
      if fid == 1:
10837 
        if ftype == TType.I64:
3064 chandransh 10838 
          self.transactionId = iprot.readI64();
494 rajveer 10839 
        else:
10840 
          iprot.skip(ftype)
10841 
      elif fid == 2:
3064 chandransh 10842 
        if ftype == TType.I64:
10843 
          self.customerId = iprot.readI64();
494 rajveer 10844 
        else:
10845 
          iprot.skip(ftype)
10846 
      else:
10847 
        iprot.skip(ftype)
10848 
      iprot.readFieldEnd()
10849 
    iprot.readStructEnd()
10850 
 
10851 
  def write(self, oprot):
10852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10854 
      return
3064 chandransh 10855 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10856 
    if self.transactionId is not None:
3064 chandransh 10857 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10858 
      oprot.writeI64(self.transactionId)
494 rajveer 10859 
      oprot.writeFieldEnd()
3431 rajveer 10860 
    if self.customerId is not None:
3064 chandransh 10861 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10862 
      oprot.writeI64(self.customerId)
494 rajveer 10863 
      oprot.writeFieldEnd()
10864 
    oprot.writeFieldStop()
10865 
    oprot.writeStructEnd()
10866 
 
3431 rajveer 10867 
  def validate(self):
10868 
    return
10869 
 
10870 
 
494 rajveer 10871 
  def __repr__(self):
10872 
    L = ['%s=%r' % (key, value)
10873 
      for key, value in self.__dict__.iteritems()]
10874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10875 
 
10876 
  def __eq__(self, other):
10877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10878 
 
10879 
  def __ne__(self, other):
10880 
    return not (self == other)
10881 
 
3064 chandransh 10882 
class getOrdersForTransaction_result:
494 rajveer 10883 
  """
10884 
  Attributes:
10885 
   - success
10886 
   - ex
10887 
  """
10888 
 
10889 
  thrift_spec = (
3064 chandransh 10890 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10892 
  )
10893 
 
10894 
  def __init__(self, success=None, ex=None,):
10895 
    self.success = success
10896 
    self.ex = ex
10897 
 
10898 
  def read(self, iprot):
10899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10901 
      return
10902 
    iprot.readStructBegin()
10903 
    while True:
10904 
      (fname, ftype, fid) = iprot.readFieldBegin()
10905 
      if ftype == TType.STOP:
10906 
        break
10907 
      if fid == 0:
3064 chandransh 10908 
        if ftype == TType.LIST:
10909 
          self.success = []
6188 rajveer 10910 
          (_etype186, _size183) = iprot.readListBegin()
10911 
          for _i187 in xrange(_size183):
10912 
            _elem188 = Order()
10913 
            _elem188.read(iprot)
10914 
            self.success.append(_elem188)
3064 chandransh 10915 
          iprot.readListEnd()
494 rajveer 10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      elif fid == 1:
10919 
        if ftype == TType.STRUCT:
10920 
          self.ex = TransactionServiceException()
10921 
          self.ex.read(iprot)
10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      else:
10925 
        iprot.skip(ftype)
10926 
      iprot.readFieldEnd()
10927 
    iprot.readStructEnd()
10928 
 
10929 
  def write(self, oprot):
10930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10932 
      return
3064 chandransh 10933 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10934 
    if self.success is not None:
3064 chandransh 10935 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10936 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10937 
      for iter189 in self.success:
10938 
        iter189.write(oprot)
3064 chandransh 10939 
      oprot.writeListEnd()
494 rajveer 10940 
      oprot.writeFieldEnd()
3431 rajveer 10941 
    if self.ex is not None:
494 rajveer 10942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10943 
      self.ex.write(oprot)
10944 
      oprot.writeFieldEnd()
10945 
    oprot.writeFieldStop()
10946 
    oprot.writeStructEnd()
10947 
 
3431 rajveer 10948 
  def validate(self):
10949 
    return
10950 
 
10951 
 
494 rajveer 10952 
  def __repr__(self):
10953 
    L = ['%s=%r' % (key, value)
10954 
      for key, value in self.__dict__.iteritems()]
10955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10956 
 
10957 
  def __eq__(self, other):
10958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10959 
 
10960 
  def __ne__(self, other):
10961 
    return not (self == other)
10962 
 
3064 chandransh 10963 
class getOrdersForCustomer_args:
1149 chandransh 10964 
  """
10965 
  Attributes:
3064 chandransh 10966 
   - customerId
10967 
   - from_date
10968 
   - to_date
10969 
   - statuses
1149 chandransh 10970 
  """
10971 
 
10972 
  thrift_spec = (
10973 
    None, # 0
3064 chandransh 10974 
    (1, TType.I64, 'customerId', None, None, ), # 1
10975 
    (2, TType.I64, 'from_date', None, None, ), # 2
10976 
    (3, TType.I64, 'to_date', None, None, ), # 3
10977 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10978 
  )
10979 
 
3064 chandransh 10980 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10981 
    self.customerId = customerId
10982 
    self.from_date = from_date
10983 
    self.to_date = to_date
10984 
    self.statuses = statuses
1149 chandransh 10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      if fid == 1:
10996 
        if ftype == TType.I64:
3064 chandransh 10997 
          self.customerId = iprot.readI64();
1149 chandransh 10998 
        else:
10999 
          iprot.skip(ftype)
11000 
      elif fid == 2:
11001 
        if ftype == TType.I64:
3064 chandransh 11002 
          self.from_date = iprot.readI64();
1149 chandransh 11003 
        else:
11004 
          iprot.skip(ftype)
2783 chandransh 11005 
      elif fid == 3:
11006 
        if ftype == TType.I64:
3064 chandransh 11007 
          self.to_date = iprot.readI64();
2783 chandransh 11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      elif fid == 4:
3064 chandransh 11011 
        if ftype == TType.LIST:
11012 
          self.statuses = []
6188 rajveer 11013 
          (_etype193, _size190) = iprot.readListBegin()
11014 
          for _i194 in xrange(_size190):
11015 
            _elem195 = iprot.readI32();
11016 
            self.statuses.append(_elem195)
3064 chandransh 11017 
          iprot.readListEnd()
2783 chandransh 11018 
        else:
11019 
          iprot.skip(ftype)
1149 chandransh 11020 
      else:
11021 
        iprot.skip(ftype)
11022 
      iprot.readFieldEnd()
11023 
    iprot.readStructEnd()
11024 
 
11025 
  def write(self, oprot):
11026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11028 
      return
3064 chandransh 11029 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11030 
    if self.customerId is not None:
3064 chandransh 11031 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11032 
      oprot.writeI64(self.customerId)
1149 chandransh 11033 
      oprot.writeFieldEnd()
3431 rajveer 11034 
    if self.from_date is not None:
3064 chandransh 11035 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11036 
      oprot.writeI64(self.from_date)
1149 chandransh 11037 
      oprot.writeFieldEnd()
3431 rajveer 11038 
    if self.to_date is not None:
3064 chandransh 11039 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11040 
      oprot.writeI64(self.to_date)
2783 chandransh 11041 
      oprot.writeFieldEnd()
3431 rajveer 11042 
    if self.statuses is not None:
3064 chandransh 11043 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11044 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11045 
      for iter196 in self.statuses:
11046 
        oprot.writeI32(iter196)
3064 chandransh 11047 
      oprot.writeListEnd()
2783 chandransh 11048 
      oprot.writeFieldEnd()
1149 chandransh 11049 
    oprot.writeFieldStop()
11050 
    oprot.writeStructEnd()
11051 
 
3431 rajveer 11052 
  def validate(self):
11053 
    return
11054 
 
11055 
 
1149 chandransh 11056 
  def __repr__(self):
11057 
    L = ['%s=%r' % (key, value)
11058 
      for key, value in self.__dict__.iteritems()]
11059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11060 
 
11061 
  def __eq__(self, other):
11062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11063 
 
11064 
  def __ne__(self, other):
11065 
    return not (self == other)
11066 
 
3064 chandransh 11067 
class getOrdersForCustomer_result:
1149 chandransh 11068 
  """
11069 
  Attributes:
11070 
   - success
11071 
   - ex
11072 
  """
11073 
 
11074 
  thrift_spec = (
3064 chandransh 11075 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11077 
  )
11078 
 
11079 
  def __init__(self, success=None, ex=None,):
11080 
    self.success = success
11081 
    self.ex = ex
11082 
 
11083 
  def read(self, iprot):
11084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11086 
      return
11087 
    iprot.readStructBegin()
11088 
    while True:
11089 
      (fname, ftype, fid) = iprot.readFieldBegin()
11090 
      if ftype == TType.STOP:
11091 
        break
11092 
      if fid == 0:
3064 chandransh 11093 
        if ftype == TType.LIST:
11094 
          self.success = []
6188 rajveer 11095 
          (_etype200, _size197) = iprot.readListBegin()
11096 
          for _i201 in xrange(_size197):
11097 
            _elem202 = Order()
11098 
            _elem202.read(iprot)
11099 
            self.success.append(_elem202)
3064 chandransh 11100 
          iprot.readListEnd()
1149 chandransh 11101 
        else:
11102 
          iprot.skip(ftype)
11103 
      elif fid == 1:
11104 
        if ftype == TType.STRUCT:
11105 
          self.ex = TransactionServiceException()
11106 
          self.ex.read(iprot)
11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      else:
11110 
        iprot.skip(ftype)
11111 
      iprot.readFieldEnd()
11112 
    iprot.readStructEnd()
11113 
 
11114 
  def write(self, oprot):
11115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11117 
      return
3064 chandransh 11118 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11119 
    if self.success is not None:
3064 chandransh 11120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11121 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11122 
      for iter203 in self.success:
11123 
        iter203.write(oprot)
3064 chandransh 11124 
      oprot.writeListEnd()
1149 chandransh 11125 
      oprot.writeFieldEnd()
3431 rajveer 11126 
    if self.ex is not None:
1149 chandransh 11127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11128 
      self.ex.write(oprot)
11129 
      oprot.writeFieldEnd()
11130 
    oprot.writeFieldStop()
11131 
    oprot.writeStructEnd()
11132 
 
3431 rajveer 11133 
  def validate(self):
11134 
    return
11135 
 
11136 
 
1149 chandransh 11137 
  def __repr__(self):
11138 
    L = ['%s=%r' % (key, value)
11139 
      for key, value in self.__dict__.iteritems()]
11140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11141 
 
11142 
  def __eq__(self, other):
11143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11144 
 
11145 
  def __ne__(self, other):
11146 
    return not (self == other)
11147 
 
3064 chandransh 11148 
class createOrder_args:
921 rajveer 11149 
  """
11150 
  Attributes:
3064 chandransh 11151 
   - order
921 rajveer 11152 
  """
11153 
 
11154 
  thrift_spec = (
11155 
    None, # 0
3064 chandransh 11156 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11157 
  )
11158 
 
3064 chandransh 11159 
  def __init__(self, order=None,):
11160 
    self.order = order
921 rajveer 11161 
 
11162 
  def read(self, iprot):
11163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11165 
      return
11166 
    iprot.readStructBegin()
11167 
    while True:
11168 
      (fname, ftype, fid) = iprot.readFieldBegin()
11169 
      if ftype == TType.STOP:
11170 
        break
11171 
      if fid == 1:
3064 chandransh 11172 
        if ftype == TType.STRUCT:
11173 
          self.order = Order()
11174 
          self.order.read(iprot)
921 rajveer 11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      else:
11178 
        iprot.skip(ftype)
11179 
      iprot.readFieldEnd()
11180 
    iprot.readStructEnd()
11181 
 
11182 
  def write(self, oprot):
11183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11185 
      return
3064 chandransh 11186 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11187 
    if self.order is not None:
3064 chandransh 11188 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11189 
      self.order.write(oprot)
921 rajveer 11190 
      oprot.writeFieldEnd()
11191 
    oprot.writeFieldStop()
11192 
    oprot.writeStructEnd()
11193 
 
3431 rajveer 11194 
  def validate(self):
11195 
    return
11196 
 
11197 
 
921 rajveer 11198 
  def __repr__(self):
11199 
    L = ['%s=%r' % (key, value)
11200 
      for key, value in self.__dict__.iteritems()]
11201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11202 
 
11203 
  def __eq__(self, other):
11204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11205 
 
11206 
  def __ne__(self, other):
11207 
    return not (self == other)
11208 
 
3064 chandransh 11209 
class createOrder_result:
921 rajveer 11210 
  """
11211 
  Attributes:
11212 
   - success
11213 
   - ex
11214 
  """
11215 
 
11216 
  thrift_spec = (
3064 chandransh 11217 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11219 
  )
11220 
 
11221 
  def __init__(self, success=None, ex=None,):
11222 
    self.success = success
11223 
    self.ex = ex
11224 
 
11225 
  def read(self, iprot):
11226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11228 
      return
11229 
    iprot.readStructBegin()
11230 
    while True:
11231 
      (fname, ftype, fid) = iprot.readFieldBegin()
11232 
      if ftype == TType.STOP:
11233 
        break
11234 
      if fid == 0:
3064 chandransh 11235 
        if ftype == TType.I64:
11236 
          self.success = iprot.readI64();
921 rajveer 11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      elif fid == 1:
11240 
        if ftype == TType.STRUCT:
11241 
          self.ex = TransactionServiceException()
11242 
          self.ex.read(iprot)
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('createOrder_result')
3431 rajveer 11255 
    if self.success is not None:
3064 chandransh 11256 
      oprot.writeFieldBegin('success', TType.I64, 0)
11257 
      oprot.writeI64(self.success)
921 rajveer 11258 
      oprot.writeFieldEnd()
3431 rajveer 11259 
    if self.ex is not None:
921 rajveer 11260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11261 
      self.ex.write(oprot)
11262 
      oprot.writeFieldEnd()
11263 
    oprot.writeFieldStop()
11264 
    oprot.writeStructEnd()
11265 
 
3431 rajveer 11266 
  def validate(self):
11267 
    return
11268 
 
11269 
 
921 rajveer 11270 
  def __repr__(self):
11271 
    L = ['%s=%r' % (key, value)
11272 
      for key, value in self.__dict__.iteritems()]
11273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11274 
 
11275 
  def __eq__(self, other):
11276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11277 
 
11278 
  def __ne__(self, other):
11279 
    return not (self == other)
11280 
 
3064 chandransh 11281 
class getOrder_args:
921 rajveer 11282 
  """
11283 
  Attributes:
3064 chandransh 11284 
   - id
921 rajveer 11285 
  """
11286 
 
11287 
  thrift_spec = (
11288 
    None, # 0
3064 chandransh 11289 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11290 
  )
11291 
 
3064 chandransh 11292 
  def __init__(self, id=None,):
11293 
    self.id = id
921 rajveer 11294 
 
11295 
  def read(self, iprot):
11296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11298 
      return
11299 
    iprot.readStructBegin()
11300 
    while True:
11301 
      (fname, ftype, fid) = iprot.readFieldBegin()
11302 
      if ftype == TType.STOP:
11303 
        break
11304 
      if fid == 1:
11305 
        if ftype == TType.I64:
3064 chandransh 11306 
          self.id = iprot.readI64();
921 rajveer 11307 
        else:
11308 
          iprot.skip(ftype)
11309 
      else:
11310 
        iprot.skip(ftype)
11311 
      iprot.readFieldEnd()
11312 
    iprot.readStructEnd()
11313 
 
11314 
  def write(self, oprot):
11315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11317 
      return
3064 chandransh 11318 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11319 
    if self.id is not None:
3064 chandransh 11320 
      oprot.writeFieldBegin('id', TType.I64, 1)
11321 
      oprot.writeI64(self.id)
921 rajveer 11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
3431 rajveer 11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
921 rajveer 11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
3064 chandransh 11341 
class getOrder_result:
921 rajveer 11342 
  """
11343 
  Attributes:
11344 
   - success
11345 
   - ex
11346 
  """
11347 
 
11348 
  thrift_spec = (
3064 chandransh 11349 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11351 
  )
11352 
 
11353 
  def __init__(self, success=None, ex=None,):
11354 
    self.success = success
11355 
    self.ex = ex
11356 
 
11357 
  def read(self, iprot):
11358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11360 
      return
11361 
    iprot.readStructBegin()
11362 
    while True:
11363 
      (fname, ftype, fid) = iprot.readFieldBegin()
11364 
      if ftype == TType.STOP:
11365 
        break
11366 
      if fid == 0:
3064 chandransh 11367 
        if ftype == TType.STRUCT:
11368 
          self.success = Order()
11369 
          self.success.read(iprot)
921 rajveer 11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      elif fid == 1:
11373 
        if ftype == TType.STRUCT:
11374 
          self.ex = TransactionServiceException()
11375 
          self.ex.read(iprot)
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('getOrder_result')
3431 rajveer 11388 
    if self.success is not None:
3064 chandransh 11389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11390 
      self.success.write(oprot)
921 rajveer 11391 
      oprot.writeFieldEnd()
3431 rajveer 11392 
    if self.ex is not None:
921 rajveer 11393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11394 
      self.ex.write(oprot)
11395 
      oprot.writeFieldEnd()
11396 
    oprot.writeFieldStop()
11397 
    oprot.writeStructEnd()
11398 
 
3431 rajveer 11399 
  def validate(self):
11400 
    return
11401 
 
11402 
 
921 rajveer 11403 
  def __repr__(self):
11404 
    L = ['%s=%r' % (key, value)
11405 
      for key, value in self.__dict__.iteritems()]
11406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11407 
 
11408 
  def __eq__(self, other):
11409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11410 
 
11411 
  def __ne__(self, other):
11412 
    return not (self == other)
11413 
 
3064 chandransh 11414 
class getLineItemsForOrder_args:
94 ashish 11415 
  """
11416 
  Attributes:
3064 chandransh 11417 
   - orderId
94 ashish 11418 
  """
11419 
 
11420 
  thrift_spec = (
11421 
    None, # 0
3064 chandransh 11422 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11423 
  )
11424 
 
3064 chandransh 11425 
  def __init__(self, orderId=None,):
11426 
    self.orderId = orderId
94 ashish 11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      if fid == 1:
11438 
        if ftype == TType.I64:
3064 chandransh 11439 
          self.orderId = iprot.readI64();
94 ashish 11440 
        else:
11441 
          iprot.skip(ftype)
11442 
      else:
11443 
        iprot.skip(ftype)
11444 
      iprot.readFieldEnd()
11445 
    iprot.readStructEnd()
11446 
 
11447 
  def write(self, oprot):
11448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11450 
      return
3064 chandransh 11451 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11452 
    if self.orderId is not None:
3064 chandransh 11453 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11454 
      oprot.writeI64(self.orderId)
94 ashish 11455 
      oprot.writeFieldEnd()
11456 
    oprot.writeFieldStop()
11457 
    oprot.writeStructEnd()
11458 
 
3431 rajveer 11459 
  def validate(self):
11460 
    return
11461 
 
11462 
 
94 ashish 11463 
  def __repr__(self):
11464 
    L = ['%s=%r' % (key, value)
11465 
      for key, value in self.__dict__.iteritems()]
11466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11467 
 
11468 
  def __eq__(self, other):
11469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11470 
 
11471 
  def __ne__(self, other):
11472 
    return not (self == other)
11473 
 
3064 chandransh 11474 
class getLineItemsForOrder_result:
94 ashish 11475 
  """
11476 
  Attributes:
11477 
   - success
11478 
   - ex
11479 
  """
11480 
 
11481 
  thrift_spec = (
3064 chandransh 11482 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11484 
  )
11485 
 
11486 
  def __init__(self, success=None, ex=None,):
11487 
    self.success = success
11488 
    self.ex = ex
11489 
 
11490 
  def read(self, iprot):
11491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11493 
      return
11494 
    iprot.readStructBegin()
11495 
    while True:
11496 
      (fname, ftype, fid) = iprot.readFieldBegin()
11497 
      if ftype == TType.STOP:
11498 
        break
11499 
      if fid == 0:
483 rajveer 11500 
        if ftype == TType.LIST:
11501 
          self.success = []
6188 rajveer 11502 
          (_etype207, _size204) = iprot.readListBegin()
11503 
          for _i208 in xrange(_size204):
11504 
            _elem209 = LineItem()
11505 
            _elem209.read(iprot)
11506 
            self.success.append(_elem209)
483 rajveer 11507 
          iprot.readListEnd()
94 ashish 11508 
        else:
11509 
          iprot.skip(ftype)
11510 
      elif fid == 1:
11511 
        if ftype == TType.STRUCT:
11512 
          self.ex = TransactionServiceException()
11513 
          self.ex.read(iprot)
11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      else:
11517 
        iprot.skip(ftype)
11518 
      iprot.readFieldEnd()
11519 
    iprot.readStructEnd()
11520 
 
11521 
  def write(self, oprot):
11522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11524 
      return
3064 chandransh 11525 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11526 
    if self.success is not None:
483 rajveer 11527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11529 
      for iter210 in self.success:
11530 
        iter210.write(oprot)
483 rajveer 11531 
      oprot.writeListEnd()
94 ashish 11532 
      oprot.writeFieldEnd()
3431 rajveer 11533 
    if self.ex is not None:
94 ashish 11534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11535 
      self.ex.write(oprot)
11536 
      oprot.writeFieldEnd()
11537 
    oprot.writeFieldStop()
11538 
    oprot.writeStructEnd()
11539 
 
3431 rajveer 11540 
  def validate(self):
11541 
    return
11542 
 
11543 
 
94 ashish 11544 
  def __repr__(self):
11545 
    L = ['%s=%r' % (key, value)
11546 
      for key, value in self.__dict__.iteritems()]
11547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11548 
 
11549 
  def __eq__(self, other):
11550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11551 
 
11552 
  def __ne__(self, other):
11553 
    return not (self == other)
11554 
 
4999 phani.kuma 11555 
class getOrderList_args:
11556 
  """
11557 
  Attributes:
11558 
   - order_ids
11559 
  """
11560 
 
11561 
  thrift_spec = (
11562 
    None, # 0
11563 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11564 
  )
11565 
 
11566 
  def __init__(self, order_ids=None,):
11567 
    self.order_ids = order_ids
11568 
 
11569 
  def read(self, iprot):
11570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11572 
      return
11573 
    iprot.readStructBegin()
11574 
    while True:
11575 
      (fname, ftype, fid) = iprot.readFieldBegin()
11576 
      if ftype == TType.STOP:
11577 
        break
11578 
      if fid == 1:
11579 
        if ftype == TType.LIST:
11580 
          self.order_ids = []
6188 rajveer 11581 
          (_etype214, _size211) = iprot.readListBegin()
11582 
          for _i215 in xrange(_size211):
11583 
            _elem216 = iprot.readI64();
11584 
            self.order_ids.append(_elem216)
4999 phani.kuma 11585 
          iprot.readListEnd()
11586 
        else:
11587 
          iprot.skip(ftype)
11588 
      else:
11589 
        iprot.skip(ftype)
11590 
      iprot.readFieldEnd()
11591 
    iprot.readStructEnd()
11592 
 
11593 
  def write(self, oprot):
11594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11596 
      return
11597 
    oprot.writeStructBegin('getOrderList_args')
11598 
    if self.order_ids is not None:
11599 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11600 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11601 
      for iter217 in self.order_ids:
11602 
        oprot.writeI64(iter217)
4999 phani.kuma 11603 
      oprot.writeListEnd()
11604 
      oprot.writeFieldEnd()
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class getOrderList_result:
11624 
  """
11625 
  Attributes:
11626 
   - success
11627 
  """
11628 
 
11629 
  thrift_spec = (
11630 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11631 
  )
11632 
 
11633 
  def __init__(self, success=None,):
11634 
    self.success = success
11635 
 
11636 
  def read(self, iprot):
11637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11639 
      return
11640 
    iprot.readStructBegin()
11641 
    while True:
11642 
      (fname, ftype, fid) = iprot.readFieldBegin()
11643 
      if ftype == TType.STOP:
11644 
        break
11645 
      if fid == 0:
11646 
        if ftype == TType.LIST:
11647 
          self.success = []
6188 rajveer 11648 
          (_etype221, _size218) = iprot.readListBegin()
11649 
          for _i222 in xrange(_size218):
11650 
            _elem223 = Order()
11651 
            _elem223.read(iprot)
11652 
            self.success.append(_elem223)
4999 phani.kuma 11653 
          iprot.readListEnd()
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      else:
11657 
        iprot.skip(ftype)
11658 
      iprot.readFieldEnd()
11659 
    iprot.readStructEnd()
11660 
 
11661 
  def write(self, oprot):
11662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11664 
      return
11665 
    oprot.writeStructBegin('getOrderList_result')
11666 
    if self.success is not None:
11667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11669 
      for iter224 in self.success:
11670 
        iter224.write(oprot)
4999 phani.kuma 11671 
      oprot.writeListEnd()
11672 
      oprot.writeFieldEnd()
11673 
    oprot.writeFieldStop()
11674 
    oprot.writeStructEnd()
11675 
 
11676 
  def validate(self):
11677 
    return
11678 
 
11679 
 
11680 
  def __repr__(self):
11681 
    L = ['%s=%r' % (key, value)
11682 
      for key, value in self.__dict__.iteritems()]
11683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11684 
 
11685 
  def __eq__(self, other):
11686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11687 
 
11688 
  def __ne__(self, other):
11689 
    return not (self == other)
11690 
 
5386 phani.kuma 11691 
class getOrderListForVendor_args:
11692 
  """
11693 
  Attributes:
11694 
   - order_ids
11695 
   - vendorId
11696 
  """
11697 
 
11698 
  thrift_spec = (
11699 
    None, # 0
11700 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11701 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11702 
  )
11703 
 
11704 
  def __init__(self, order_ids=None, vendorId=None,):
11705 
    self.order_ids = order_ids
11706 
    self.vendorId = vendorId
11707 
 
11708 
  def read(self, iprot):
11709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11711 
      return
11712 
    iprot.readStructBegin()
11713 
    while True:
11714 
      (fname, ftype, fid) = iprot.readFieldBegin()
11715 
      if ftype == TType.STOP:
11716 
        break
11717 
      if fid == 1:
11718 
        if ftype == TType.LIST:
11719 
          self.order_ids = []
6188 rajveer 11720 
          (_etype228, _size225) = iprot.readListBegin()
11721 
          for _i229 in xrange(_size225):
11722 
            _elem230 = iprot.readI64();
11723 
            self.order_ids.append(_elem230)
5386 phani.kuma 11724 
          iprot.readListEnd()
11725 
        else:
11726 
          iprot.skip(ftype)
11727 
      elif fid == 2:
11728 
        if ftype == TType.I64:
11729 
          self.vendorId = iprot.readI64();
11730 
        else:
11731 
          iprot.skip(ftype)
11732 
      else:
11733 
        iprot.skip(ftype)
11734 
      iprot.readFieldEnd()
11735 
    iprot.readStructEnd()
11736 
 
11737 
  def write(self, oprot):
11738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11740 
      return
11741 
    oprot.writeStructBegin('getOrderListForVendor_args')
11742 
    if self.order_ids is not None:
11743 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11744 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11745 
      for iter231 in self.order_ids:
11746 
        oprot.writeI64(iter231)
5386 phani.kuma 11747 
      oprot.writeListEnd()
11748 
      oprot.writeFieldEnd()
11749 
    if self.vendorId is not None:
11750 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11751 
      oprot.writeI64(self.vendorId)
11752 
      oprot.writeFieldEnd()
11753 
    oprot.writeFieldStop()
11754 
    oprot.writeStructEnd()
11755 
 
11756 
  def validate(self):
11757 
    return
11758 
 
11759 
 
11760 
  def __repr__(self):
11761 
    L = ['%s=%r' % (key, value)
11762 
      for key, value in self.__dict__.iteritems()]
11763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11764 
 
11765 
  def __eq__(self, other):
11766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11767 
 
11768 
  def __ne__(self, other):
11769 
    return not (self == other)
11770 
 
11771 
class getOrderListForVendor_result:
11772 
  """
11773 
  Attributes:
11774 
   - success
11775 
  """
11776 
 
11777 
  thrift_spec = (
11778 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11779 
  )
11780 
 
11781 
  def __init__(self, success=None,):
11782 
    self.success = success
11783 
 
11784 
  def read(self, iprot):
11785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11787 
      return
11788 
    iprot.readStructBegin()
11789 
    while True:
11790 
      (fname, ftype, fid) = iprot.readFieldBegin()
11791 
      if ftype == TType.STOP:
11792 
        break
11793 
      if fid == 0:
11794 
        if ftype == TType.LIST:
11795 
          self.success = []
6188 rajveer 11796 
          (_etype235, _size232) = iprot.readListBegin()
11797 
          for _i236 in xrange(_size232):
11798 
            _elem237 = Order()
11799 
            _elem237.read(iprot)
11800 
            self.success.append(_elem237)
5386 phani.kuma 11801 
          iprot.readListEnd()
11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
11813 
    oprot.writeStructBegin('getOrderListForVendor_result')
11814 
    if self.success is not None:
11815 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11816 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11817 
      for iter238 in self.success:
11818 
        iter238.write(oprot)
5386 phani.kuma 11819 
      oprot.writeListEnd()
11820 
      oprot.writeFieldEnd()
11821 
    oprot.writeFieldStop()
11822 
    oprot.writeStructEnd()
11823 
 
11824 
  def validate(self):
11825 
    return
11826 
 
11827 
 
11828 
  def __repr__(self):
11829 
    L = ['%s=%r' % (key, value)
11830 
      for key, value in self.__dict__.iteritems()]
11831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11832 
 
11833 
  def __eq__(self, other):
11834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11835 
 
11836 
  def __ne__(self, other):
11837 
    return not (self == other)
11838 
 
3064 chandransh 11839 
class getOrderForCustomer_args:
94 ashish 11840 
  """
11841 
  Attributes:
3064 chandransh 11842 
   - orderId
483 rajveer 11843 
   - customerId
94 ashish 11844 
  """
11845 
 
11846 
  thrift_spec = (
11847 
    None, # 0
3064 chandransh 11848 
    (1, TType.I64, 'orderId', None, None, ), # 1
11849 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11850 
  )
11851 
 
3064 chandransh 11852 
  def __init__(self, orderId=None, customerId=None,):
11853 
    self.orderId = orderId
483 rajveer 11854 
    self.customerId = customerId
94 ashish 11855 
 
11856 
  def read(self, iprot):
11857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11859 
      return
11860 
    iprot.readStructBegin()
11861 
    while True:
11862 
      (fname, ftype, fid) = iprot.readFieldBegin()
11863 
      if ftype == TType.STOP:
11864 
        break
11865 
      if fid == 1:
11866 
        if ftype == TType.I64:
3064 chandransh 11867 
          self.orderId = iprot.readI64();
94 ashish 11868 
        else:
11869 
          iprot.skip(ftype)
11870 
      elif fid == 2:
11871 
        if ftype == TType.I64:
3064 chandransh 11872 
          self.customerId = iprot.readI64();
94 ashish 11873 
        else:
11874 
          iprot.skip(ftype)
11875 
      else:
11876 
        iprot.skip(ftype)
11877 
      iprot.readFieldEnd()
11878 
    iprot.readStructEnd()
11879 
 
11880 
  def write(self, oprot):
11881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11883 
      return
3064 chandransh 11884 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11885 
    if self.orderId is not None:
3064 chandransh 11886 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11887 
      oprot.writeI64(self.orderId)
11888 
      oprot.writeFieldEnd()
3431 rajveer 11889 
    if self.customerId is not None:
3064 chandransh 11890 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11891 
      oprot.writeI64(self.customerId)
94 ashish 11892 
      oprot.writeFieldEnd()
11893 
    oprot.writeFieldStop()
11894 
    oprot.writeStructEnd()
11895 
 
3431 rajveer 11896 
  def validate(self):
11897 
    return
11898 
 
11899 
 
94 ashish 11900 
  def __repr__(self):
11901 
    L = ['%s=%r' % (key, value)
11902 
      for key, value in self.__dict__.iteritems()]
11903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11904 
 
11905 
  def __eq__(self, other):
11906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11907 
 
11908 
  def __ne__(self, other):
11909 
    return not (self == other)
11910 
 
3064 chandransh 11911 
class getOrderForCustomer_result:
94 ashish 11912 
  """
11913 
  Attributes:
11914 
   - success
11915 
   - ex
11916 
  """
11917 
 
11918 
  thrift_spec = (
3064 chandransh 11919 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11920 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11921 
  )
11922 
 
11923 
  def __init__(self, success=None, ex=None,):
11924 
    self.success = success
11925 
    self.ex = ex
11926 
 
11927 
  def read(self, iprot):
11928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11930 
      return
11931 
    iprot.readStructBegin()
11932 
    while True:
11933 
      (fname, ftype, fid) = iprot.readFieldBegin()
11934 
      if ftype == TType.STOP:
11935 
        break
11936 
      if fid == 0:
3064 chandransh 11937 
        if ftype == TType.STRUCT:
11938 
          self.success = Order()
11939 
          self.success.read(iprot)
94 ashish 11940 
        else:
11941 
          iprot.skip(ftype)
11942 
      elif fid == 1:
11943 
        if ftype == TType.STRUCT:
11944 
          self.ex = TransactionServiceException()
11945 
          self.ex.read(iprot)
11946 
        else:
11947 
          iprot.skip(ftype)
11948 
      else:
11949 
        iprot.skip(ftype)
11950 
      iprot.readFieldEnd()
11951 
    iprot.readStructEnd()
11952 
 
11953 
  def write(self, oprot):
11954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11956 
      return
3064 chandransh 11957 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11958 
    if self.success is not None:
3064 chandransh 11959 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11960 
      self.success.write(oprot)
94 ashish 11961 
      oprot.writeFieldEnd()
3431 rajveer 11962 
    if self.ex is not None:
94 ashish 11963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11964 
      self.ex.write(oprot)
11965 
      oprot.writeFieldEnd()
11966 
    oprot.writeFieldStop()
11967 
    oprot.writeStructEnd()
11968 
 
3431 rajveer 11969 
  def validate(self):
11970 
    return
11971 
 
11972 
 
94 ashish 11973 
  def __repr__(self):
11974 
    L = ['%s=%r' % (key, value)
11975 
      for key, value in self.__dict__.iteritems()]
11976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11977 
 
11978 
  def __eq__(self, other):
11979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11980 
 
11981 
  def __ne__(self, other):
11982 
    return not (self == other)
11983 
 
3064 chandransh 11984 
class getAlerts_args:
94 ashish 11985 
  """
11986 
  Attributes:
4394 rajveer 11987 
   - type
4444 rajveer 11988 
   - warehouseId
4394 rajveer 11989 
   - status
11990 
   - timestamp
94 ashish 11991 
  """
11992 
 
11993 
  thrift_spec = (
11994 
    None, # 0
4394 rajveer 11995 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11996 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11997 
    (3, TType.I64, 'status', None, None, ), # 3
11998 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11999 
  )
12000 
 
4444 rajveer 12001 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12002 
    self.type = type
4444 rajveer 12003 
    self.warehouseId = warehouseId
4394 rajveer 12004 
    self.status = status
12005 
    self.timestamp = timestamp
94 ashish 12006 
 
12007 
  def read(self, iprot):
12008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12010 
      return
12011 
    iprot.readStructBegin()
12012 
    while True:
12013 
      (fname, ftype, fid) = iprot.readFieldBegin()
12014 
      if ftype == TType.STOP:
12015 
        break
12016 
      if fid == 1:
3064 chandransh 12017 
        if ftype == TType.I64:
4394 rajveer 12018 
          self.type = iprot.readI64();
94 ashish 12019 
        else:
12020 
          iprot.skip(ftype)
3064 chandransh 12021 
      elif fid == 2:
4394 rajveer 12022 
        if ftype == TType.I64:
4444 rajveer 12023 
          self.warehouseId = iprot.readI64();
3064 chandransh 12024 
        else:
12025 
          iprot.skip(ftype)
4394 rajveer 12026 
      elif fid == 3:
12027 
        if ftype == TType.I64:
4444 rajveer 12028 
          self.status = iprot.readI64();
12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      elif fid == 4:
12032 
        if ftype == TType.I64:
4394 rajveer 12033 
          self.timestamp = iprot.readI64();
12034 
        else:
12035 
          iprot.skip(ftype)
94 ashish 12036 
      else:
12037 
        iprot.skip(ftype)
12038 
      iprot.readFieldEnd()
12039 
    iprot.readStructEnd()
12040 
 
12041 
  def write(self, oprot):
12042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12044 
      return
3064 chandransh 12045 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12046 
    if self.type is not None:
12047 
      oprot.writeFieldBegin('type', TType.I64, 1)
12048 
      oprot.writeI64(self.type)
94 ashish 12049 
      oprot.writeFieldEnd()
4444 rajveer 12050 
    if self.warehouseId is not None:
12051 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12052 
      oprot.writeI64(self.warehouseId)
12053 
      oprot.writeFieldEnd()
4394 rajveer 12054 
    if self.status is not None:
4444 rajveer 12055 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12056 
      oprot.writeI64(self.status)
3064 chandransh 12057 
      oprot.writeFieldEnd()
4394 rajveer 12058 
    if self.timestamp is not None:
4444 rajveer 12059 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12060 
      oprot.writeI64(self.timestamp)
12061 
      oprot.writeFieldEnd()
94 ashish 12062 
    oprot.writeFieldStop()
12063 
    oprot.writeStructEnd()
12064 
 
3431 rajveer 12065 
  def validate(self):
12066 
    return
12067 
 
12068 
 
94 ashish 12069 
  def __repr__(self):
12070 
    L = ['%s=%r' % (key, value)
12071 
      for key, value in self.__dict__.iteritems()]
12072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12073 
 
12074 
  def __eq__(self, other):
12075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12076 
 
12077 
  def __ne__(self, other):
12078 
    return not (self == other)
12079 
 
3064 chandransh 12080 
class getAlerts_result:
94 ashish 12081 
  """
12082 
  Attributes:
12083 
   - success
12084 
  """
12085 
 
12086 
  thrift_spec = (
3064 chandransh 12087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12088 
  )
12089 
 
3064 chandransh 12090 
  def __init__(self, success=None,):
94 ashish 12091 
    self.success = success
12092 
 
12093 
  def read(self, iprot):
12094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12096 
      return
12097 
    iprot.readStructBegin()
12098 
    while True:
12099 
      (fname, ftype, fid) = iprot.readFieldBegin()
12100 
      if ftype == TType.STOP:
12101 
        break
12102 
      if fid == 0:
3064 chandransh 12103 
        if ftype == TType.LIST:
12104 
          self.success = []
6188 rajveer 12105 
          (_etype242, _size239) = iprot.readListBegin()
12106 
          for _i243 in xrange(_size239):
12107 
            _elem244 = Alert()
12108 
            _elem244.read(iprot)
12109 
            self.success.append(_elem244)
3064 chandransh 12110 
          iprot.readListEnd()
94 ashish 12111 
        else:
12112 
          iprot.skip(ftype)
12113 
      else:
12114 
        iprot.skip(ftype)
12115 
      iprot.readFieldEnd()
12116 
    iprot.readStructEnd()
12117 
 
12118 
  def write(self, oprot):
12119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12121 
      return
3064 chandransh 12122 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12123 
    if self.success is not None:
3064 chandransh 12124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12126 
      for iter245 in self.success:
12127 
        iter245.write(oprot)
3064 chandransh 12128 
      oprot.writeListEnd()
94 ashish 12129 
      oprot.writeFieldEnd()
12130 
    oprot.writeFieldStop()
12131 
    oprot.writeStructEnd()
12132 
 
3431 rajveer 12133 
  def validate(self):
12134 
    return
12135 
 
12136 
 
94 ashish 12137 
  def __repr__(self):
12138 
    L = ['%s=%r' % (key, value)
12139 
      for key, value in self.__dict__.iteritems()]
12140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12141 
 
12142 
  def __eq__(self, other):
12143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12144 
 
12145 
  def __ne__(self, other):
12146 
    return not (self == other)
12147 
 
4394 rajveer 12148 
class addAlert_args:
94 ashish 12149 
  """
12150 
  Attributes:
3064 chandransh 12151 
   - type
4444 rajveer 12152 
   - warehouseId
4394 rajveer 12153 
   - description
94 ashish 12154 
  """
12155 
 
12156 
  thrift_spec = (
12157 
    None, # 0
4394 rajveer 12158 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12159 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12160 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12161 
  )
12162 
 
4444 rajveer 12163 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12164 
    self.type = type
4444 rajveer 12165 
    self.warehouseId = warehouseId
4394 rajveer 12166 
    self.description = description
94 ashish 12167 
 
12168 
  def read(self, iprot):
12169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12171 
      return
12172 
    iprot.readStructBegin()
12173 
    while True:
12174 
      (fname, ftype, fid) = iprot.readFieldBegin()
12175 
      if ftype == TType.STOP:
12176 
        break
12177 
      if fid == 1:
12178 
        if ftype == TType.I64:
4394 rajveer 12179 
          self.type = iprot.readI64();
94 ashish 12180 
        else:
12181 
          iprot.skip(ftype)
3064 chandransh 12182 
      elif fid == 2:
4444 rajveer 12183 
        if ftype == TType.I64:
12184 
          self.warehouseId = iprot.readI64();
12185 
        else:
12186 
          iprot.skip(ftype)
12187 
      elif fid == 3:
3064 chandransh 12188 
        if ftype == TType.STRING:
4394 rajveer 12189 
          self.description = iprot.readString();
3064 chandransh 12190 
        else:
12191 
          iprot.skip(ftype)
94 ashish 12192 
      else:
12193 
        iprot.skip(ftype)
12194 
      iprot.readFieldEnd()
12195 
    iprot.readStructEnd()
12196 
 
12197 
  def write(self, oprot):
12198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12200 
      return
4394 rajveer 12201 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12202 
    if self.type is not None:
4394 rajveer 12203 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12204 
      oprot.writeI64(self.type)
12205 
      oprot.writeFieldEnd()
4444 rajveer 12206 
    if self.warehouseId is not None:
12207 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12208 
      oprot.writeI64(self.warehouseId)
12209 
      oprot.writeFieldEnd()
4394 rajveer 12210 
    if self.description is not None:
4444 rajveer 12211 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12212 
      oprot.writeString(self.description)
3064 chandransh 12213 
      oprot.writeFieldEnd()
94 ashish 12214 
    oprot.writeFieldStop()
12215 
    oprot.writeStructEnd()
12216 
 
3431 rajveer 12217 
  def validate(self):
12218 
    return
12219 
 
12220 
 
94 ashish 12221 
  def __repr__(self):
12222 
    L = ['%s=%r' % (key, value)
12223 
      for key, value in self.__dict__.iteritems()]
12224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12225 
 
12226 
  def __eq__(self, other):
12227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12228 
 
12229 
  def __ne__(self, other):
12230 
    return not (self == other)
12231 
 
4394 rajveer 12232 
class addAlert_result:
3064 chandransh 12233 
 
12234 
  thrift_spec = (
12235 
  )
12236 
 
12237 
  def read(self, iprot):
12238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12240 
      return
12241 
    iprot.readStructBegin()
12242 
    while True:
12243 
      (fname, ftype, fid) = iprot.readFieldBegin()
12244 
      if ftype == TType.STOP:
12245 
        break
12246 
      else:
12247 
        iprot.skip(ftype)
12248 
      iprot.readFieldEnd()
12249 
    iprot.readStructEnd()
12250 
 
12251 
  def write(self, oprot):
12252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12254 
      return
4394 rajveer 12255 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12256 
    oprot.writeFieldStop()
12257 
    oprot.writeStructEnd()
12258 
 
3431 rajveer 12259 
  def validate(self):
12260 
    return
12261 
 
12262 
 
3064 chandransh 12263 
  def __repr__(self):
12264 
    L = ['%s=%r' % (key, value)
12265 
      for key, value in self.__dict__.iteritems()]
12266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12267 
 
12268 
  def __eq__(self, other):
12269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12270 
 
12271 
  def __ne__(self, other):
12272 
    return not (self == other)
12273 
 
4444 rajveer 12274 
class markAlertsAsSeen_args:
12275 
  """
12276 
  Attributes:
12277 
   - warehouseId
12278 
  """
12279 
 
12280 
  thrift_spec = (
12281 
    None, # 0
12282 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12283 
  )
12284 
 
12285 
  def __init__(self, warehouseId=None,):
12286 
    self.warehouseId = warehouseId
12287 
 
12288 
  def read(self, iprot):
12289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12291 
      return
12292 
    iprot.readStructBegin()
12293 
    while True:
12294 
      (fname, ftype, fid) = iprot.readFieldBegin()
12295 
      if ftype == TType.STOP:
12296 
        break
12297 
      if fid == 1:
12298 
        if ftype == TType.I64:
12299 
          self.warehouseId = iprot.readI64();
12300 
        else:
12301 
          iprot.skip(ftype)
12302 
      else:
12303 
        iprot.skip(ftype)
12304 
      iprot.readFieldEnd()
12305 
    iprot.readStructEnd()
12306 
 
12307 
  def write(self, oprot):
12308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12310 
      return
12311 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12312 
    if self.warehouseId is not None:
12313 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12314 
      oprot.writeI64(self.warehouseId)
12315 
      oprot.writeFieldEnd()
12316 
    oprot.writeFieldStop()
12317 
    oprot.writeStructEnd()
12318 
 
12319 
  def validate(self):
12320 
    return
12321 
 
12322 
 
12323 
  def __repr__(self):
12324 
    L = ['%s=%r' % (key, value)
12325 
      for key, value in self.__dict__.iteritems()]
12326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12327 
 
12328 
  def __eq__(self, other):
12329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12330 
 
12331 
  def __ne__(self, other):
12332 
    return not (self == other)
12333 
 
12334 
class markAlertsAsSeen_result:
12335 
 
12336 
  thrift_spec = (
12337 
  )
12338 
 
12339 
  def read(self, iprot):
12340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12342 
      return
12343 
    iprot.readStructBegin()
12344 
    while True:
12345 
      (fname, ftype, fid) = iprot.readFieldBegin()
12346 
      if ftype == TType.STOP:
12347 
        break
12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
12357 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12358 
    oprot.writeFieldStop()
12359 
    oprot.writeStructEnd()
12360 
 
12361 
  def validate(self):
12362 
    return
12363 
 
12364 
 
12365 
  def __repr__(self):
12366 
    L = ['%s=%r' % (key, value)
12367 
      for key, value in self.__dict__.iteritems()]
12368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12369 
 
12370 
  def __eq__(self, other):
12371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12372 
 
12373 
  def __ne__(self, other):
12374 
    return not (self == other)
12375 
 
3064 chandransh 12376 
class getValidOrderCount_args:
12377 
 
12378 
  thrift_spec = (
12379 
  )
12380 
 
12381 
  def read(self, iprot):
12382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12384 
      return
12385 
    iprot.readStructBegin()
12386 
    while True:
12387 
      (fname, ftype, fid) = iprot.readFieldBegin()
12388 
      if ftype == TType.STOP:
12389 
        break
12390 
      else:
12391 
        iprot.skip(ftype)
12392 
      iprot.readFieldEnd()
12393 
    iprot.readStructEnd()
12394 
 
12395 
  def write(self, oprot):
12396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12398 
      return
12399 
    oprot.writeStructBegin('getValidOrderCount_args')
12400 
    oprot.writeFieldStop()
12401 
    oprot.writeStructEnd()
12402 
 
3431 rajveer 12403 
  def validate(self):
12404 
    return
12405 
 
12406 
 
3064 chandransh 12407 
  def __repr__(self):
12408 
    L = ['%s=%r' % (key, value)
12409 
      for key, value in self.__dict__.iteritems()]
12410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12411 
 
12412 
  def __eq__(self, other):
12413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12414 
 
12415 
  def __ne__(self, other):
12416 
    return not (self == other)
12417 
 
12418 
class getValidOrderCount_result:
94 ashish 12419 
  """
12420 
  Attributes:
12421 
   - success
12422 
  """
12423 
 
12424 
  thrift_spec = (
3064 chandransh 12425 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12426 
  )
12427 
 
3064 chandransh 12428 
  def __init__(self, success=None,):
94 ashish 12429 
    self.success = success
12430 
 
12431 
  def read(self, iprot):
12432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12434 
      return
12435 
    iprot.readStructBegin()
12436 
    while True:
12437 
      (fname, ftype, fid) = iprot.readFieldBegin()
12438 
      if ftype == TType.STOP:
12439 
        break
12440 
      if fid == 0:
3064 chandransh 12441 
        if ftype == TType.I64:
12442 
          self.success = iprot.readI64();
94 ashish 12443 
        else:
12444 
          iprot.skip(ftype)
12445 
      else:
12446 
        iprot.skip(ftype)
12447 
      iprot.readFieldEnd()
12448 
    iprot.readStructEnd()
12449 
 
12450 
  def write(self, oprot):
12451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12453 
      return
3064 chandransh 12454 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12455 
    if self.success is not None:
3064 chandransh 12456 
      oprot.writeFieldBegin('success', TType.I64, 0)
12457 
      oprot.writeI64(self.success)
94 ashish 12458 
      oprot.writeFieldEnd()
12459 
    oprot.writeFieldStop()
12460 
    oprot.writeStructEnd()
12461 
 
3431 rajveer 12462 
  def validate(self):
12463 
    return
12464 
 
12465 
 
94 ashish 12466 
  def __repr__(self):
12467 
    L = ['%s=%r' % (key, value)
12468 
      for key, value in self.__dict__.iteritems()]
12469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12470 
 
12471 
  def __eq__(self, other):
12472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12473 
 
12474 
  def __ne__(self, other):
12475 
    return not (self == other)
12476 
 
3064 chandransh 12477 
class getNoOfCustomersWithSuccessfulTransaction_args:
12478 
 
12479 
  thrift_spec = (
12480 
  )
12481 
 
12482 
  def read(self, iprot):
12483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12485 
      return
12486 
    iprot.readStructBegin()
12487 
    while True:
12488 
      (fname, ftype, fid) = iprot.readFieldBegin()
12489 
      if ftype == TType.STOP:
12490 
        break
12491 
      else:
12492 
        iprot.skip(ftype)
12493 
      iprot.readFieldEnd()
12494 
    iprot.readStructEnd()
12495 
 
12496 
  def write(self, oprot):
12497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12499 
      return
12500 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12501 
    oprot.writeFieldStop()
12502 
    oprot.writeStructEnd()
12503 
 
3431 rajveer 12504 
  def validate(self):
12505 
    return
12506 
 
12507 
 
3064 chandransh 12508 
  def __repr__(self):
12509 
    L = ['%s=%r' % (key, value)
12510 
      for key, value in self.__dict__.iteritems()]
12511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12512 
 
12513 
  def __eq__(self, other):
12514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12515 
 
12516 
  def __ne__(self, other):
12517 
    return not (self == other)
12518 
 
12519 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12520 
  """
12521 
  Attributes:
3064 chandransh 12522 
   - success
94 ashish 12523 
  """
12524 
 
12525 
  thrift_spec = (
3064 chandransh 12526 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12527 
  )
12528 
 
3064 chandransh 12529 
  def __init__(self, success=None,):
12530 
    self.success = success
94 ashish 12531 
 
12532 
  def read(self, iprot):
12533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12535 
      return
12536 
    iprot.readStructBegin()
12537 
    while True:
12538 
      (fname, ftype, fid) = iprot.readFieldBegin()
12539 
      if ftype == TType.STOP:
12540 
        break
3064 chandransh 12541 
      if fid == 0:
94 ashish 12542 
        if ftype == TType.I64:
3064 chandransh 12543 
          self.success = iprot.readI64();
94 ashish 12544 
        else:
12545 
          iprot.skip(ftype)
12546 
      else:
12547 
        iprot.skip(ftype)
12548 
      iprot.readFieldEnd()
12549 
    iprot.readStructEnd()
12550 
 
12551 
  def write(self, oprot):
12552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12554 
      return
3064 chandransh 12555 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12556 
    if self.success is not None:
3064 chandransh 12557 
      oprot.writeFieldBegin('success', TType.I64, 0)
12558 
      oprot.writeI64(self.success)
94 ashish 12559 
      oprot.writeFieldEnd()
12560 
    oprot.writeFieldStop()
12561 
    oprot.writeStructEnd()
12562 
 
3431 rajveer 12563 
  def validate(self):
12564 
    return
12565 
 
12566 
 
94 ashish 12567 
  def __repr__(self):
12568 
    L = ['%s=%r' % (key, value)
12569 
      for key, value in self.__dict__.iteritems()]
12570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12571 
 
12572 
  def __eq__(self, other):
12573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12574 
 
12575 
  def __ne__(self, other):
12576 
    return not (self == other)
12577 
 
3064 chandransh 12578 
class getValidOrdersAmountRange_args:
12579 
 
12580 
  thrift_spec = (
12581 
  )
12582 
 
12583 
  def read(self, iprot):
12584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12586 
      return
12587 
    iprot.readStructBegin()
12588 
    while True:
12589 
      (fname, ftype, fid) = iprot.readFieldBegin()
12590 
      if ftype == TType.STOP:
12591 
        break
12592 
      else:
12593 
        iprot.skip(ftype)
12594 
      iprot.readFieldEnd()
12595 
    iprot.readStructEnd()
12596 
 
12597 
  def write(self, oprot):
12598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12600 
      return
12601 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12602 
    oprot.writeFieldStop()
12603 
    oprot.writeStructEnd()
12604 
 
3431 rajveer 12605 
  def validate(self):
12606 
    return
12607 
 
12608 
 
3064 chandransh 12609 
  def __repr__(self):
12610 
    L = ['%s=%r' % (key, value)
12611 
      for key, value in self.__dict__.iteritems()]
12612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12613 
 
12614 
  def __eq__(self, other):
12615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12616 
 
12617 
  def __ne__(self, other):
12618 
    return not (self == other)
12619 
 
12620 
class getValidOrdersAmountRange_result:
94 ashish 12621 
  """
12622 
  Attributes:
12623 
   - success
12624 
  """
12625 
 
12626 
  thrift_spec = (
3064 chandransh 12627 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12628 
  )
12629 
 
3064 chandransh 12630 
  def __init__(self, success=None,):
94 ashish 12631 
    self.success = success
12632 
 
12633 
  def read(self, iprot):
12634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12636 
      return
12637 
    iprot.readStructBegin()
12638 
    while True:
12639 
      (fname, ftype, fid) = iprot.readFieldBegin()
12640 
      if ftype == TType.STOP:
12641 
        break
12642 
      if fid == 0:
483 rajveer 12643 
        if ftype == TType.LIST:
12644 
          self.success = []
6188 rajveer 12645 
          (_etype249, _size246) = iprot.readListBegin()
12646 
          for _i250 in xrange(_size246):
12647 
            _elem251 = iprot.readDouble();
12648 
            self.success.append(_elem251)
483 rajveer 12649 
          iprot.readListEnd()
94 ashish 12650 
        else:
12651 
          iprot.skip(ftype)
12652 
      else:
12653 
        iprot.skip(ftype)
12654 
      iprot.readFieldEnd()
12655 
    iprot.readStructEnd()
12656 
 
12657 
  def write(self, oprot):
12658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12660 
      return
3064 chandransh 12661 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12662 
    if self.success is not None:
483 rajveer 12663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12664 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12665 
      for iter252 in self.success:
12666 
        oprot.writeDouble(iter252)
483 rajveer 12667 
      oprot.writeListEnd()
94 ashish 12668 
      oprot.writeFieldEnd()
12669 
    oprot.writeFieldStop()
12670 
    oprot.writeStructEnd()
12671 
 
3431 rajveer 12672 
  def validate(self):
12673 
    return
12674 
 
12675 
 
94 ashish 12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12686 
 
3064 chandransh 12687 
class getValidOrders_args:
1528 ankur.sing 12688 
  """
12689 
  Attributes:
3064 chandransh 12690 
   - limit
5874 rajveer 12691 
   - onlyStore
1528 ankur.sing 12692 
  """
12693 
 
12694 
  thrift_spec = (
12695 
    None, # 0
3064 chandransh 12696 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12697 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12698 
  )
12699 
 
5874 rajveer 12700 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12701 
    self.limit = limit
5874 rajveer 12702 
    self.onlyStore = onlyStore
1528 ankur.sing 12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      if fid == 1:
12714 
        if ftype == TType.I64:
3064 chandransh 12715 
          self.limit = iprot.readI64();
1528 ankur.sing 12716 
        else:
12717 
          iprot.skip(ftype)
5874 rajveer 12718 
      elif fid == 2:
12719 
        if ftype == TType.BOOL:
12720 
          self.onlyStore = iprot.readBool();
12721 
        else:
12722 
          iprot.skip(ftype)
1528 ankur.sing 12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
3064 chandransh 12732 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12733 
    if self.limit is not None:
3064 chandransh 12734 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12735 
      oprot.writeI64(self.limit)
1528 ankur.sing 12736 
      oprot.writeFieldEnd()
5874 rajveer 12737 
    if self.onlyStore is not None:
12738 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12739 
      oprot.writeBool(self.onlyStore)
12740 
      oprot.writeFieldEnd()
1528 ankur.sing 12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
3431 rajveer 12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
1528 ankur.sing 12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
3064 chandransh 12759 
class getValidOrders_result:
1528 ankur.sing 12760 
  """
12761 
  Attributes:
12762 
   - success
12763 
  """
12764 
 
12765 
  thrift_spec = (
3064 chandransh 12766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12767 
  )
12768 
 
3064 chandransh 12769 
  def __init__(self, success=None,):
1528 ankur.sing 12770 
    self.success = success
12771 
 
12772 
  def read(self, iprot):
12773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12775 
      return
12776 
    iprot.readStructBegin()
12777 
    while True:
12778 
      (fname, ftype, fid) = iprot.readFieldBegin()
12779 
      if ftype == TType.STOP:
12780 
        break
12781 
      if fid == 0:
3064 chandransh 12782 
        if ftype == TType.LIST:
12783 
          self.success = []
6188 rajveer 12784 
          (_etype256, _size253) = iprot.readListBegin()
12785 
          for _i257 in xrange(_size253):
12786 
            _elem258 = Order()
12787 
            _elem258.read(iprot)
12788 
            self.success.append(_elem258)
3064 chandransh 12789 
          iprot.readListEnd()
1528 ankur.sing 12790 
        else:
12791 
          iprot.skip(ftype)
12792 
      else:
12793 
        iprot.skip(ftype)
12794 
      iprot.readFieldEnd()
12795 
    iprot.readStructEnd()
12796 
 
12797 
  def write(self, oprot):
12798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12800 
      return
3064 chandransh 12801 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12802 
    if self.success is not None:
3064 chandransh 12803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12805 
      for iter259 in self.success:
12806 
        iter259.write(oprot)
3064 chandransh 12807 
      oprot.writeListEnd()
1528 ankur.sing 12808 
      oprot.writeFieldEnd()
12809 
    oprot.writeFieldStop()
12810 
    oprot.writeStructEnd()
12811 
 
3431 rajveer 12812 
  def validate(self):
12813 
    return
12814 
 
12815 
 
1528 ankur.sing 12816 
  def __repr__(self):
12817 
    L = ['%s=%r' % (key, value)
12818 
      for key, value in self.__dict__.iteritems()]
12819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12820 
 
12821 
  def __eq__(self, other):
12822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12823 
 
12824 
  def __ne__(self, other):
12825 
    return not (self == other)
12826 
 
1220 chandransh 12827 
class batchOrders_args:
12828 
  """
12829 
  Attributes:
12830 
   - warehouseId
12831 
  """
12832 
 
12833 
  thrift_spec = (
12834 
    None, # 0
12835 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12836 
  )
12837 
 
12838 
  def __init__(self, warehouseId=None,):
12839 
    self.warehouseId = warehouseId
12840 
 
12841 
  def read(self, iprot):
12842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12844 
      return
12845 
    iprot.readStructBegin()
12846 
    while True:
12847 
      (fname, ftype, fid) = iprot.readFieldBegin()
12848 
      if ftype == TType.STOP:
12849 
        break
12850 
      if fid == 1:
12851 
        if ftype == TType.I64:
12852 
          self.warehouseId = iprot.readI64();
12853 
        else:
12854 
          iprot.skip(ftype)
12855 
      else:
12856 
        iprot.skip(ftype)
12857 
      iprot.readFieldEnd()
12858 
    iprot.readStructEnd()
12859 
 
12860 
  def write(self, oprot):
12861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12863 
      return
12864 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12865 
    if self.warehouseId is not None:
1220 chandransh 12866 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12867 
      oprot.writeI64(self.warehouseId)
12868 
      oprot.writeFieldEnd()
12869 
    oprot.writeFieldStop()
12870 
    oprot.writeStructEnd()
12871 
 
3431 rajveer 12872 
  def validate(self):
12873 
    return
12874 
 
12875 
 
1220 chandransh 12876 
  def __repr__(self):
12877 
    L = ['%s=%r' % (key, value)
12878 
      for key, value in self.__dict__.iteritems()]
12879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12880 
 
12881 
  def __eq__(self, other):
12882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12883 
 
12884 
  def __ne__(self, other):
12885 
    return not (self == other)
12886 
 
12887 
class batchOrders_result:
12888 
  """
12889 
  Attributes:
12890 
   - success
12891 
   - ex
12892 
  """
12893 
 
12894 
  thrift_spec = (
12895 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12897 
  )
12898 
 
12899 
  def __init__(self, success=None, ex=None,):
12900 
    self.success = success
12901 
    self.ex = ex
12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == 0:
12913 
        if ftype == TType.LIST:
12914 
          self.success = []
6188 rajveer 12915 
          (_etype263, _size260) = iprot.readListBegin()
12916 
          for _i264 in xrange(_size260):
12917 
            _elem265 = Order()
12918 
            _elem265.read(iprot)
12919 
            self.success.append(_elem265)
1220 chandransh 12920 
          iprot.readListEnd()
12921 
        else:
12922 
          iprot.skip(ftype)
12923 
      elif fid == 1:
12924 
        if ftype == TType.STRUCT:
12925 
          self.ex = TransactionServiceException()
12926 
          self.ex.read(iprot)
12927 
        else:
12928 
          iprot.skip(ftype)
12929 
      else:
12930 
        iprot.skip(ftype)
12931 
      iprot.readFieldEnd()
12932 
    iprot.readStructEnd()
12933 
 
12934 
  def write(self, oprot):
12935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12937 
      return
12938 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12939 
    if self.success is not None:
1220 chandransh 12940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12941 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12942 
      for iter266 in self.success:
12943 
        iter266.write(oprot)
1220 chandransh 12944 
      oprot.writeListEnd()
12945 
      oprot.writeFieldEnd()
3431 rajveer 12946 
    if self.ex is not None:
1220 chandransh 12947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12948 
      self.ex.write(oprot)
12949 
      oprot.writeFieldEnd()
12950 
    oprot.writeFieldStop()
12951 
    oprot.writeStructEnd()
12952 
 
3431 rajveer 12953 
  def validate(self):
12954 
    return
12955 
 
12956 
 
1220 chandransh 12957 
  def __repr__(self):
12958 
    L = ['%s=%r' % (key, value)
12959 
      for key, value in self.__dict__.iteritems()]
12960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12961 
 
12962 
  def __eq__(self, other):
12963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12964 
 
12965 
  def __ne__(self, other):
12966 
    return not (self == other)
12967 
 
1208 chandransh 12968 
class markOrderAsOutOfStock_args:
12969 
  """
12970 
  Attributes:
12971 
   - orderId
12972 
  """
12973 
 
12974 
  thrift_spec = (
12975 
    None, # 0
12976 
    (1, TType.I64, 'orderId', None, None, ), # 1
12977 
  )
12978 
 
12979 
  def __init__(self, orderId=None,):
12980 
    self.orderId = orderId
12981 
 
12982 
  def read(self, iprot):
12983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12985 
      return
12986 
    iprot.readStructBegin()
12987 
    while True:
12988 
      (fname, ftype, fid) = iprot.readFieldBegin()
12989 
      if ftype == TType.STOP:
12990 
        break
12991 
      if fid == 1:
12992 
        if ftype == TType.I64:
12993 
          self.orderId = iprot.readI64();
12994 
        else:
12995 
          iprot.skip(ftype)
12996 
      else:
12997 
        iprot.skip(ftype)
12998 
      iprot.readFieldEnd()
12999 
    iprot.readStructEnd()
13000 
 
13001 
  def write(self, oprot):
13002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13004 
      return
13005 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13006 
    if self.orderId is not None:
1208 chandransh 13007 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13008 
      oprot.writeI64(self.orderId)
13009 
      oprot.writeFieldEnd()
13010 
    oprot.writeFieldStop()
13011 
    oprot.writeStructEnd()
13012 
 
3431 rajveer 13013 
  def validate(self):
13014 
    return
13015 
 
13016 
 
1208 chandransh 13017 
  def __repr__(self):
13018 
    L = ['%s=%r' % (key, value)
13019 
      for key, value in self.__dict__.iteritems()]
13020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13021 
 
13022 
  def __eq__(self, other):
13023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13024 
 
13025 
  def __ne__(self, other):
13026 
    return not (self == other)
13027 
 
13028 
class markOrderAsOutOfStock_result:
13029 
  """
13030 
  Attributes:
13031 
   - success
13032 
   - ex
13033 
  """
13034 
 
13035 
  thrift_spec = (
13036 
    (0, TType.BOOL, 'success', None, None, ), # 0
13037 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13038 
  )
13039 
 
13040 
  def __init__(self, success=None, ex=None,):
13041 
    self.success = success
13042 
    self.ex = ex
13043 
 
13044 
  def read(self, iprot):
13045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13047 
      return
13048 
    iprot.readStructBegin()
13049 
    while True:
13050 
      (fname, ftype, fid) = iprot.readFieldBegin()
13051 
      if ftype == TType.STOP:
13052 
        break
13053 
      if fid == 0:
13054 
        if ftype == TType.BOOL:
13055 
          self.success = iprot.readBool();
13056 
        else:
13057 
          iprot.skip(ftype)
13058 
      elif fid == 1:
13059 
        if ftype == TType.STRUCT:
13060 
          self.ex = TransactionServiceException()
13061 
          self.ex.read(iprot)
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
13073 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13074 
    if self.success is not None:
1208 chandransh 13075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13076 
      oprot.writeBool(self.success)
13077 
      oprot.writeFieldEnd()
3431 rajveer 13078 
    if self.ex is not None:
1208 chandransh 13079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13080 
      self.ex.write(oprot)
13081 
      oprot.writeFieldEnd()
13082 
    oprot.writeFieldStop()
13083 
    oprot.writeStructEnd()
13084 
 
3431 rajveer 13085 
  def validate(self):
13086 
    return
13087 
 
13088 
 
1208 chandransh 13089 
  def __repr__(self):
13090 
    L = ['%s=%r' % (key, value)
13091 
      for key, value in self.__dict__.iteritems()]
13092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13093 
 
13094 
  def __eq__(self, other):
13095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13096 
 
13097 
  def __ne__(self, other):
13098 
    return not (self == other)
13099 
 
3064 chandransh 13100 
class verifyOrder_args:
759 chandransh 13101 
  """
13102 
  Attributes:
3064 chandransh 13103 
   - orderId
759 chandransh 13104 
  """
13105 
 
13106 
  thrift_spec = (
13107 
    None, # 0
3064 chandransh 13108 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13109 
  )
13110 
 
3064 chandransh 13111 
  def __init__(self, orderId=None,):
13112 
    self.orderId = orderId
759 chandransh 13113 
 
13114 
  def read(self, iprot):
13115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13117 
      return
13118 
    iprot.readStructBegin()
13119 
    while True:
13120 
      (fname, ftype, fid) = iprot.readFieldBegin()
13121 
      if ftype == TType.STOP:
13122 
        break
13123 
      if fid == 1:
13124 
        if ftype == TType.I64:
3064 chandransh 13125 
          self.orderId = iprot.readI64();
759 chandransh 13126 
        else:
13127 
          iprot.skip(ftype)
13128 
      else:
13129 
        iprot.skip(ftype)
13130 
      iprot.readFieldEnd()
13131 
    iprot.readStructEnd()
13132 
 
13133 
  def write(self, oprot):
13134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13136 
      return
3064 chandransh 13137 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13138 
    if self.orderId is not None:
3064 chandransh 13139 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13140 
      oprot.writeI64(self.orderId)
759 chandransh 13141 
      oprot.writeFieldEnd()
13142 
    oprot.writeFieldStop()
13143 
    oprot.writeStructEnd()
13144 
 
3431 rajveer 13145 
  def validate(self):
13146 
    return
13147 
 
13148 
 
759 chandransh 13149 
  def __repr__(self):
13150 
    L = ['%s=%r' % (key, value)
13151 
      for key, value in self.__dict__.iteritems()]
13152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13153 
 
13154 
  def __eq__(self, other):
13155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13156 
 
13157 
  def __ne__(self, other):
13158 
    return not (self == other)
13159 
 
3064 chandransh 13160 
class verifyOrder_result:
759 chandransh 13161 
  """
13162 
  Attributes:
13163 
   - success
13164 
   - ex
13165 
  """
13166 
 
13167 
  thrift_spec = (
13168 
    (0, TType.BOOL, 'success', None, None, ), # 0
13169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13170 
  )
13171 
 
13172 
  def __init__(self, success=None, ex=None,):
13173 
    self.success = success
13174 
    self.ex = ex
13175 
 
13176 
  def read(self, iprot):
13177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13179 
      return
13180 
    iprot.readStructBegin()
13181 
    while True:
13182 
      (fname, ftype, fid) = iprot.readFieldBegin()
13183 
      if ftype == TType.STOP:
13184 
        break
13185 
      if fid == 0:
13186 
        if ftype == TType.BOOL:
13187 
          self.success = iprot.readBool();
13188 
        else:
13189 
          iprot.skip(ftype)
13190 
      elif fid == 1:
13191 
        if ftype == TType.STRUCT:
13192 
          self.ex = TransactionServiceException()
13193 
          self.ex.read(iprot)
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('verifyOrder_result')
3431 rajveer 13206 
    if self.success is not None:
759 chandransh 13207 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13208 
      oprot.writeBool(self.success)
13209 
      oprot.writeFieldEnd()
3431 rajveer 13210 
    if self.ex is not None:
759 chandransh 13211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13212 
      self.ex.write(oprot)
13213 
      oprot.writeFieldEnd()
13214 
    oprot.writeFieldStop()
13215 
    oprot.writeStructEnd()
13216 
 
3431 rajveer 13217 
  def validate(self):
13218 
    return
13219 
 
13220 
 
759 chandransh 13221 
  def __repr__(self):
13222 
    L = ['%s=%r' % (key, value)
13223 
      for key, value in self.__dict__.iteritems()]
13224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13225 
 
13226 
  def __eq__(self, other):
13227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13228 
 
13229 
  def __ne__(self, other):
13230 
    return not (self == other)
13231 
 
3064 chandransh 13232 
class acceptOrder_args:
1113 chandransh 13233 
  """
13234 
  Attributes:
3064 chandransh 13235 
   - orderId
1113 chandransh 13236 
  """
13237 
 
13238 
  thrift_spec = (
13239 
    None, # 0
3064 chandransh 13240 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13241 
  )
13242 
 
3064 chandransh 13243 
  def __init__(self, orderId=None,):
13244 
    self.orderId = orderId
1113 chandransh 13245 
 
13246 
  def read(self, iprot):
13247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13249 
      return
13250 
    iprot.readStructBegin()
13251 
    while True:
13252 
      (fname, ftype, fid) = iprot.readFieldBegin()
13253 
      if ftype == TType.STOP:
13254 
        break
13255 
      if fid == 1:
13256 
        if ftype == TType.I64:
3064 chandransh 13257 
          self.orderId = iprot.readI64();
1113 chandransh 13258 
        else:
13259 
          iprot.skip(ftype)
13260 
      else:
13261 
        iprot.skip(ftype)
13262 
      iprot.readFieldEnd()
13263 
    iprot.readStructEnd()
13264 
 
13265 
  def write(self, oprot):
13266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13268 
      return
3064 chandransh 13269 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13270 
    if self.orderId is not None:
3064 chandransh 13271 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13272 
      oprot.writeI64(self.orderId)
1113 chandransh 13273 
      oprot.writeFieldEnd()
13274 
    oprot.writeFieldStop()
13275 
    oprot.writeStructEnd()
13276 
 
3431 rajveer 13277 
  def validate(self):
13278 
    return
13279 
 
13280 
 
1113 chandransh 13281 
  def __repr__(self):
13282 
    L = ['%s=%r' % (key, value)
13283 
      for key, value in self.__dict__.iteritems()]
13284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13285 
 
13286 
  def __eq__(self, other):
13287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13288 
 
13289 
  def __ne__(self, other):
13290 
    return not (self == other)
13291 
 
3064 chandransh 13292 
class acceptOrder_result:
1113 chandransh 13293 
  """
13294 
  Attributes:
13295 
   - success
13296 
   - ex
13297 
  """
13298 
 
13299 
  thrift_spec = (
3064 chandransh 13300 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13302 
  )
13303 
 
13304 
  def __init__(self, success=None, ex=None,):
13305 
    self.success = success
13306 
    self.ex = ex
13307 
 
13308 
  def read(self, iprot):
13309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13311 
      return
13312 
    iprot.readStructBegin()
13313 
    while True:
13314 
      (fname, ftype, fid) = iprot.readFieldBegin()
13315 
      if ftype == TType.STOP:
13316 
        break
13317 
      if fid == 0:
3064 chandransh 13318 
        if ftype == TType.BOOL:
13319 
          self.success = iprot.readBool();
1113 chandransh 13320 
        else:
13321 
          iprot.skip(ftype)
13322 
      elif fid == 1:
13323 
        if ftype == TType.STRUCT:
13324 
          self.ex = TransactionServiceException()
13325 
          self.ex.read(iprot)
13326 
        else:
13327 
          iprot.skip(ftype)
13328 
      else:
13329 
        iprot.skip(ftype)
13330 
      iprot.readFieldEnd()
13331 
    iprot.readStructEnd()
13332 
 
13333 
  def write(self, oprot):
13334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13336 
      return
3064 chandransh 13337 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13338 
    if self.success is not None:
3064 chandransh 13339 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13340 
      oprot.writeBool(self.success)
1113 chandransh 13341 
      oprot.writeFieldEnd()
3431 rajveer 13342 
    if self.ex is not None:
1113 chandransh 13343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13344 
      self.ex.write(oprot)
13345 
      oprot.writeFieldEnd()
13346 
    oprot.writeFieldStop()
13347 
    oprot.writeStructEnd()
13348 
 
3431 rajveer 13349 
  def validate(self):
13350 
    return
13351 
 
13352 
 
1113 chandransh 13353 
  def __repr__(self):
13354 
    L = ['%s=%r' % (key, value)
13355 
      for key, value in self.__dict__.iteritems()]
13356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13357 
 
13358 
  def __eq__(self, other):
13359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13360 
 
13361 
  def __ne__(self, other):
13362 
    return not (self == other)
13363 
 
3064 chandransh 13364 
class addBillingDetails_args:
1135 chandransh 13365 
  """
13366 
  Attributes:
3064 chandransh 13367 
   - orderId
13368 
   - invoice_number
4658 mandeep.dh 13369 
   - serialNumber
4283 anupam.sin 13370 
   - itemNumber
3064 chandransh 13371 
   - billed_by
4264 rajveer 13372 
   - jacketNumber
4283 anupam.sin 13373 
   - billingType
5110 mandeep.dh 13374 
   - fulfilmentWarehouseId
4763 rajveer 13375 
   - authorize
1135 chandransh 13376 
  """
13377 
 
13378 
  thrift_spec = (
13379 
    None, # 0
3064 chandransh 13380 
    (1, TType.I64, 'orderId', None, None, ), # 1
13381 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13382 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13383 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13384 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13385 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13386 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13387 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13388 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13389 
  )
13390 
 
5110 mandeep.dh 13391 
  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 13392 
    self.orderId = orderId
13393 
    self.invoice_number = invoice_number
4658 mandeep.dh 13394 
    self.serialNumber = serialNumber
4283 anupam.sin 13395 
    self.itemNumber = itemNumber
3064 chandransh 13396 
    self.billed_by = billed_by
4264 rajveer 13397 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13398 
    self.billingType = billingType
5110 mandeep.dh 13399 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13400 
    self.authorize = authorize
1135 chandransh 13401 
 
13402 
  def read(self, iprot):
13403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13405 
      return
13406 
    iprot.readStructBegin()
13407 
    while True:
13408 
      (fname, ftype, fid) = iprot.readFieldBegin()
13409 
      if ftype == TType.STOP:
13410 
        break
13411 
      if fid == 1:
13412 
        if ftype == TType.I64:
3064 chandransh 13413 
          self.orderId = iprot.readI64();
1135 chandransh 13414 
        else:
13415 
          iprot.skip(ftype)
13416 
      elif fid == 2:
3064 chandransh 13417 
        if ftype == TType.STRING:
13418 
          self.invoice_number = iprot.readString();
1135 chandransh 13419 
        else:
13420 
          iprot.skip(ftype)
3064 chandransh 13421 
      elif fid == 3:
5411 rajveer 13422 
        if ftype == TType.LIST:
13423 
          self.serialNumber = []
6188 rajveer 13424 
          (_etype270, _size267) = iprot.readListBegin()
13425 
          for _i271 in xrange(_size267):
13426 
            _elem272 = iprot.readString();
13427 
            self.serialNumber.append(_elem272)
5411 rajveer 13428 
          iprot.readListEnd()
3064 chandransh 13429 
        else:
13430 
          iprot.skip(ftype)
13431 
      elif fid == 4:
5411 rajveer 13432 
        if ftype == TType.LIST:
13433 
          self.itemNumber = []
6188 rajveer 13434 
          (_etype276, _size273) = iprot.readListBegin()
13435 
          for _i277 in xrange(_size273):
13436 
            _elem278 = iprot.readString();
13437 
            self.itemNumber.append(_elem278)
5411 rajveer 13438 
          iprot.readListEnd()
3064 chandransh 13439 
        else:
13440 
          iprot.skip(ftype)
13441 
      elif fid == 5:
13442 
        if ftype == TType.STRING:
4283 anupam.sin 13443 
          self.billed_by = iprot.readString();
3064 chandransh 13444 
        else:
13445 
          iprot.skip(ftype)
13446 
      elif fid == 6:
13447 
        if ftype == TType.I64:
4283 anupam.sin 13448 
          self.jacketNumber = iprot.readI64();
13449 
        else:
13450 
          iprot.skip(ftype)
13451 
      elif fid == 7:
13452 
        if ftype == TType.I64:
3064 chandransh 13453 
          self.billingType = iprot.readI64();
13454 
        else:
13455 
          iprot.skip(ftype)
4283 anupam.sin 13456 
      elif fid == 8:
13457 
        if ftype == TType.I64:
5110 mandeep.dh 13458 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13459 
        else:
13460 
          iprot.skip(ftype)
4763 rajveer 13461 
      elif fid == 9:
13462 
        if ftype == TType.BOOL:
13463 
          self.authorize = iprot.readBool();
13464 
        else:
13465 
          iprot.skip(ftype)
1246 chandransh 13466 
      else:
13467 
        iprot.skip(ftype)
13468 
      iprot.readFieldEnd()
13469 
    iprot.readStructEnd()
13470 
 
13471 
  def write(self, oprot):
13472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13474 
      return
4283 anupam.sin 13475 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13476 
    if self.orderId is not None:
3064 chandransh 13477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13478 
      oprot.writeI64(self.orderId)
1246 chandransh 13479 
      oprot.writeFieldEnd()
4283 anupam.sin 13480 
    if self.invoice_number is not None:
13481 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13482 
      oprot.writeString(self.invoice_number)
1246 chandransh 13483 
      oprot.writeFieldEnd()
4658 mandeep.dh 13484 
    if self.serialNumber is not None:
5411 rajveer 13485 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13486 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13487 
      for iter279 in self.serialNumber:
13488 
        oprot.writeString(iter279)
5411 rajveer 13489 
      oprot.writeListEnd()
3064 chandransh 13490 
      oprot.writeFieldEnd()
3431 rajveer 13491 
    if self.itemNumber is not None:
5411 rajveer 13492 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13493 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13494 
      for iter280 in self.itemNumber:
13495 
        oprot.writeString(iter280)
5411 rajveer 13496 
      oprot.writeListEnd()
3064 chandransh 13497 
      oprot.writeFieldEnd()
4283 anupam.sin 13498 
    if self.billed_by is not None:
13499 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13500 
      oprot.writeString(self.billed_by)
3064 chandransh 13501 
      oprot.writeFieldEnd()
4283 anupam.sin 13502 
    if self.jacketNumber is not None:
13503 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13504 
      oprot.writeI64(self.jacketNumber)
13505 
      oprot.writeFieldEnd()
3431 rajveer 13506 
    if self.billingType is not None:
4283 anupam.sin 13507 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13508 
      oprot.writeI64(self.billingType)
13509 
      oprot.writeFieldEnd()
5110 mandeep.dh 13510 
    if self.fulfilmentWarehouseId is not None:
13511 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13512 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13513 
      oprot.writeFieldEnd()
4763 rajveer 13514 
    if self.authorize is not None:
13515 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13516 
      oprot.writeBool(self.authorize)
13517 
      oprot.writeFieldEnd()
1246 chandransh 13518 
    oprot.writeFieldStop()
13519 
    oprot.writeStructEnd()
13520 
 
3431 rajveer 13521 
  def validate(self):
13522 
    return
13523 
 
13524 
 
1246 chandransh 13525 
  def __repr__(self):
13526 
    L = ['%s=%r' % (key, value)
13527 
      for key, value in self.__dict__.iteritems()]
13528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13529 
 
13530 
  def __eq__(self, other):
13531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13532 
 
13533 
  def __ne__(self, other):
13534 
    return not (self == other)
13535 
 
4283 anupam.sin 13536 
class addBillingDetails_result:
1246 chandransh 13537 
  """
13538 
  Attributes:
3064 chandransh 13539 
   - success
1246 chandransh 13540 
   - ex
13541 
  """
13542 
 
13543 
  thrift_spec = (
3064 chandransh 13544 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13546 
  )
13547 
 
3064 chandransh 13548 
  def __init__(self, success=None, ex=None,):
13549 
    self.success = success
1246 chandransh 13550 
    self.ex = ex
13551 
 
13552 
  def read(self, iprot):
13553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13555 
      return
13556 
    iprot.readStructBegin()
13557 
    while True:
13558 
      (fname, ftype, fid) = iprot.readFieldBegin()
13559 
      if ftype == TType.STOP:
13560 
        break
3064 chandransh 13561 
      if fid == 0:
13562 
        if ftype == TType.BOOL:
13563 
          self.success = iprot.readBool();
13564 
        else:
13565 
          iprot.skip(ftype)
13566 
      elif fid == 1:
1246 chandransh 13567 
        if ftype == TType.STRUCT:
13568 
          self.ex = TransactionServiceException()
13569 
          self.ex.read(iprot)
13570 
        else:
13571 
          iprot.skip(ftype)
13572 
      else:
13573 
        iprot.skip(ftype)
13574 
      iprot.readFieldEnd()
13575 
    iprot.readStructEnd()
13576 
 
13577 
  def write(self, oprot):
13578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13580 
      return
4283 anupam.sin 13581 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13582 
    if self.success is not None:
3064 chandransh 13583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13584 
      oprot.writeBool(self.success)
13585 
      oprot.writeFieldEnd()
3431 rajveer 13586 
    if self.ex is not None:
1246 chandransh 13587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13588 
      self.ex.write(oprot)
13589 
      oprot.writeFieldEnd()
13590 
    oprot.writeFieldStop()
13591 
    oprot.writeStructEnd()
13592 
 
3431 rajveer 13593 
  def validate(self):
13594 
    return
13595 
 
13596 
 
1246 chandransh 13597 
  def __repr__(self):
13598 
    L = ['%s=%r' % (key, value)
13599 
      for key, value in self.__dict__.iteritems()]
13600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13601 
 
13602 
  def __eq__(self, other):
13603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13604 
 
13605 
  def __ne__(self, other):
13606 
    return not (self == other)
13607 
 
4579 rajveer 13608 
class addInvoiceNumber_args:
13609 
  """
13610 
  Attributes:
13611 
   - orderId
13612 
   - invoiceNumber
4763 rajveer 13613 
   - color
4579 rajveer 13614 
  """
13615 
 
13616 
  thrift_spec = (
13617 
    None, # 0
13618 
    (1, TType.I64, 'orderId', None, None, ), # 1
13619 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13620 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13621 
  )
13622 
 
4763 rajveer 13623 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13624 
    self.orderId = orderId
13625 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13626 
    self.color = color
4579 rajveer 13627 
 
13628 
  def read(self, iprot):
13629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13631 
      return
13632 
    iprot.readStructBegin()
13633 
    while True:
13634 
      (fname, ftype, fid) = iprot.readFieldBegin()
13635 
      if ftype == TType.STOP:
13636 
        break
13637 
      if fid == 1:
13638 
        if ftype == TType.I64:
13639 
          self.orderId = iprot.readI64();
13640 
        else:
13641 
          iprot.skip(ftype)
13642 
      elif fid == 2:
13643 
        if ftype == TType.STRING:
13644 
          self.invoiceNumber = iprot.readString();
13645 
        else:
13646 
          iprot.skip(ftype)
4763 rajveer 13647 
      elif fid == 3:
13648 
        if ftype == TType.STRING:
13649 
          self.color = iprot.readString();
13650 
        else:
13651 
          iprot.skip(ftype)
4579 rajveer 13652 
      else:
13653 
        iprot.skip(ftype)
13654 
      iprot.readFieldEnd()
13655 
    iprot.readStructEnd()
13656 
 
13657 
  def write(self, oprot):
13658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13660 
      return
13661 
    oprot.writeStructBegin('addInvoiceNumber_args')
13662 
    if self.orderId is not None:
13663 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13664 
      oprot.writeI64(self.orderId)
13665 
      oprot.writeFieldEnd()
13666 
    if self.invoiceNumber is not None:
13667 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13668 
      oprot.writeString(self.invoiceNumber)
13669 
      oprot.writeFieldEnd()
4763 rajveer 13670 
    if self.color is not None:
13671 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13672 
      oprot.writeString(self.color)
13673 
      oprot.writeFieldEnd()
4579 rajveer 13674 
    oprot.writeFieldStop()
13675 
    oprot.writeStructEnd()
13676 
 
13677 
  def validate(self):
13678 
    return
13679 
 
13680 
 
13681 
  def __repr__(self):
13682 
    L = ['%s=%r' % (key, value)
13683 
      for key, value in self.__dict__.iteritems()]
13684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13685 
 
13686 
  def __eq__(self, other):
13687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13688 
 
13689 
  def __ne__(self, other):
13690 
    return not (self == other)
13691 
 
13692 
class addInvoiceNumber_result:
13693 
  """
13694 
  Attributes:
13695 
   - ex
13696 
  """
13697 
 
13698 
  thrift_spec = (
13699 
    None, # 0
13700 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13701 
  )
13702 
 
13703 
  def __init__(self, ex=None,):
13704 
    self.ex = ex
13705 
 
13706 
  def read(self, iprot):
13707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13709 
      return
13710 
    iprot.readStructBegin()
13711 
    while True:
13712 
      (fname, ftype, fid) = iprot.readFieldBegin()
13713 
      if ftype == TType.STOP:
13714 
        break
13715 
      if fid == 1:
13716 
        if ftype == TType.STRUCT:
13717 
          self.ex = TransactionServiceException()
13718 
          self.ex.read(iprot)
13719 
        else:
13720 
          iprot.skip(ftype)
13721 
      else:
13722 
        iprot.skip(ftype)
13723 
      iprot.readFieldEnd()
13724 
    iprot.readStructEnd()
13725 
 
13726 
  def write(self, oprot):
13727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13729 
      return
13730 
    oprot.writeStructBegin('addInvoiceNumber_result')
13731 
    if self.ex is not None:
13732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13733 
      self.ex.write(oprot)
13734 
      oprot.writeFieldEnd()
13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
4910 phani.kuma 13753 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13754 
  """
13755 
  Attributes:
3064 chandransh 13756 
   - warehouseId
1408 ankur.sing 13757 
   - providerId
3064 chandransh 13758 
   - cod
4910 phani.kuma 13759 
   - orderIds
1408 ankur.sing 13760 
  """
13761 
 
13762 
  thrift_spec = (
13763 
    None, # 0
3064 chandransh 13764 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13765 
    (2, TType.I64, 'providerId', None, None, ), # 2
13766 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13767 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13768 
  )
13769 
 
4910 phani.kuma 13770 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13771 
    self.warehouseId = warehouseId
1408 ankur.sing 13772 
    self.providerId = providerId
3064 chandransh 13773 
    self.cod = cod
4910 phani.kuma 13774 
    self.orderIds = orderIds
1408 ankur.sing 13775 
 
13776 
  def read(self, iprot):
13777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13779 
      return
13780 
    iprot.readStructBegin()
13781 
    while True:
13782 
      (fname, ftype, fid) = iprot.readFieldBegin()
13783 
      if ftype == TType.STOP:
13784 
        break
13785 
      if fid == 1:
13786 
        if ftype == TType.I64:
3064 chandransh 13787 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13788 
        else:
13789 
          iprot.skip(ftype)
13790 
      elif fid == 2:
13791 
        if ftype == TType.I64:
3064 chandransh 13792 
          self.providerId = iprot.readI64();
1408 ankur.sing 13793 
        else:
13794 
          iprot.skip(ftype)
3064 chandransh 13795 
      elif fid == 3:
13796 
        if ftype == TType.BOOL:
13797 
          self.cod = iprot.readBool();
13798 
        else:
13799 
          iprot.skip(ftype)
4910 phani.kuma 13800 
      elif fid == 4:
13801 
        if ftype == TType.LIST:
13802 
          self.orderIds = []
6188 rajveer 13803 
          (_etype284, _size281) = iprot.readListBegin()
13804 
          for _i285 in xrange(_size281):
13805 
            _elem286 = iprot.readI64();
13806 
            self.orderIds.append(_elem286)
4910 phani.kuma 13807 
          iprot.readListEnd()
13808 
        else:
13809 
          iprot.skip(ftype)
1408 ankur.sing 13810 
      else:
13811 
        iprot.skip(ftype)
13812 
      iprot.readFieldEnd()
13813 
    iprot.readStructEnd()
13814 
 
13815 
  def write(self, oprot):
13816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13818 
      return
4910 phani.kuma 13819 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13820 
    if self.warehouseId is not None:
3064 chandransh 13821 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13822 
      oprot.writeI64(self.warehouseId)
13823 
      oprot.writeFieldEnd()
3431 rajveer 13824 
    if self.providerId is not None:
3064 chandransh 13825 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13826 
      oprot.writeI64(self.providerId)
13827 
      oprot.writeFieldEnd()
3431 rajveer 13828 
    if self.cod is not None:
3064 chandransh 13829 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13830 
      oprot.writeBool(self.cod)
1408 ankur.sing 13831 
      oprot.writeFieldEnd()
4910 phani.kuma 13832 
    if self.orderIds is not None:
13833 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13834 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13835 
      for iter287 in self.orderIds:
13836 
        oprot.writeI64(iter287)
4910 phani.kuma 13837 
      oprot.writeListEnd()
13838 
      oprot.writeFieldEnd()
1408 ankur.sing 13839 
    oprot.writeFieldStop()
13840 
    oprot.writeStructEnd()
13841 
 
3431 rajveer 13842 
  def validate(self):
13843 
    return
13844 
 
13845 
 
1408 ankur.sing 13846 
  def __repr__(self):
13847 
    L = ['%s=%r' % (key, value)
13848 
      for key, value in self.__dict__.iteritems()]
13849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13850 
 
13851 
  def __eq__(self, other):
13852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13853 
 
13854 
  def __ne__(self, other):
13855 
    return not (self == other)
13856 
 
4910 phani.kuma 13857 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13858 
  """
13859 
  Attributes:
13860 
   - success
3064 chandransh 13861 
   - ex
1408 ankur.sing 13862 
  """
13863 
 
13864 
  thrift_spec = (
3064 chandransh 13865 
    (0, TType.BOOL, 'success', None, None, ), # 0
13866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13867 
  )
13868 
 
3064 chandransh 13869 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13870 
    self.success = success
3064 chandransh 13871 
    self.ex = ex
1408 ankur.sing 13872 
 
13873 
  def read(self, iprot):
13874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13876 
      return
13877 
    iprot.readStructBegin()
13878 
    while True:
13879 
      (fname, ftype, fid) = iprot.readFieldBegin()
13880 
      if ftype == TType.STOP:
13881 
        break
13882 
      if fid == 0:
3064 chandransh 13883 
        if ftype == TType.BOOL:
13884 
          self.success = iprot.readBool();
1408 ankur.sing 13885 
        else:
13886 
          iprot.skip(ftype)
3064 chandransh 13887 
      elif fid == 1:
13888 
        if ftype == TType.STRUCT:
13889 
          self.ex = TransactionServiceException()
13890 
          self.ex.read(iprot)
13891 
        else:
13892 
          iprot.skip(ftype)
1408 ankur.sing 13893 
      else:
13894 
        iprot.skip(ftype)
13895 
      iprot.readFieldEnd()
13896 
    iprot.readStructEnd()
13897 
 
13898 
  def write(self, oprot):
13899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13901 
      return
4910 phani.kuma 13902 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13903 
    if self.success is not None:
3064 chandransh 13904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13905 
      oprot.writeBool(self.success)
1408 ankur.sing 13906 
      oprot.writeFieldEnd()
3431 rajveer 13907 
    if self.ex is not None:
3064 chandransh 13908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13909 
      self.ex.write(oprot)
13910 
      oprot.writeFieldEnd()
1408 ankur.sing 13911 
    oprot.writeFieldStop()
13912 
    oprot.writeStructEnd()
13913 
 
3431 rajveer 13914 
  def validate(self):
13915 
    return
13916 
 
13917 
 
1408 ankur.sing 13918 
  def __repr__(self):
13919 
    L = ['%s=%r' % (key, value)
13920 
      for key, value in self.__dict__.iteritems()]
13921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13922 
 
13923 
  def __eq__(self, other):
13924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13925 
 
13926 
  def __ne__(self, other):
13927 
    return not (self == other)
13928 
 
5676 rajveer 13929 
class markOrdersAsReturnedFromStore_args:
13930 
  """
13931 
  Attributes:
13932 
   - providerId
13933 
   - orderIds
5713 rajveer 13934 
   - awbs
5676 rajveer 13935 
  """
13936 
 
13937 
  thrift_spec = (
13938 
    None, # 0
13939 
    (1, TType.I64, 'providerId', None, None, ), # 1
13940 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13941 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13942 
  )
13943 
 
5713 rajveer 13944 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13945 
    self.providerId = providerId
13946 
    self.orderIds = orderIds
5713 rajveer 13947 
    self.awbs = awbs
5676 rajveer 13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 1:
13959 
        if ftype == TType.I64:
13960 
          self.providerId = iprot.readI64();
13961 
        else:
13962 
          iprot.skip(ftype)
13963 
      elif fid == 2:
13964 
        if ftype == TType.LIST:
13965 
          self.orderIds = []
6188 rajveer 13966 
          (_etype291, _size288) = iprot.readListBegin()
13967 
          for _i292 in xrange(_size288):
13968 
            _elem293 = iprot.readI64();
13969 
            self.orderIds.append(_elem293)
5676 rajveer 13970 
          iprot.readListEnd()
13971 
        else:
13972 
          iprot.skip(ftype)
5713 rajveer 13973 
      elif fid == 3:
13974 
        if ftype == TType.LIST:
13975 
          self.awbs = []
6188 rajveer 13976 
          (_etype297, _size294) = iprot.readListBegin()
13977 
          for _i298 in xrange(_size294):
13978 
            _elem299 = iprot.readString();
13979 
            self.awbs.append(_elem299)
5713 rajveer 13980 
          iprot.readListEnd()
13981 
        else:
13982 
          iprot.skip(ftype)
5676 rajveer 13983 
      else:
13984 
        iprot.skip(ftype)
13985 
      iprot.readFieldEnd()
13986 
    iprot.readStructEnd()
13987 
 
13988 
  def write(self, oprot):
13989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13991 
      return
13992 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13993 
    if self.providerId is not None:
13994 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13995 
      oprot.writeI64(self.providerId)
13996 
      oprot.writeFieldEnd()
13997 
    if self.orderIds is not None:
13998 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13999 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14000 
      for iter300 in self.orderIds:
14001 
        oprot.writeI64(iter300)
5676 rajveer 14002 
      oprot.writeListEnd()
14003 
      oprot.writeFieldEnd()
5713 rajveer 14004 
    if self.awbs is not None:
14005 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14006 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14007 
      for iter301 in self.awbs:
14008 
        oprot.writeString(iter301)
5713 rajveer 14009 
      oprot.writeListEnd()
14010 
      oprot.writeFieldEnd()
5676 rajveer 14011 
    oprot.writeFieldStop()
14012 
    oprot.writeStructEnd()
14013 
 
14014 
  def validate(self):
14015 
    return
14016 
 
14017 
 
14018 
  def __repr__(self):
14019 
    L = ['%s=%r' % (key, value)
14020 
      for key, value in self.__dict__.iteritems()]
14021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14022 
 
14023 
  def __eq__(self, other):
14024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14025 
 
14026 
  def __ne__(self, other):
14027 
    return not (self == other)
14028 
 
14029 
class markOrdersAsReturnedFromStore_result:
14030 
  """
14031 
  Attributes:
14032 
   - success
14033 
   - ex
14034 
  """
14035 
 
14036 
  thrift_spec = (
14037 
    (0, TType.BOOL, 'success', None, None, ), # 0
14038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14039 
  )
14040 
 
14041 
  def __init__(self, success=None, ex=None,):
14042 
    self.success = success
14043 
    self.ex = ex
14044 
 
14045 
  def read(self, iprot):
14046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14048 
      return
14049 
    iprot.readStructBegin()
14050 
    while True:
14051 
      (fname, ftype, fid) = iprot.readFieldBegin()
14052 
      if ftype == TType.STOP:
14053 
        break
14054 
      if fid == 0:
14055 
        if ftype == TType.BOOL:
14056 
          self.success = iprot.readBool();
14057 
        else:
14058 
          iprot.skip(ftype)
14059 
      elif fid == 1:
14060 
        if ftype == TType.STRUCT:
14061 
          self.ex = TransactionServiceException()
14062 
          self.ex.read(iprot)
14063 
        else:
14064 
          iprot.skip(ftype)
14065 
      else:
14066 
        iprot.skip(ftype)
14067 
      iprot.readFieldEnd()
14068 
    iprot.readStructEnd()
14069 
 
14070 
  def write(self, oprot):
14071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14073 
      return
14074 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14075 
    if self.success is not None:
14076 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14077 
      oprot.writeBool(self.success)
14078 
      oprot.writeFieldEnd()
14079 
    if self.ex is not None:
14080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14081 
      self.ex.write(oprot)
14082 
      oprot.writeFieldEnd()
14083 
    oprot.writeFieldStop()
14084 
    oprot.writeStructEnd()
14085 
 
14086 
  def validate(self):
14087 
    return
14088 
 
14089 
 
14090 
  def __repr__(self):
14091 
    L = ['%s=%r' % (key, value)
14092 
      for key, value in self.__dict__.iteritems()]
14093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14094 
 
14095 
  def __eq__(self, other):
14096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14097 
 
14098 
  def __ne__(self, other):
14099 
    return not (self == other)
14100 
 
4910 phani.kuma 14101 
class markOrdersAsPickedUp_args:
4410 rajveer 14102 
  """
14103 
  Attributes:
14104 
   - providerId
4910 phani.kuma 14105 
   - pickupDetails
4410 rajveer 14106 
  """
14107 
 
14108 
  thrift_spec = (
14109 
    None, # 0
4910 phani.kuma 14110 
    (1, TType.I64, 'providerId', None, None, ), # 1
14111 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14112 
  )
14113 
 
4910 phani.kuma 14114 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14115 
    self.providerId = providerId
4910 phani.kuma 14116 
    self.pickupDetails = pickupDetails
4410 rajveer 14117 
 
14118 
  def read(self, iprot):
14119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14121 
      return
14122 
    iprot.readStructBegin()
14123 
    while True:
14124 
      (fname, ftype, fid) = iprot.readFieldBegin()
14125 
      if ftype == TType.STOP:
14126 
        break
14127 
      if fid == 1:
14128 
        if ftype == TType.I64:
4910 phani.kuma 14129 
          self.providerId = iprot.readI64();
4410 rajveer 14130 
        else:
14131 
          iprot.skip(ftype)
14132 
      elif fid == 2:
4910 phani.kuma 14133 
        if ftype == TType.MAP:
14134 
          self.pickupDetails = {}
6188 rajveer 14135 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14136 
          for _i306 in xrange(_size302):
14137 
            _key307 = iprot.readString();
14138 
            _val308 = iprot.readString();
14139 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14140 
          iprot.readMapEnd()
4410 rajveer 14141 
        else:
14142 
          iprot.skip(ftype)
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
4910 phani.kuma 14152 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14153 
    if self.providerId is not None:
4910 phani.kuma 14154 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14155 
      oprot.writeI64(self.providerId)
14156 
      oprot.writeFieldEnd()
4910 phani.kuma 14157 
    if self.pickupDetails is not None:
14158 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14159 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14160 
      for kiter309,viter310 in self.pickupDetails.items():
14161 
        oprot.writeString(kiter309)
14162 
        oprot.writeString(viter310)
4910 phani.kuma 14163 
      oprot.writeMapEnd()
4410 rajveer 14164 
      oprot.writeFieldEnd()
14165 
    oprot.writeFieldStop()
14166 
    oprot.writeStructEnd()
14167 
 
14168 
  def validate(self):
14169 
    return
14170 
 
14171 
 
14172 
  def __repr__(self):
14173 
    L = ['%s=%r' % (key, value)
14174 
      for key, value in self.__dict__.iteritems()]
14175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14176 
 
14177 
  def __eq__(self, other):
14178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14179 
 
14180 
  def __ne__(self, other):
14181 
    return not (self == other)
14182 
 
4910 phani.kuma 14183 
class markOrdersAsPickedUp_result:
4410 rajveer 14184 
  """
14185 
  Attributes:
14186 
   - ex
14187 
  """
14188 
 
14189 
  thrift_spec = (
4910 phani.kuma 14190 
    None, # 0
4410 rajveer 14191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14192 
  )
14193 
 
4910 phani.kuma 14194 
  def __init__(self, ex=None,):
4410 rajveer 14195 
    self.ex = ex
14196 
 
14197 
  def read(self, iprot):
14198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14200 
      return
14201 
    iprot.readStructBegin()
14202 
    while True:
14203 
      (fname, ftype, fid) = iprot.readFieldBegin()
14204 
      if ftype == TType.STOP:
14205 
        break
4910 phani.kuma 14206 
      if fid == 1:
4410 rajveer 14207 
        if ftype == TType.STRUCT:
14208 
          self.ex = TransactionServiceException()
14209 
          self.ex.read(iprot)
14210 
        else:
14211 
          iprot.skip(ftype)
14212 
      else:
14213 
        iprot.skip(ftype)
14214 
      iprot.readFieldEnd()
14215 
    iprot.readStructEnd()
14216 
 
14217 
  def write(self, oprot):
14218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14220 
      return
4910 phani.kuma 14221 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14222 
    if self.ex is not None:
14223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14224 
      self.ex.write(oprot)
14225 
      oprot.writeFieldEnd()
14226 
    oprot.writeFieldStop()
14227 
    oprot.writeStructEnd()
14228 
 
14229 
  def validate(self):
14230 
    return
14231 
 
14232 
 
14233 
  def __repr__(self):
14234 
    L = ['%s=%r' % (key, value)
14235 
      for key, value in self.__dict__.iteritems()]
14236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14237 
 
14238 
  def __eq__(self, other):
14239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14240 
 
14241 
  def __ne__(self, other):
14242 
    return not (self == other)
14243 
 
4910 phani.kuma 14244 
class getOrdersNotPickedUp_args:
304 ashish 14245 
  """
14246 
  Attributes:
3064 chandransh 14247 
   - providerId
304 ashish 14248 
  """
94 ashish 14249 
 
304 ashish 14250 
  thrift_spec = (
14251 
    None, # 0
3064 chandransh 14252 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14253 
  )
14254 
 
4910 phani.kuma 14255 
  def __init__(self, providerId=None,):
3064 chandransh 14256 
    self.providerId = providerId
304 ashish 14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 1:
14268 
        if ftype == TType.I64:
3064 chandransh 14269 
          self.providerId = iprot.readI64();
304 ashish 14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      else:
14273 
        iprot.skip(ftype)
14274 
      iprot.readFieldEnd()
14275 
    iprot.readStructEnd()
14276 
 
14277 
  def write(self, oprot):
14278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14280 
      return
4910 phani.kuma 14281 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14282 
    if self.providerId is not None:
3064 chandransh 14283 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14284 
      oprot.writeI64(self.providerId)
304 ashish 14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
3431 rajveer 14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
304 ashish 14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
14303 
 
4910 phani.kuma 14304 
class getOrdersNotPickedUp_result:
304 ashish 14305 
  """
14306 
  Attributes:
14307 
   - success
14308 
  """
14309 
 
14310 
  thrift_spec = (
3064 chandransh 14311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14312 
  )
14313 
 
4910 phani.kuma 14314 
  def __init__(self, success=None,):
304 ashish 14315 
    self.success = success
14316 
 
14317 
  def read(self, iprot):
14318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14320 
      return
14321 
    iprot.readStructBegin()
14322 
    while True:
14323 
      (fname, ftype, fid) = iprot.readFieldBegin()
14324 
      if ftype == TType.STOP:
14325 
        break
14326 
      if fid == 0:
14327 
        if ftype == TType.LIST:
14328 
          self.success = []
6188 rajveer 14329 
          (_etype314, _size311) = iprot.readListBegin()
14330 
          for _i315 in xrange(_size311):
14331 
            _elem316 = Order()
14332 
            _elem316.read(iprot)
14333 
            self.success.append(_elem316)
304 ashish 14334 
          iprot.readListEnd()
14335 
        else:
14336 
          iprot.skip(ftype)
14337 
      else:
14338 
        iprot.skip(ftype)
14339 
      iprot.readFieldEnd()
14340 
    iprot.readStructEnd()
14341 
 
14342 
  def write(self, oprot):
14343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14345 
      return
4910 phani.kuma 14346 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14347 
    if self.success is not None:
304 ashish 14348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14350 
      for iter317 in self.success:
14351 
        iter317.write(oprot)
304 ashish 14352 
      oprot.writeListEnd()
14353 
      oprot.writeFieldEnd()
14354 
    oprot.writeFieldStop()
14355 
    oprot.writeStructEnd()
14356 
 
3431 rajveer 14357 
  def validate(self):
14358 
    return
14359 
 
14360 
 
304 ashish 14361 
  def __repr__(self):
14362 
    L = ['%s=%r' % (key, value)
14363 
      for key, value in self.__dict__.iteritems()]
14364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14365 
 
14366 
  def __eq__(self, other):
14367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14368 
 
14369 
  def __ne__(self, other):
14370 
    return not (self == other)
14371 
 
3064 chandransh 14372 
class markOrdersAsDelivered_args:
304 ashish 14373 
  """
14374 
  Attributes:
3064 chandransh 14375 
   - providerId
14376 
   - deliveredOrders
304 ashish 14377 
  """
14378 
 
14379 
  thrift_spec = (
14380 
    None, # 0
3064 chandransh 14381 
    (1, TType.I64, 'providerId', None, None, ), # 1
14382 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14383 
  )
14384 
 
3064 chandransh 14385 
  def __init__(self, providerId=None, deliveredOrders=None,):
14386 
    self.providerId = providerId
14387 
    self.deliveredOrders = deliveredOrders
304 ashish 14388 
 
14389 
  def read(self, iprot):
14390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14392 
      return
14393 
    iprot.readStructBegin()
14394 
    while True:
14395 
      (fname, ftype, fid) = iprot.readFieldBegin()
14396 
      if ftype == TType.STOP:
14397 
        break
14398 
      if fid == 1:
14399 
        if ftype == TType.I64:
3064 chandransh 14400 
          self.providerId = iprot.readI64();
304 ashish 14401 
        else:
14402 
          iprot.skip(ftype)
14403 
      elif fid == 2:
3064 chandransh 14404 
        if ftype == TType.MAP:
14405 
          self.deliveredOrders = {}
6188 rajveer 14406 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14407 
          for _i322 in xrange(_size318):
14408 
            _key323 = iprot.readString();
14409 
            _val324 = iprot.readString();
14410 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14411 
          iprot.readMapEnd()
304 ashish 14412 
        else:
14413 
          iprot.skip(ftype)
14414 
      else:
14415 
        iprot.skip(ftype)
14416 
      iprot.readFieldEnd()
14417 
    iprot.readStructEnd()
14418 
 
14419 
  def write(self, oprot):
14420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14422 
      return
3064 chandransh 14423 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14424 
    if self.providerId is not None:
3064 chandransh 14425 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14426 
      oprot.writeI64(self.providerId)
304 ashish 14427 
      oprot.writeFieldEnd()
3431 rajveer 14428 
    if self.deliveredOrders is not None:
3064 chandransh 14429 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14430 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14431 
      for kiter325,viter326 in self.deliveredOrders.items():
14432 
        oprot.writeString(kiter325)
14433 
        oprot.writeString(viter326)
3064 chandransh 14434 
      oprot.writeMapEnd()
304 ashish 14435 
      oprot.writeFieldEnd()
14436 
    oprot.writeFieldStop()
14437 
    oprot.writeStructEnd()
14438 
 
3431 rajveer 14439 
  def validate(self):
14440 
    return
14441 
 
14442 
 
304 ashish 14443 
  def __repr__(self):
14444 
    L = ['%s=%r' % (key, value)
14445 
      for key, value in self.__dict__.iteritems()]
14446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14447 
 
14448 
  def __eq__(self, other):
14449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14450 
 
14451 
  def __ne__(self, other):
14452 
    return not (self == other)
14453 
 
3064 chandransh 14454 
class markOrdersAsDelivered_result:
14455 
  """
14456 
  Attributes:
14457 
   - ex
14458 
  """
304 ashish 14459 
 
14460 
  thrift_spec = (
3064 chandransh 14461 
    None, # 0
14462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14463 
  )
14464 
 
3064 chandransh 14465 
  def __init__(self, ex=None,):
14466 
    self.ex = ex
304 ashish 14467 
 
1596 ankur.sing 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:
14478 
        if ftype == TType.STRUCT:
14479 
          self.ex = TransactionServiceException()
14480 
          self.ex.read(iprot)
14481 
        else:
14482 
          iprot.skip(ftype)
1596 ankur.sing 14483 
      else:
14484 
        iprot.skip(ftype)
14485 
      iprot.readFieldEnd()
14486 
    iprot.readStructEnd()
14487 
 
14488 
  def write(self, oprot):
14489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14491 
      return
3064 chandransh 14492 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14493 
    if self.ex is not None:
3064 chandransh 14494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14495 
      self.ex.write(oprot)
14496 
      oprot.writeFieldEnd()
1596 ankur.sing 14497 
    oprot.writeFieldStop()
14498 
    oprot.writeStructEnd()
14499 
 
3431 rajveer 14500 
  def validate(self):
14501 
    return
14502 
 
14503 
 
1596 ankur.sing 14504 
  def __repr__(self):
14505 
    L = ['%s=%r' % (key, value)
14506 
      for key, value in self.__dict__.iteritems()]
14507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14508 
 
14509 
  def __eq__(self, other):
14510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14511 
 
14512 
  def __ne__(self, other):
14513 
    return not (self == other)
14514 
 
4910 phani.kuma 14515 
class markAsRTOrders_args:
1596 ankur.sing 14516 
  """
14517 
  Attributes:
3064 chandransh 14518 
   - providerId
14519 
   - returnedOrders
1596 ankur.sing 14520 
  """
14521 
 
14522 
  thrift_spec = (
3064 chandransh 14523 
    None, # 0
14524 
    (1, TType.I64, 'providerId', None, None, ), # 1
14525 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14526 
  )
14527 
 
3064 chandransh 14528 
  def __init__(self, providerId=None, returnedOrders=None,):
14529 
    self.providerId = providerId
14530 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14531 
 
14532 
  def read(self, iprot):
14533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14535 
      return
14536 
    iprot.readStructBegin()
14537 
    while True:
14538 
      (fname, ftype, fid) = iprot.readFieldBegin()
14539 
      if ftype == TType.STOP:
14540 
        break
3064 chandransh 14541 
      if fid == 1:
1596 ankur.sing 14542 
        if ftype == TType.I64:
3064 chandransh 14543 
          self.providerId = iprot.readI64();
1596 ankur.sing 14544 
        else:
14545 
          iprot.skip(ftype)
3064 chandransh 14546 
      elif fid == 2:
14547 
        if ftype == TType.MAP:
14548 
          self.returnedOrders = {}
6188 rajveer 14549 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14550 
          for _i331 in xrange(_size327):
14551 
            _key332 = iprot.readString();
14552 
            _val333 = iprot.readString();
14553 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14554 
          iprot.readMapEnd()
14555 
        else:
14556 
          iprot.skip(ftype)
1596 ankur.sing 14557 
      else:
14558 
        iprot.skip(ftype)
14559 
      iprot.readFieldEnd()
14560 
    iprot.readStructEnd()
14561 
 
14562 
  def write(self, oprot):
14563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14565 
      return
4910 phani.kuma 14566 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14567 
    if self.providerId is not None:
3064 chandransh 14568 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14569 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14570 
      oprot.writeFieldEnd()
3431 rajveer 14571 
    if self.returnedOrders is not None:
3064 chandransh 14572 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14573 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14574 
      for kiter334,viter335 in self.returnedOrders.items():
14575 
        oprot.writeString(kiter334)
14576 
        oprot.writeString(viter335)
3064 chandransh 14577 
      oprot.writeMapEnd()
14578 
      oprot.writeFieldEnd()
1596 ankur.sing 14579 
    oprot.writeFieldStop()
14580 
    oprot.writeStructEnd()
14581 
 
3431 rajveer 14582 
  def validate(self):
14583 
    return
14584 
 
14585 
 
1596 ankur.sing 14586 
  def __repr__(self):
14587 
    L = ['%s=%r' % (key, value)
14588 
      for key, value in self.__dict__.iteritems()]
14589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14590 
 
14591 
  def __eq__(self, other):
14592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14593 
 
14594 
  def __ne__(self, other):
14595 
    return not (self == other)
14596 
 
4910 phani.kuma 14597 
class markAsRTOrders_result:
3064 chandransh 14598 
  """
14599 
  Attributes:
14600 
   - ex
14601 
  """
1596 ankur.sing 14602 
 
1627 ankur.sing 14603 
  thrift_spec = (
3064 chandransh 14604 
    None, # 0
14605 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14606 
  )
14607 
 
3064 chandransh 14608 
  def __init__(self, ex=None,):
14609 
    self.ex = ex
14610 
 
1627 ankur.sing 14611 
  def read(self, iprot):
14612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14614 
      return
14615 
    iprot.readStructBegin()
14616 
    while True:
14617 
      (fname, ftype, fid) = iprot.readFieldBegin()
14618 
      if ftype == TType.STOP:
14619 
        break
3064 chandransh 14620 
      if fid == 1:
14621 
        if ftype == TType.STRUCT:
14622 
          self.ex = TransactionServiceException()
14623 
          self.ex.read(iprot)
14624 
        else:
14625 
          iprot.skip(ftype)
1627 ankur.sing 14626 
      else:
14627 
        iprot.skip(ftype)
14628 
      iprot.readFieldEnd()
14629 
    iprot.readStructEnd()
14630 
 
14631 
  def write(self, oprot):
14632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14634 
      return
4910 phani.kuma 14635 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14636 
    if self.ex is not None:
3064 chandransh 14637 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14638 
      self.ex.write(oprot)
14639 
      oprot.writeFieldEnd()
1627 ankur.sing 14640 
    oprot.writeFieldStop()
14641 
    oprot.writeStructEnd()
14642 
 
3431 rajveer 14643 
  def validate(self):
14644 
    return
14645 
 
14646 
 
1627 ankur.sing 14647 
  def __repr__(self):
14648 
    L = ['%s=%r' % (key, value)
14649 
      for key, value in self.__dict__.iteritems()]
14650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14651 
 
14652 
  def __eq__(self, other):
14653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14654 
 
14655 
  def __ne__(self, other):
14656 
    return not (self == other)
14657 
 
4910 phani.kuma 14658 
class getRTOrders_args:
14659 
  """
14660 
  Attributes:
14661 
   - providerId
14662 
  """
14663 
 
14664 
  thrift_spec = (
14665 
    None, # 0
14666 
    (1, TType.I64, 'providerId', None, None, ), # 1
14667 
  )
14668 
 
14669 
  def __init__(self, providerId=None,):
14670 
    self.providerId = providerId
14671 
 
14672 
  def read(self, iprot):
14673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14675 
      return
14676 
    iprot.readStructBegin()
14677 
    while True:
14678 
      (fname, ftype, fid) = iprot.readFieldBegin()
14679 
      if ftype == TType.STOP:
14680 
        break
14681 
      if fid == 1:
14682 
        if ftype == TType.I64:
14683 
          self.providerId = iprot.readI64();
14684 
        else:
14685 
          iprot.skip(ftype)
14686 
      else:
14687 
        iprot.skip(ftype)
14688 
      iprot.readFieldEnd()
14689 
    iprot.readStructEnd()
14690 
 
14691 
  def write(self, oprot):
14692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14694 
      return
14695 
    oprot.writeStructBegin('getRTOrders_args')
14696 
    if self.providerId is not None:
14697 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14698 
      oprot.writeI64(self.providerId)
14699 
      oprot.writeFieldEnd()
14700 
    oprot.writeFieldStop()
14701 
    oprot.writeStructEnd()
14702 
 
14703 
  def validate(self):
14704 
    return
14705 
 
14706 
 
14707 
  def __repr__(self):
14708 
    L = ['%s=%r' % (key, value)
14709 
      for key, value in self.__dict__.iteritems()]
14710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14711 
 
14712 
  def __eq__(self, other):
14713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14714 
 
14715 
  def __ne__(self, other):
14716 
    return not (self == other)
14717 
 
14718 
class getRTOrders_result:
14719 
  """
14720 
  Attributes:
14721 
   - success
14722 
  """
14723 
 
14724 
  thrift_spec = (
14725 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14726 
  )
14727 
 
14728 
  def __init__(self, success=None,):
14729 
    self.success = success
14730 
 
14731 
  def read(self, iprot):
14732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14734 
      return
14735 
    iprot.readStructBegin()
14736 
    while True:
14737 
      (fname, ftype, fid) = iprot.readFieldBegin()
14738 
      if ftype == TType.STOP:
14739 
        break
14740 
      if fid == 0:
14741 
        if ftype == TType.LIST:
14742 
          self.success = []
6188 rajveer 14743 
          (_etype339, _size336) = iprot.readListBegin()
14744 
          for _i340 in xrange(_size336):
14745 
            _elem341 = Order()
14746 
            _elem341.read(iprot)
14747 
            self.success.append(_elem341)
4910 phani.kuma 14748 
          iprot.readListEnd()
14749 
        else:
14750 
          iprot.skip(ftype)
14751 
      else:
14752 
        iprot.skip(ftype)
14753 
      iprot.readFieldEnd()
14754 
    iprot.readStructEnd()
14755 
 
14756 
  def write(self, oprot):
14757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14759 
      return
14760 
    oprot.writeStructBegin('getRTOrders_result')
14761 
    if self.success is not None:
14762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14764 
      for iter342 in self.success:
14765 
        iter342.write(oprot)
4910 phani.kuma 14766 
      oprot.writeListEnd()
14767 
      oprot.writeFieldEnd()
14768 
    oprot.writeFieldStop()
14769 
    oprot.writeStructEnd()
14770 
 
14771 
  def validate(self):
14772 
    return
14773 
 
14774 
 
14775 
  def __repr__(self):
14776 
    L = ['%s=%r' % (key, value)
14777 
      for key, value in self.__dict__.iteritems()]
14778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14779 
 
14780 
  def __eq__(self, other):
14781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14782 
 
14783 
  def __ne__(self, other):
14784 
    return not (self == other)
14785 
 
3064 chandransh 14786 
class updateNonDeliveryReason_args:
1627 ankur.sing 14787 
  """
14788 
  Attributes:
3064 chandransh 14789 
   - providerId
14790 
   - undeliveredOrders
1627 ankur.sing 14791 
  """
14792 
 
14793 
  thrift_spec = (
3064 chandransh 14794 
    None, # 0
14795 
    (1, TType.I64, 'providerId', None, None, ), # 1
14796 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14797 
  )
14798 
 
3064 chandransh 14799 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14800 
    self.providerId = providerId
14801 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14802 
 
14803 
  def read(self, iprot):
14804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14806 
      return
14807 
    iprot.readStructBegin()
14808 
    while True:
14809 
      (fname, ftype, fid) = iprot.readFieldBegin()
14810 
      if ftype == TType.STOP:
14811 
        break
3064 chandransh 14812 
      if fid == 1:
1627 ankur.sing 14813 
        if ftype == TType.I64:
3064 chandransh 14814 
          self.providerId = iprot.readI64();
1627 ankur.sing 14815 
        else:
14816 
          iprot.skip(ftype)
3064 chandransh 14817 
      elif fid == 2:
14818 
        if ftype == TType.MAP:
14819 
          self.undeliveredOrders = {}
6188 rajveer 14820 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14821 
          for _i347 in xrange(_size343):
14822 
            _key348 = iprot.readString();
14823 
            _val349 = iprot.readString();
14824 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14825 
          iprot.readMapEnd()
14826 
        else:
14827 
          iprot.skip(ftype)
1627 ankur.sing 14828 
      else:
14829 
        iprot.skip(ftype)
14830 
      iprot.readFieldEnd()
14831 
    iprot.readStructEnd()
14832 
 
14833 
  def write(self, oprot):
14834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14836 
      return
3064 chandransh 14837 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14838 
    if self.providerId is not None:
3064 chandransh 14839 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14840 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14841 
      oprot.writeFieldEnd()
3431 rajveer 14842 
    if self.undeliveredOrders is not None:
3064 chandransh 14843 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14844 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14845 
      for kiter350,viter351 in self.undeliveredOrders.items():
14846 
        oprot.writeString(kiter350)
14847 
        oprot.writeString(viter351)
3064 chandransh 14848 
      oprot.writeMapEnd()
14849 
      oprot.writeFieldEnd()
1627 ankur.sing 14850 
    oprot.writeFieldStop()
14851 
    oprot.writeStructEnd()
14852 
 
3431 rajveer 14853 
  def validate(self):
14854 
    return
14855 
 
14856 
 
1627 ankur.sing 14857 
  def __repr__(self):
14858 
    L = ['%s=%r' % (key, value)
14859 
      for key, value in self.__dict__.iteritems()]
14860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14861 
 
14862 
  def __eq__(self, other):
14863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14864 
 
14865 
  def __ne__(self, other):
14866 
    return not (self == other)
14867 
 
3064 chandransh 14868 
class updateNonDeliveryReason_result:
1627 ankur.sing 14869 
  """
14870 
  Attributes:
3064 chandransh 14871 
   - ex
1627 ankur.sing 14872 
  """
14873 
 
14874 
  thrift_spec = (
4910 phani.kuma 14875 
    None, # 0
3064 chandransh 14876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14877 
  )
14878 
 
4910 phani.kuma 14879 
  def __init__(self, ex=None,):
3064 chandransh 14880 
    self.ex = ex
1627 ankur.sing 14881 
 
14882 
  def read(self, iprot):
14883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14885 
      return
14886 
    iprot.readStructBegin()
14887 
    while True:
14888 
      (fname, ftype, fid) = iprot.readFieldBegin()
14889 
      if ftype == TType.STOP:
14890 
        break
4910 phani.kuma 14891 
      if fid == 1:
14892 
        if ftype == TType.STRUCT:
14893 
          self.ex = TransactionServiceException()
14894 
          self.ex.read(iprot)
14895 
        else:
14896 
          iprot.skip(ftype)
14897 
      else:
14898 
        iprot.skip(ftype)
14899 
      iprot.readFieldEnd()
14900 
    iprot.readStructEnd()
14901 
 
14902 
  def write(self, oprot):
14903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14905 
      return
14906 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14907 
    if self.ex is not None:
14908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14909 
      self.ex.write(oprot)
14910 
      oprot.writeFieldEnd()
14911 
    oprot.writeFieldStop()
14912 
    oprot.writeStructEnd()
14913 
 
14914 
  def validate(self):
14915 
    return
14916 
 
14917 
 
14918 
  def __repr__(self):
14919 
    L = ['%s=%r' % (key, value)
14920 
      for key, value in self.__dict__.iteritems()]
14921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14922 
 
14923 
  def __eq__(self, other):
14924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14925 
 
14926 
  def __ne__(self, other):
14927 
    return not (self == other)
14928 
 
14929 
class getNonDeliveredOrdersbyCourier_args:
14930 
  """
14931 
  Attributes:
14932 
   - providerId
14933 
  """
14934 
 
14935 
  thrift_spec = (
14936 
    None, # 0
14937 
    (1, TType.I64, 'providerId', None, None, ), # 1
14938 
  )
14939 
 
14940 
  def __init__(self, providerId=None,):
14941 
    self.providerId = providerId
14942 
 
14943 
  def read(self, iprot):
14944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14946 
      return
14947 
    iprot.readStructBegin()
14948 
    while True:
14949 
      (fname, ftype, fid) = iprot.readFieldBegin()
14950 
      if ftype == TType.STOP:
14951 
        break
14952 
      if fid == 1:
14953 
        if ftype == TType.I64:
14954 
          self.providerId = iprot.readI64();
14955 
        else:
14956 
          iprot.skip(ftype)
14957 
      else:
14958 
        iprot.skip(ftype)
14959 
      iprot.readFieldEnd()
14960 
    iprot.readStructEnd()
14961 
 
14962 
  def write(self, oprot):
14963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14965 
      return
14966 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14967 
    if self.providerId is not None:
14968 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14969 
      oprot.writeI64(self.providerId)
14970 
      oprot.writeFieldEnd()
14971 
    oprot.writeFieldStop()
14972 
    oprot.writeStructEnd()
14973 
 
14974 
  def validate(self):
14975 
    return
14976 
 
14977 
 
14978 
  def __repr__(self):
14979 
    L = ['%s=%r' % (key, value)
14980 
      for key, value in self.__dict__.iteritems()]
14981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14982 
 
14983 
  def __eq__(self, other):
14984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14985 
 
14986 
  def __ne__(self, other):
14987 
    return not (self == other)
14988 
 
14989 
class getNonDeliveredOrdersbyCourier_result:
14990 
  """
14991 
  Attributes:
14992 
   - success
14993 
  """
14994 
 
14995 
  thrift_spec = (
14996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14997 
  )
14998 
 
14999 
  def __init__(self, success=None,):
15000 
    self.success = success
15001 
 
15002 
  def read(self, iprot):
15003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15005 
      return
15006 
    iprot.readStructBegin()
15007 
    while True:
15008 
      (fname, ftype, fid) = iprot.readFieldBegin()
15009 
      if ftype == TType.STOP:
15010 
        break
4581 phani.kuma 15011 
      if fid == 0:
15012 
        if ftype == TType.LIST:
15013 
          self.success = []
6188 rajveer 15014 
          (_etype355, _size352) = iprot.readListBegin()
15015 
          for _i356 in xrange(_size352):
15016 
            _elem357 = Order()
15017 
            _elem357.read(iprot)
15018 
            self.success.append(_elem357)
4581 phani.kuma 15019 
          iprot.readListEnd()
15020 
        else:
15021 
          iprot.skip(ftype)
4910 phani.kuma 15022 
      else:
15023 
        iprot.skip(ftype)
15024 
      iprot.readFieldEnd()
15025 
    iprot.readStructEnd()
15026 
 
15027 
  def write(self, oprot):
15028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15030 
      return
15031 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15032 
    if self.success is not None:
15033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15035 
      for iter358 in self.success:
15036 
        iter358.write(oprot)
4910 phani.kuma 15037 
      oprot.writeListEnd()
15038 
      oprot.writeFieldEnd()
15039 
    oprot.writeFieldStop()
15040 
    oprot.writeStructEnd()
15041 
 
15042 
  def validate(self):
15043 
    return
15044 
 
15045 
 
15046 
  def __repr__(self):
15047 
    L = ['%s=%r' % (key, value)
15048 
      for key, value in self.__dict__.iteritems()]
15049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15050 
 
15051 
  def __eq__(self, other):
15052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15053 
 
15054 
  def __ne__(self, other):
15055 
    return not (self == other)
15056 
 
15057 
class markOrdersAsLocalConnected_args:
15058 
  """
15059 
  Attributes:
15060 
   - providerId
15061 
   - local_connected_orders
15062 
  """
15063 
 
15064 
  thrift_spec = (
15065 
    None, # 0
15066 
    (1, TType.I64, 'providerId', None, None, ), # 1
15067 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15068 
  )
15069 
 
15070 
  def __init__(self, providerId=None, local_connected_orders=None,):
15071 
    self.providerId = providerId
15072 
    self.local_connected_orders = local_connected_orders
15073 
 
15074 
  def read(self, iprot):
15075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15077 
      return
15078 
    iprot.readStructBegin()
15079 
    while True:
15080 
      (fname, ftype, fid) = iprot.readFieldBegin()
15081 
      if ftype == TType.STOP:
15082 
        break
15083 
      if fid == 1:
15084 
        if ftype == TType.I64:
15085 
          self.providerId = iprot.readI64();
15086 
        else:
15087 
          iprot.skip(ftype)
15088 
      elif fid == 2:
15089 
        if ftype == TType.MAP:
15090 
          self.local_connected_orders = {}
6188 rajveer 15091 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15092 
          for _i363 in xrange(_size359):
15093 
            _key364 = iprot.readString();
15094 
            _val365 = iprot.readString();
15095 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15096 
          iprot.readMapEnd()
15097 
        else:
15098 
          iprot.skip(ftype)
15099 
      else:
15100 
        iprot.skip(ftype)
15101 
      iprot.readFieldEnd()
15102 
    iprot.readStructEnd()
15103 
 
15104 
  def write(self, oprot):
15105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15107 
      return
15108 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15109 
    if self.providerId is not None:
15110 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15111 
      oprot.writeI64(self.providerId)
15112 
      oprot.writeFieldEnd()
15113 
    if self.local_connected_orders is not None:
15114 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15115 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15116 
      for kiter366,viter367 in self.local_connected_orders.items():
15117 
        oprot.writeString(kiter366)
15118 
        oprot.writeString(viter367)
4910 phani.kuma 15119 
      oprot.writeMapEnd()
15120 
      oprot.writeFieldEnd()
15121 
    oprot.writeFieldStop()
15122 
    oprot.writeStructEnd()
15123 
 
15124 
  def validate(self):
15125 
    return
15126 
 
15127 
 
15128 
  def __repr__(self):
15129 
    L = ['%s=%r' % (key, value)
15130 
      for key, value in self.__dict__.iteritems()]
15131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15132 
 
15133 
  def __eq__(self, other):
15134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15135 
 
15136 
  def __ne__(self, other):
15137 
    return not (self == other)
15138 
 
15139 
class markOrdersAsLocalConnected_result:
15140 
  """
15141 
  Attributes:
15142 
   - ex
15143 
  """
15144 
 
15145 
  thrift_spec = (
15146 
    None, # 0
15147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15148 
  )
15149 
 
15150 
  def __init__(self, ex=None,):
15151 
    self.ex = ex
15152 
 
15153 
  def read(self, iprot):
15154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15156 
      return
15157 
    iprot.readStructBegin()
15158 
    while True:
15159 
      (fname, ftype, fid) = iprot.readFieldBegin()
15160 
      if ftype == TType.STOP:
15161 
        break
15162 
      if fid == 1:
3064 chandransh 15163 
        if ftype == TType.STRUCT:
15164 
          self.ex = TransactionServiceException()
15165 
          self.ex.read(iprot)
1627 ankur.sing 15166 
        else:
15167 
          iprot.skip(ftype)
15168 
      else:
15169 
        iprot.skip(ftype)
15170 
      iprot.readFieldEnd()
15171 
    iprot.readStructEnd()
15172 
 
15173 
  def write(self, oprot):
15174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15176 
      return
4910 phani.kuma 15177 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15178 
    if self.ex is not None:
15179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15180 
      self.ex.write(oprot)
15181 
      oprot.writeFieldEnd()
15182 
    oprot.writeFieldStop()
15183 
    oprot.writeStructEnd()
15184 
 
15185 
  def validate(self):
15186 
    return
15187 
 
15188 
 
15189 
  def __repr__(self):
15190 
    L = ['%s=%r' % (key, value)
15191 
      for key, value in self.__dict__.iteritems()]
15192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15193 
 
15194 
  def __eq__(self, other):
15195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15196 
 
15197 
  def __ne__(self, other):
15198 
    return not (self == other)
15199 
 
15200 
class getOrdersNotLocalConnected_args:
15201 
  """
15202 
  Attributes:
15203 
   - providerId
15204 
  """
15205 
 
15206 
  thrift_spec = (
15207 
    None, # 0
15208 
    (1, TType.I64, 'providerId', None, None, ), # 1
15209 
  )
15210 
 
15211 
  def __init__(self, providerId=None,):
15212 
    self.providerId = providerId
15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == 1:
15224 
        if ftype == TType.I64:
15225 
          self.providerId = iprot.readI64();
15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
15237 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15238 
    if self.providerId is not None:
15239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15240 
      oprot.writeI64(self.providerId)
15241 
      oprot.writeFieldEnd()
15242 
    oprot.writeFieldStop()
15243 
    oprot.writeStructEnd()
15244 
 
15245 
  def validate(self):
15246 
    return
15247 
 
15248 
 
15249 
  def __repr__(self):
15250 
    L = ['%s=%r' % (key, value)
15251 
      for key, value in self.__dict__.iteritems()]
15252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15253 
 
15254 
  def __eq__(self, other):
15255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15256 
 
15257 
  def __ne__(self, other):
15258 
    return not (self == other)
15259 
 
15260 
class getOrdersNotLocalConnected_result:
15261 
  """
15262 
  Attributes:
15263 
   - success
15264 
  """
15265 
 
15266 
  thrift_spec = (
15267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15268 
  )
15269 
 
15270 
  def __init__(self, success=None,):
15271 
    self.success = success
15272 
 
15273 
  def read(self, iprot):
15274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15276 
      return
15277 
    iprot.readStructBegin()
15278 
    while True:
15279 
      (fname, ftype, fid) = iprot.readFieldBegin()
15280 
      if ftype == TType.STOP:
15281 
        break
15282 
      if fid == 0:
15283 
        if ftype == TType.LIST:
15284 
          self.success = []
6188 rajveer 15285 
          (_etype371, _size368) = iprot.readListBegin()
15286 
          for _i372 in xrange(_size368):
15287 
            _elem373 = Order()
15288 
            _elem373.read(iprot)
15289 
            self.success.append(_elem373)
4910 phani.kuma 15290 
          iprot.readListEnd()
15291 
        else:
15292 
          iprot.skip(ftype)
15293 
      else:
15294 
        iprot.skip(ftype)
15295 
      iprot.readFieldEnd()
15296 
    iprot.readStructEnd()
15297 
 
15298 
  def write(self, oprot):
15299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15301 
      return
15302 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15303 
    if self.success is not None:
15304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15306 
      for iter374 in self.success:
15307 
        iter374.write(oprot)
4581 phani.kuma 15308 
      oprot.writeListEnd()
15309 
      oprot.writeFieldEnd()
4910 phani.kuma 15310 
    oprot.writeFieldStop()
15311 
    oprot.writeStructEnd()
15312 
 
15313 
  def validate(self):
15314 
    return
15315 
 
15316 
 
15317 
  def __repr__(self):
15318 
    L = ['%s=%r' % (key, value)
15319 
      for key, value in self.__dict__.iteritems()]
15320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15321 
 
15322 
  def __eq__(self, other):
15323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15324 
 
15325 
  def __ne__(self, other):
15326 
    return not (self == other)
15327 
 
15328 
class markOrdersAsDestinationCityReached_args:
15329 
  """
15330 
  Attributes:
15331 
   - providerId
15332 
   - destination_city_reached_orders
15333 
  """
15334 
 
15335 
  thrift_spec = (
15336 
    None, # 0
15337 
    (1, TType.I64, 'providerId', None, None, ), # 1
15338 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15339 
  )
15340 
 
15341 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15342 
    self.providerId = providerId
15343 
    self.destination_city_reached_orders = destination_city_reached_orders
15344 
 
15345 
  def read(self, iprot):
15346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15348 
      return
15349 
    iprot.readStructBegin()
15350 
    while True:
15351 
      (fname, ftype, fid) = iprot.readFieldBegin()
15352 
      if ftype == TType.STOP:
15353 
        break
15354 
      if fid == 1:
15355 
        if ftype == TType.I64:
15356 
          self.providerId = iprot.readI64();
15357 
        else:
15358 
          iprot.skip(ftype)
15359 
      elif fid == 2:
15360 
        if ftype == TType.MAP:
15361 
          self.destination_city_reached_orders = {}
6188 rajveer 15362 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15363 
          for _i379 in xrange(_size375):
15364 
            _key380 = iprot.readString();
15365 
            _val381 = iprot.readString();
15366 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15367 
          iprot.readMapEnd()
15368 
        else:
15369 
          iprot.skip(ftype)
15370 
      else:
15371 
        iprot.skip(ftype)
15372 
      iprot.readFieldEnd()
15373 
    iprot.readStructEnd()
15374 
 
15375 
  def write(self, oprot):
15376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15378 
      return
15379 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15380 
    if self.providerId is not None:
15381 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15382 
      oprot.writeI64(self.providerId)
15383 
      oprot.writeFieldEnd()
15384 
    if self.destination_city_reached_orders is not None:
15385 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15386 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15387 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15388 
        oprot.writeString(kiter382)
15389 
        oprot.writeString(viter383)
4910 phani.kuma 15390 
      oprot.writeMapEnd()
15391 
      oprot.writeFieldEnd()
15392 
    oprot.writeFieldStop()
15393 
    oprot.writeStructEnd()
15394 
 
15395 
  def validate(self):
15396 
    return
15397 
 
15398 
 
15399 
  def __repr__(self):
15400 
    L = ['%s=%r' % (key, value)
15401 
      for key, value in self.__dict__.iteritems()]
15402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15403 
 
15404 
  def __eq__(self, other):
15405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15406 
 
15407 
  def __ne__(self, other):
15408 
    return not (self == other)
15409 
 
15410 
class markOrdersAsDestinationCityReached_result:
15411 
  """
15412 
  Attributes:
15413 
   - ex
15414 
  """
15415 
 
15416 
  thrift_spec = (
15417 
    None, # 0
15418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15419 
  )
15420 
 
15421 
  def __init__(self, ex=None,):
15422 
    self.ex = ex
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.STRUCT:
15435 
          self.ex = TransactionServiceException()
15436 
          self.ex.read(iprot)
15437 
        else:
15438 
          iprot.skip(ftype)
15439 
      else:
15440 
        iprot.skip(ftype)
15441 
      iprot.readFieldEnd()
15442 
    iprot.readStructEnd()
15443 
 
15444 
  def write(self, oprot):
15445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15447 
      return
15448 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15449 
    if self.ex is not None:
3064 chandransh 15450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15451 
      self.ex.write(oprot)
1627 ankur.sing 15452 
      oprot.writeFieldEnd()
15453 
    oprot.writeFieldStop()
15454 
    oprot.writeStructEnd()
15455 
 
3431 rajveer 15456 
  def validate(self):
15457 
    return
15458 
 
15459 
 
1627 ankur.sing 15460 
  def __repr__(self):
15461 
    L = ['%s=%r' % (key, value)
15462 
      for key, value in self.__dict__.iteritems()]
15463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15464 
 
15465 
  def __eq__(self, other):
15466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15467 
 
15468 
  def __ne__(self, other):
15469 
    return not (self == other)
15470 
 
4910 phani.kuma 15471 
class markOrdersAsFirstDeliveryAttempted_args:
15472 
  """
15473 
  Attributes:
15474 
   - providerId
15475 
   - first_atdl_orders
15476 
  """
15477 
 
15478 
  thrift_spec = (
15479 
    None, # 0
15480 
    (1, TType.I64, 'providerId', None, None, ), # 1
15481 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15482 
  )
15483 
 
15484 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15485 
    self.providerId = providerId
15486 
    self.first_atdl_orders = first_atdl_orders
15487 
 
15488 
  def read(self, iprot):
15489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15491 
      return
15492 
    iprot.readStructBegin()
15493 
    while True:
15494 
      (fname, ftype, fid) = iprot.readFieldBegin()
15495 
      if ftype == TType.STOP:
15496 
        break
15497 
      if fid == 1:
15498 
        if ftype == TType.I64:
15499 
          self.providerId = iprot.readI64();
15500 
        else:
15501 
          iprot.skip(ftype)
15502 
      elif fid == 2:
15503 
        if ftype == TType.MAP:
15504 
          self.first_atdl_orders = {}
6188 rajveer 15505 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15506 
          for _i388 in xrange(_size384):
15507 
            _key389 = iprot.readString();
15508 
            _val390 = iprot.readString();
15509 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15510 
          iprot.readMapEnd()
15511 
        else:
15512 
          iprot.skip(ftype)
15513 
      else:
15514 
        iprot.skip(ftype)
15515 
      iprot.readFieldEnd()
15516 
    iprot.readStructEnd()
15517 
 
15518 
  def write(self, oprot):
15519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15521 
      return
15522 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15523 
    if self.providerId is not None:
15524 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15525 
      oprot.writeI64(self.providerId)
15526 
      oprot.writeFieldEnd()
15527 
    if self.first_atdl_orders is not None:
15528 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15529 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15530 
      for kiter391,viter392 in self.first_atdl_orders.items():
15531 
        oprot.writeString(kiter391)
15532 
        oprot.writeString(viter392)
4910 phani.kuma 15533 
      oprot.writeMapEnd()
15534 
      oprot.writeFieldEnd()
15535 
    oprot.writeFieldStop()
15536 
    oprot.writeStructEnd()
15537 
 
15538 
  def validate(self):
15539 
    return
15540 
 
15541 
 
15542 
  def __repr__(self):
15543 
    L = ['%s=%r' % (key, value)
15544 
      for key, value in self.__dict__.iteritems()]
15545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15546 
 
15547 
  def __eq__(self, other):
15548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15549 
 
15550 
  def __ne__(self, other):
15551 
    return not (self == other)
15552 
 
15553 
class markOrdersAsFirstDeliveryAttempted_result:
15554 
  """
15555 
  Attributes:
15556 
   - ex
15557 
  """
15558 
 
15559 
  thrift_spec = (
15560 
    None, # 0
15561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15562 
  )
15563 
 
15564 
  def __init__(self, ex=None,):
15565 
    self.ex = ex
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.STRUCT:
15578 
          self.ex = TransactionServiceException()
15579 
          self.ex.read(iprot)
15580 
        else:
15581 
          iprot.skip(ftype)
15582 
      else:
15583 
        iprot.skip(ftype)
15584 
      iprot.readFieldEnd()
15585 
    iprot.readStructEnd()
15586 
 
15587 
  def write(self, oprot):
15588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15590 
      return
15591 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15592 
    if self.ex is not None:
15593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15594 
      self.ex.write(oprot)
15595 
      oprot.writeFieldEnd()
15596 
    oprot.writeFieldStop()
15597 
    oprot.writeStructEnd()
15598 
 
15599 
  def validate(self):
15600 
    return
15601 
 
15602 
 
15603 
  def __repr__(self):
15604 
    L = ['%s=%r' % (key, value)
15605 
      for key, value in self.__dict__.iteritems()]
15606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15607 
 
15608 
  def __eq__(self, other):
15609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15610 
 
15611 
  def __ne__(self, other):
15612 
    return not (self == other)
15613 
 
3064 chandransh 15614 
class getUndeliveredOrders_args:
1886 ankur.sing 15615 
  """
15616 
  Attributes:
3064 chandransh 15617 
   - providerId
15618 
   - warehouseId
1886 ankur.sing 15619 
  """
1627 ankur.sing 15620 
 
1886 ankur.sing 15621 
  thrift_spec = (
15622 
    None, # 0
3064 chandransh 15623 
    (1, TType.I64, 'providerId', None, None, ), # 1
15624 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15625 
  )
15626 
 
3064 chandransh 15627 
  def __init__(self, providerId=None, warehouseId=None,):
15628 
    self.providerId = providerId
15629 
    self.warehouseId = warehouseId
1886 ankur.sing 15630 
 
15631 
  def read(self, iprot):
15632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15634 
      return
15635 
    iprot.readStructBegin()
15636 
    while True:
15637 
      (fname, ftype, fid) = iprot.readFieldBegin()
15638 
      if ftype == TType.STOP:
15639 
        break
15640 
      if fid == 1:
15641 
        if ftype == TType.I64:
3064 chandransh 15642 
          self.providerId = iprot.readI64();
1886 ankur.sing 15643 
        else:
15644 
          iprot.skip(ftype)
3064 chandransh 15645 
      elif fid == 2:
15646 
        if ftype == TType.I64:
15647 
          self.warehouseId = iprot.readI64();
15648 
        else:
15649 
          iprot.skip(ftype)
1886 ankur.sing 15650 
      else:
15651 
        iprot.skip(ftype)
15652 
      iprot.readFieldEnd()
15653 
    iprot.readStructEnd()
15654 
 
15655 
  def write(self, oprot):
15656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15658 
      return
3064 chandransh 15659 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15660 
    if self.providerId is not None:
3064 chandransh 15661 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15662 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15663 
      oprot.writeFieldEnd()
3431 rajveer 15664 
    if self.warehouseId is not None:
3064 chandransh 15665 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15666 
      oprot.writeI64(self.warehouseId)
15667 
      oprot.writeFieldEnd()
1886 ankur.sing 15668 
    oprot.writeFieldStop()
15669 
    oprot.writeStructEnd()
15670 
 
3431 rajveer 15671 
  def validate(self):
15672 
    return
15673 
 
15674 
 
1886 ankur.sing 15675 
  def __repr__(self):
15676 
    L = ['%s=%r' % (key, value)
15677 
      for key, value in self.__dict__.iteritems()]
15678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15679 
 
15680 
  def __eq__(self, other):
15681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15682 
 
15683 
  def __ne__(self, other):
15684 
    return not (self == other)
15685 
 
3064 chandransh 15686 
class getUndeliveredOrders_result:
1886 ankur.sing 15687 
  """
15688 
  Attributes:
15689 
   - success
15690 
  """
15691 
 
15692 
  thrift_spec = (
15693 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15694 
  )
15695 
 
15696 
  def __init__(self, success=None,):
15697 
    self.success = success
15698 
 
15699 
  def read(self, iprot):
15700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15702 
      return
15703 
    iprot.readStructBegin()
15704 
    while True:
15705 
      (fname, ftype, fid) = iprot.readFieldBegin()
15706 
      if ftype == TType.STOP:
15707 
        break
15708 
      if fid == 0:
15709 
        if ftype == TType.LIST:
15710 
          self.success = []
6188 rajveer 15711 
          (_etype396, _size393) = iprot.readListBegin()
15712 
          for _i397 in xrange(_size393):
15713 
            _elem398 = Order()
15714 
            _elem398.read(iprot)
15715 
            self.success.append(_elem398)
1886 ankur.sing 15716 
          iprot.readListEnd()
15717 
        else:
15718 
          iprot.skip(ftype)
15719 
      else:
15720 
        iprot.skip(ftype)
15721 
      iprot.readFieldEnd()
15722 
    iprot.readStructEnd()
15723 
 
15724 
  def write(self, oprot):
15725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15727 
      return
3064 chandransh 15728 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15729 
    if self.success is not None:
1886 ankur.sing 15730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15732 
      for iter399 in self.success:
15733 
        iter399.write(oprot)
1886 ankur.sing 15734 
      oprot.writeListEnd()
15735 
      oprot.writeFieldEnd()
15736 
    oprot.writeFieldStop()
15737 
    oprot.writeStructEnd()
15738 
 
3431 rajveer 15739 
  def validate(self):
15740 
    return
15741 
 
15742 
 
1886 ankur.sing 15743 
  def __repr__(self):
15744 
    L = ['%s=%r' % (key, value)
15745 
      for key, value in self.__dict__.iteritems()]
15746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15747 
 
15748 
  def __eq__(self, other):
15749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15750 
 
15751 
  def __ne__(self, other):
15752 
    return not (self == other)
15753 
 
4783 phani.kuma 15754 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15755 
 
15756 
  thrift_spec = (
15757 
  )
15758 
 
15759 
  def read(self, iprot):
15760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15762 
      return
15763 
    iprot.readStructBegin()
15764 
    while True:
15765 
      (fname, ftype, fid) = iprot.readFieldBegin()
15766 
      if ftype == TType.STOP:
15767 
        break
15768 
      else:
15769 
        iprot.skip(ftype)
15770 
      iprot.readFieldEnd()
15771 
    iprot.readStructEnd()
15772 
 
15773 
  def write(self, oprot):
15774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15776 
      return
15777 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15778 
    oprot.writeFieldStop()
15779 
    oprot.writeStructEnd()
15780 
 
15781 
  def validate(self):
15782 
    return
15783 
 
15784 
 
15785 
  def __repr__(self):
15786 
    L = ['%s=%r' % (key, value)
15787 
      for key, value in self.__dict__.iteritems()]
15788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15789 
 
15790 
  def __eq__(self, other):
15791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15792 
 
15793 
  def __ne__(self, other):
15794 
    return not (self == other)
15795 
 
15796 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15797 
  """
15798 
  Attributes:
15799 
   - success
15800 
  """
15801 
 
15802 
  thrift_spec = (
15803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15804 
  )
15805 
 
15806 
  def __init__(self, success=None,):
15807 
    self.success = success
15808 
 
15809 
  def read(self, iprot):
15810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15812 
      return
15813 
    iprot.readStructBegin()
15814 
    while True:
15815 
      (fname, ftype, fid) = iprot.readFieldBegin()
15816 
      if ftype == TType.STOP:
15817 
        break
15818 
      if fid == 0:
15819 
        if ftype == TType.LIST:
15820 
          self.success = []
6188 rajveer 15821 
          (_etype403, _size400) = iprot.readListBegin()
15822 
          for _i404 in xrange(_size400):
15823 
            _elem405 = Order()
15824 
            _elem405.read(iprot)
15825 
            self.success.append(_elem405)
4783 phani.kuma 15826 
          iprot.readListEnd()
15827 
        else:
15828 
          iprot.skip(ftype)
15829 
      else:
15830 
        iprot.skip(ftype)
15831 
      iprot.readFieldEnd()
15832 
    iprot.readStructEnd()
15833 
 
15834 
  def write(self, oprot):
15835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15837 
      return
15838 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15839 
    if self.success is not None:
15840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15842 
      for iter406 in self.success:
15843 
        iter406.write(oprot)
4783 phani.kuma 15844 
      oprot.writeListEnd()
15845 
      oprot.writeFieldEnd()
15846 
    oprot.writeFieldStop()
15847 
    oprot.writeStructEnd()
15848 
 
15849 
  def validate(self):
15850 
    return
15851 
 
15852 
 
15853 
  def __repr__(self):
15854 
    L = ['%s=%r' % (key, value)
15855 
      for key, value in self.__dict__.iteritems()]
15856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15857 
 
15858 
  def __eq__(self, other):
15859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15860 
 
15861 
  def __ne__(self, other):
15862 
    return not (self == other)
15863 
 
2536 chandransh 15864 
class toggleDOAFlag_args:
15865 
  """
15866 
  Attributes:
15867 
   - orderId
15868 
  """
1886 ankur.sing 15869 
 
2536 chandransh 15870 
  thrift_spec = (
15871 
    None, # 0
15872 
    (1, TType.I64, 'orderId', None, None, ), # 1
15873 
  )
15874 
 
15875 
  def __init__(self, orderId=None,):
15876 
    self.orderId = orderId
15877 
 
15878 
  def read(self, iprot):
15879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15881 
      return
15882 
    iprot.readStructBegin()
15883 
    while True:
15884 
      (fname, ftype, fid) = iprot.readFieldBegin()
15885 
      if ftype == TType.STOP:
15886 
        break
15887 
      if fid == 1:
15888 
        if ftype == TType.I64:
15889 
          self.orderId = iprot.readI64();
15890 
        else:
15891 
          iprot.skip(ftype)
15892 
      else:
15893 
        iprot.skip(ftype)
15894 
      iprot.readFieldEnd()
15895 
    iprot.readStructEnd()
15896 
 
15897 
  def write(self, oprot):
15898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15900 
      return
15901 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15902 
    if self.orderId is not None:
2536 chandransh 15903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15904 
      oprot.writeI64(self.orderId)
15905 
      oprot.writeFieldEnd()
15906 
    oprot.writeFieldStop()
15907 
    oprot.writeStructEnd()
15908 
 
3431 rajveer 15909 
  def validate(self):
15910 
    return
15911 
 
15912 
 
2536 chandransh 15913 
  def __repr__(self):
15914 
    L = ['%s=%r' % (key, value)
15915 
      for key, value in self.__dict__.iteritems()]
15916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15917 
 
15918 
  def __eq__(self, other):
15919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15920 
 
15921 
  def __ne__(self, other):
15922 
    return not (self == other)
15923 
 
15924 
class toggleDOAFlag_result:
15925 
  """
15926 
  Attributes:
15927 
   - success
15928 
   - ex
15929 
  """
15930 
 
15931 
  thrift_spec = (
15932 
    (0, TType.BOOL, 'success', None, None, ), # 0
15933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15934 
  )
15935 
 
15936 
  def __init__(self, success=None, ex=None,):
15937 
    self.success = success
15938 
    self.ex = ex
15939 
 
15940 
  def read(self, iprot):
15941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15943 
      return
15944 
    iprot.readStructBegin()
15945 
    while True:
15946 
      (fname, ftype, fid) = iprot.readFieldBegin()
15947 
      if ftype == TType.STOP:
15948 
        break
15949 
      if fid == 0:
15950 
        if ftype == TType.BOOL:
15951 
          self.success = iprot.readBool();
15952 
        else:
15953 
          iprot.skip(ftype)
15954 
      elif fid == 1:
15955 
        if ftype == TType.STRUCT:
15956 
          self.ex = TransactionServiceException()
15957 
          self.ex.read(iprot)
15958 
        else:
15959 
          iprot.skip(ftype)
15960 
      else:
15961 
        iprot.skip(ftype)
15962 
      iprot.readFieldEnd()
15963 
    iprot.readStructEnd()
15964 
 
15965 
  def write(self, oprot):
15966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15968 
      return
15969 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15970 
    if self.success is not None:
2536 chandransh 15971 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15972 
      oprot.writeBool(self.success)
15973 
      oprot.writeFieldEnd()
3431 rajveer 15974 
    if self.ex is not None:
2536 chandransh 15975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15976 
      self.ex.write(oprot)
15977 
      oprot.writeFieldEnd()
15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
3431 rajveer 15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
2536 chandransh 15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
4712 rajveer 15996 
class markOrderAsDelivered_args:
15997 
  """
15998 
  Attributes:
15999 
   - orderId
16000 
   - deliveryTimestamp
16001 
   - receiver
16002 
  """
16003 
 
16004 
  thrift_spec = None
16005 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16006 
    self.orderId = orderId
16007 
    self.deliveryTimestamp = deliveryTimestamp
16008 
    self.receiver = receiver
16009 
 
16010 
  def read(self, iprot):
16011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16013 
      return
16014 
    iprot.readStructBegin()
16015 
    while True:
16016 
      (fname, ftype, fid) = iprot.readFieldBegin()
16017 
      if ftype == TType.STOP:
16018 
        break
16019 
      if fid == 1:
16020 
        if ftype == TType.I64:
16021 
          self.orderId = iprot.readI64();
16022 
        else:
16023 
          iprot.skip(ftype)
16024 
      elif fid == 2:
16025 
        if ftype == TType.I64:
16026 
          self.deliveryTimestamp = iprot.readI64();
16027 
        else:
16028 
          iprot.skip(ftype)
16029 
      elif fid == -1:
16030 
        if ftype == TType.STRING:
16031 
          self.receiver = iprot.readString();
16032 
        else:
16033 
          iprot.skip(ftype)
16034 
      else:
16035 
        iprot.skip(ftype)
16036 
      iprot.readFieldEnd()
16037 
    iprot.readStructEnd()
16038 
 
16039 
  def write(self, oprot):
16040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16042 
      return
16043 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16044 
    if self.receiver is not None:
16045 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16046 
      oprot.writeString(self.receiver)
16047 
      oprot.writeFieldEnd()
16048 
    if self.orderId is not None:
16049 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16050 
      oprot.writeI64(self.orderId)
16051 
      oprot.writeFieldEnd()
16052 
    if self.deliveryTimestamp is not None:
16053 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16054 
      oprot.writeI64(self.deliveryTimestamp)
16055 
      oprot.writeFieldEnd()
16056 
    oprot.writeFieldStop()
16057 
    oprot.writeStructEnd()
16058 
 
16059 
  def validate(self):
16060 
    return
16061 
 
16062 
 
16063 
  def __repr__(self):
16064 
    L = ['%s=%r' % (key, value)
16065 
      for key, value in self.__dict__.iteritems()]
16066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16067 
 
16068 
  def __eq__(self, other):
16069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16070 
 
16071 
  def __ne__(self, other):
16072 
    return not (self == other)
16073 
 
16074 
class markOrderAsDelivered_result:
16075 
  """
16076 
  Attributes:
16077 
   - ex
16078 
  """
16079 
 
16080 
  thrift_spec = (
16081 
    None, # 0
16082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16083 
  )
16084 
 
16085 
  def __init__(self, ex=None,):
16086 
    self.ex = ex
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.STRUCT:
16099 
          self.ex = TransactionServiceException()
16100 
          self.ex.read(iprot)
16101 
        else:
16102 
          iprot.skip(ftype)
16103 
      else:
16104 
        iprot.skip(ftype)
16105 
      iprot.readFieldEnd()
16106 
    iprot.readStructEnd()
16107 
 
16108 
  def write(self, oprot):
16109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16111 
      return
16112 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16113 
    if self.ex is not None:
16114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16115 
      self.ex.write(oprot)
16116 
      oprot.writeFieldEnd()
16117 
    oprot.writeFieldStop()
16118 
    oprot.writeStructEnd()
16119 
 
16120 
  def validate(self):
16121 
    return
16122 
 
16123 
 
16124 
  def __repr__(self):
16125 
    L = ['%s=%r' % (key, value)
16126 
      for key, value in self.__dict__.iteritems()]
16127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16128 
 
16129 
  def __eq__(self, other):
16130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16131 
 
16132 
  def __ne__(self, other):
16133 
    return not (self == other)
16134 
 
5553 rajveer 16135 
class markOrderAsReceivedAtStore_args:
16136 
  """
16137 
  Attributes:
16138 
   - orderId
16139 
   - deliveryTimestamp
16140 
  """
16141 
 
16142 
  thrift_spec = (
16143 
    None, # 0
16144 
    (1, TType.I64, 'orderId', None, None, ), # 1
16145 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16146 
  )
16147 
 
16148 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16149 
    self.orderId = orderId
16150 
    self.deliveryTimestamp = deliveryTimestamp
16151 
 
16152 
  def read(self, iprot):
16153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16155 
      return
16156 
    iprot.readStructBegin()
16157 
    while True:
16158 
      (fname, ftype, fid) = iprot.readFieldBegin()
16159 
      if ftype == TType.STOP:
16160 
        break
16161 
      if fid == 1:
16162 
        if ftype == TType.I64:
16163 
          self.orderId = iprot.readI64();
16164 
        else:
16165 
          iprot.skip(ftype)
16166 
      elif fid == 2:
16167 
        if ftype == TType.I64:
16168 
          self.deliveryTimestamp = iprot.readI64();
16169 
        else:
16170 
          iprot.skip(ftype)
16171 
      else:
16172 
        iprot.skip(ftype)
16173 
      iprot.readFieldEnd()
16174 
    iprot.readStructEnd()
16175 
 
16176 
  def write(self, oprot):
16177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16179 
      return
16180 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16181 
    if self.orderId is not None:
16182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16183 
      oprot.writeI64(self.orderId)
16184 
      oprot.writeFieldEnd()
16185 
    if self.deliveryTimestamp is not None:
16186 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16187 
      oprot.writeI64(self.deliveryTimestamp)
16188 
      oprot.writeFieldEnd()
16189 
    oprot.writeFieldStop()
16190 
    oprot.writeStructEnd()
16191 
 
16192 
  def validate(self):
16193 
    return
16194 
 
16195 
 
16196 
  def __repr__(self):
16197 
    L = ['%s=%r' % (key, value)
16198 
      for key, value in self.__dict__.iteritems()]
16199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16200 
 
16201 
  def __eq__(self, other):
16202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16203 
 
16204 
  def __ne__(self, other):
16205 
    return not (self == other)
16206 
 
16207 
class markOrderAsReceivedAtStore_result:
16208 
  """
16209 
  Attributes:
16210 
   - ex
16211 
  """
16212 
 
16213 
  thrift_spec = (
16214 
    None, # 0
16215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16216 
  )
16217 
 
16218 
  def __init__(self, ex=None,):
16219 
    self.ex = ex
16220 
 
16221 
  def read(self, iprot):
16222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16224 
      return
16225 
    iprot.readStructBegin()
16226 
    while True:
16227 
      (fname, ftype, fid) = iprot.readFieldBegin()
16228 
      if ftype == TType.STOP:
16229 
        break
16230 
      if fid == 1:
16231 
        if ftype == TType.STRUCT:
16232 
          self.ex = TransactionServiceException()
16233 
          self.ex.read(iprot)
16234 
        else:
16235 
          iprot.skip(ftype)
16236 
      else:
16237 
        iprot.skip(ftype)
16238 
      iprot.readFieldEnd()
16239 
    iprot.readStructEnd()
16240 
 
16241 
  def write(self, oprot):
16242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16244 
      return
16245 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16246 
    if self.ex is not None:
16247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16248 
      self.ex.write(oprot)
16249 
      oprot.writeFieldEnd()
16250 
    oprot.writeFieldStop()
16251 
    oprot.writeStructEnd()
16252 
 
16253 
  def validate(self):
16254 
    return
16255 
 
16256 
 
16257 
  def __repr__(self):
16258 
    L = ['%s=%r' % (key, value)
16259 
      for key, value in self.__dict__.iteritems()]
16260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16261 
 
16262 
  def __eq__(self, other):
16263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16264 
 
16265 
  def __ne__(self, other):
16266 
    return not (self == other)
16267 
 
4454 rajveer 16268 
class markOrderDoaRequestReceived_args:
16269 
  """
16270 
  Attributes:
16271 
   - orderId
16272 
  """
16273 
 
16274 
  thrift_spec = (
16275 
    None, # 0
16276 
    (1, TType.I64, 'orderId', None, None, ), # 1
16277 
  )
16278 
 
16279 
  def __init__(self, orderId=None,):
16280 
    self.orderId = orderId
16281 
 
16282 
  def read(self, iprot):
16283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16285 
      return
16286 
    iprot.readStructBegin()
16287 
    while True:
16288 
      (fname, ftype, fid) = iprot.readFieldBegin()
16289 
      if ftype == TType.STOP:
16290 
        break
16291 
      if fid == 1:
16292 
        if ftype == TType.I64:
16293 
          self.orderId = iprot.readI64();
16294 
        else:
16295 
          iprot.skip(ftype)
16296 
      else:
16297 
        iprot.skip(ftype)
16298 
      iprot.readFieldEnd()
16299 
    iprot.readStructEnd()
16300 
 
16301 
  def write(self, oprot):
16302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16304 
      return
16305 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16306 
    if self.orderId is not None:
16307 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16308 
      oprot.writeI64(self.orderId)
16309 
      oprot.writeFieldEnd()
16310 
    oprot.writeFieldStop()
16311 
    oprot.writeStructEnd()
16312 
 
16313 
  def validate(self):
16314 
    return
16315 
 
16316 
 
16317 
  def __repr__(self):
16318 
    L = ['%s=%r' % (key, value)
16319 
      for key, value in self.__dict__.iteritems()]
16320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16321 
 
16322 
  def __eq__(self, other):
16323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16324 
 
16325 
  def __ne__(self, other):
16326 
    return not (self == other)
16327 
 
16328 
class markOrderDoaRequestReceived_result:
16329 
  """
16330 
  Attributes:
16331 
   - success
16332 
   - ex
16333 
  """
16334 
 
16335 
  thrift_spec = (
16336 
    (0, TType.BOOL, 'success', None, None, ), # 0
16337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16338 
  )
16339 
 
16340 
  def __init__(self, success=None, ex=None,):
16341 
    self.success = success
16342 
    self.ex = ex
16343 
 
16344 
  def read(self, iprot):
16345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16347 
      return
16348 
    iprot.readStructBegin()
16349 
    while True:
16350 
      (fname, ftype, fid) = iprot.readFieldBegin()
16351 
      if ftype == TType.STOP:
16352 
        break
16353 
      if fid == 0:
16354 
        if ftype == TType.BOOL:
16355 
          self.success = iprot.readBool();
16356 
        else:
16357 
          iprot.skip(ftype)
16358 
      elif fid == 1:
16359 
        if ftype == TType.STRUCT:
16360 
          self.ex = TransactionServiceException()
16361 
          self.ex.read(iprot)
16362 
        else:
16363 
          iprot.skip(ftype)
16364 
      else:
16365 
        iprot.skip(ftype)
16366 
      iprot.readFieldEnd()
16367 
    iprot.readStructEnd()
16368 
 
16369 
  def write(self, oprot):
16370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16372 
      return
16373 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16374 
    if self.success is not None:
16375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16376 
      oprot.writeBool(self.success)
16377 
      oprot.writeFieldEnd()
16378 
    if self.ex is not None:
16379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16380 
      self.ex.write(oprot)
16381 
      oprot.writeFieldEnd()
16382 
    oprot.writeFieldStop()
16383 
    oprot.writeStructEnd()
16384 
 
16385 
  def validate(self):
16386 
    return
16387 
 
16388 
 
16389 
  def __repr__(self):
16390 
    L = ['%s=%r' % (key, value)
16391 
      for key, value in self.__dict__.iteritems()]
16392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16393 
 
16394 
  def __eq__(self, other):
16395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16396 
 
16397 
  def __ne__(self, other):
16398 
    return not (self == other)
16399 
 
16400 
class markOrderDoaRequestAuthorized_args:
16401 
  """
16402 
  Attributes:
16403 
   - orderId
16404 
   - isAuthorized
16405 
  """
16406 
 
16407 
  thrift_spec = (
16408 
    None, # 0
16409 
    (1, TType.I64, 'orderId', None, None, ), # 1
16410 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16411 
  )
16412 
 
16413 
  def __init__(self, orderId=None, isAuthorized=None,):
16414 
    self.orderId = orderId
16415 
    self.isAuthorized = isAuthorized
16416 
 
16417 
  def read(self, iprot):
16418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16420 
      return
16421 
    iprot.readStructBegin()
16422 
    while True:
16423 
      (fname, ftype, fid) = iprot.readFieldBegin()
16424 
      if ftype == TType.STOP:
16425 
        break
16426 
      if fid == 1:
16427 
        if ftype == TType.I64:
16428 
          self.orderId = iprot.readI64();
16429 
        else:
16430 
          iprot.skip(ftype)
16431 
      elif fid == 2:
16432 
        if ftype == TType.BOOL:
16433 
          self.isAuthorized = iprot.readBool();
16434 
        else:
16435 
          iprot.skip(ftype)
16436 
      else:
16437 
        iprot.skip(ftype)
16438 
      iprot.readFieldEnd()
16439 
    iprot.readStructEnd()
16440 
 
16441 
  def write(self, oprot):
16442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16444 
      return
16445 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16446 
    if self.orderId is not None:
16447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16448 
      oprot.writeI64(self.orderId)
16449 
      oprot.writeFieldEnd()
16450 
    if self.isAuthorized is not None:
16451 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16452 
      oprot.writeBool(self.isAuthorized)
16453 
      oprot.writeFieldEnd()
16454 
    oprot.writeFieldStop()
16455 
    oprot.writeStructEnd()
16456 
 
16457 
  def validate(self):
16458 
    return
16459 
 
16460 
 
16461 
  def __repr__(self):
16462 
    L = ['%s=%r' % (key, value)
16463 
      for key, value in self.__dict__.iteritems()]
16464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16465 
 
16466 
  def __eq__(self, other):
16467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16468 
 
16469 
  def __ne__(self, other):
16470 
    return not (self == other)
16471 
 
16472 
class markOrderDoaRequestAuthorized_result:
16473 
  """
16474 
  Attributes:
16475 
   - success
16476 
   - ex
16477 
  """
16478 
 
16479 
  thrift_spec = (
16480 
    (0, TType.BOOL, 'success', None, None, ), # 0
16481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16482 
  )
16483 
 
16484 
  def __init__(self, success=None, ex=None,):
16485 
    self.success = success
16486 
    self.ex = ex
16487 
 
16488 
  def read(self, iprot):
16489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16491 
      return
16492 
    iprot.readStructBegin()
16493 
    while True:
16494 
      (fname, ftype, fid) = iprot.readFieldBegin()
16495 
      if ftype == TType.STOP:
16496 
        break
16497 
      if fid == 0:
16498 
        if ftype == TType.BOOL:
16499 
          self.success = iprot.readBool();
16500 
        else:
16501 
          iprot.skip(ftype)
16502 
      elif fid == 1:
16503 
        if ftype == TType.STRUCT:
16504 
          self.ex = TransactionServiceException()
16505 
          self.ex.read(iprot)
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('markOrderDoaRequestAuthorized_result')
16518 
    if self.success is not None:
16519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16520 
      oprot.writeBool(self.success)
16521 
      oprot.writeFieldEnd()
16522 
    if self.ex is not None:
16523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16524 
      self.ex.write(oprot)
16525 
      oprot.writeFieldEnd()
16526 
    oprot.writeFieldStop()
16527 
    oprot.writeStructEnd()
16528 
 
16529 
  def validate(self):
16530 
    return
16531 
 
16532 
 
16533 
  def __repr__(self):
16534 
    L = ['%s=%r' % (key, value)
16535 
      for key, value in self.__dict__.iteritems()]
16536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16537 
 
16538 
  def __eq__(self, other):
16539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16540 
 
16541 
  def __ne__(self, other):
16542 
    return not (self == other)
16543 
 
4488 rajveer 16544 
class markOrderReturnRequestReceived_args:
16545 
  """
16546 
  Attributes:
16547 
   - orderId
16548 
  """
16549 
 
16550 
  thrift_spec = (
16551 
    None, # 0
16552 
    (1, TType.I64, 'orderId', None, None, ), # 1
16553 
  )
16554 
 
16555 
  def __init__(self, orderId=None,):
16556 
    self.orderId = orderId
16557 
 
16558 
  def read(self, iprot):
16559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16561 
      return
16562 
    iprot.readStructBegin()
16563 
    while True:
16564 
      (fname, ftype, fid) = iprot.readFieldBegin()
16565 
      if ftype == TType.STOP:
16566 
        break
16567 
      if fid == 1:
16568 
        if ftype == TType.I64:
16569 
          self.orderId = iprot.readI64();
16570 
        else:
16571 
          iprot.skip(ftype)
16572 
      else:
16573 
        iprot.skip(ftype)
16574 
      iprot.readFieldEnd()
16575 
    iprot.readStructEnd()
16576 
 
16577 
  def write(self, oprot):
16578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16580 
      return
16581 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16582 
    if self.orderId is not None:
16583 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16584 
      oprot.writeI64(self.orderId)
16585 
      oprot.writeFieldEnd()
16586 
    oprot.writeFieldStop()
16587 
    oprot.writeStructEnd()
16588 
 
16589 
  def validate(self):
16590 
    return
16591 
 
16592 
 
16593 
  def __repr__(self):
16594 
    L = ['%s=%r' % (key, value)
16595 
      for key, value in self.__dict__.iteritems()]
16596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16597 
 
16598 
  def __eq__(self, other):
16599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16600 
 
16601 
  def __ne__(self, other):
16602 
    return not (self == other)
16603 
 
16604 
class markOrderReturnRequestReceived_result:
16605 
  """
16606 
  Attributes:
16607 
   - success
16608 
   - ex
16609 
  """
16610 
 
16611 
  thrift_spec = (
16612 
    (0, TType.BOOL, 'success', None, None, ), # 0
16613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16614 
  )
16615 
 
16616 
  def __init__(self, success=None, ex=None,):
16617 
    self.success = success
16618 
    self.ex = ex
16619 
 
16620 
  def read(self, iprot):
16621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16623 
      return
16624 
    iprot.readStructBegin()
16625 
    while True:
16626 
      (fname, ftype, fid) = iprot.readFieldBegin()
16627 
      if ftype == TType.STOP:
16628 
        break
16629 
      if fid == 0:
16630 
        if ftype == TType.BOOL:
16631 
          self.success = iprot.readBool();
16632 
        else:
16633 
          iprot.skip(ftype)
16634 
      elif fid == 1:
16635 
        if ftype == TType.STRUCT:
16636 
          self.ex = TransactionServiceException()
16637 
          self.ex.read(iprot)
16638 
        else:
16639 
          iprot.skip(ftype)
16640 
      else:
16641 
        iprot.skip(ftype)
16642 
      iprot.readFieldEnd()
16643 
    iprot.readStructEnd()
16644 
 
16645 
  def write(self, oprot):
16646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16648 
      return
16649 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16650 
    if self.success is not None:
16651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16652 
      oprot.writeBool(self.success)
16653 
      oprot.writeFieldEnd()
16654 
    if self.ex is not None:
16655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16656 
      self.ex.write(oprot)
16657 
      oprot.writeFieldEnd()
16658 
    oprot.writeFieldStop()
16659 
    oprot.writeStructEnd()
16660 
 
16661 
  def validate(self):
16662 
    return
16663 
 
16664 
 
16665 
  def __repr__(self):
16666 
    L = ['%s=%r' % (key, value)
16667 
      for key, value in self.__dict__.iteritems()]
16668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16669 
 
16670 
  def __eq__(self, other):
16671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16672 
 
16673 
  def __ne__(self, other):
16674 
    return not (self == other)
16675 
 
16676 
class markOrderReturnRequestAuthorized_args:
16677 
  """
16678 
  Attributes:
16679 
   - orderId
16680 
   - isAuthorized
16681 
  """
16682 
 
16683 
  thrift_spec = (
16684 
    None, # 0
16685 
    (1, TType.I64, 'orderId', None, None, ), # 1
16686 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16687 
  )
16688 
 
16689 
  def __init__(self, orderId=None, isAuthorized=None,):
16690 
    self.orderId = orderId
16691 
    self.isAuthorized = isAuthorized
16692 
 
16693 
  def read(self, iprot):
16694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16696 
      return
16697 
    iprot.readStructBegin()
16698 
    while True:
16699 
      (fname, ftype, fid) = iprot.readFieldBegin()
16700 
      if ftype == TType.STOP:
16701 
        break
16702 
      if fid == 1:
16703 
        if ftype == TType.I64:
16704 
          self.orderId = iprot.readI64();
16705 
        else:
16706 
          iprot.skip(ftype)
16707 
      elif fid == 2:
16708 
        if ftype == TType.BOOL:
16709 
          self.isAuthorized = iprot.readBool();
16710 
        else:
16711 
          iprot.skip(ftype)
16712 
      else:
16713 
        iprot.skip(ftype)
16714 
      iprot.readFieldEnd()
16715 
    iprot.readStructEnd()
16716 
 
16717 
  def write(self, oprot):
16718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16720 
      return
16721 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16722 
    if self.orderId is not None:
16723 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16724 
      oprot.writeI64(self.orderId)
16725 
      oprot.writeFieldEnd()
16726 
    if self.isAuthorized is not None:
16727 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16728 
      oprot.writeBool(self.isAuthorized)
16729 
      oprot.writeFieldEnd()
16730 
    oprot.writeFieldStop()
16731 
    oprot.writeStructEnd()
16732 
 
16733 
  def validate(self):
16734 
    return
16735 
 
16736 
 
16737 
  def __repr__(self):
16738 
    L = ['%s=%r' % (key, value)
16739 
      for key, value in self.__dict__.iteritems()]
16740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16741 
 
16742 
  def __eq__(self, other):
16743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16744 
 
16745 
  def __ne__(self, other):
16746 
    return not (self == other)
16747 
 
16748 
class markOrderReturnRequestAuthorized_result:
16749 
  """
16750 
  Attributes:
16751 
   - success
16752 
   - ex
16753 
  """
16754 
 
16755 
  thrift_spec = (
16756 
    (0, TType.BOOL, 'success', None, None, ), # 0
16757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16758 
  )
16759 
 
16760 
  def __init__(self, success=None, ex=None,):
16761 
    self.success = success
16762 
    self.ex = ex
16763 
 
16764 
  def read(self, iprot):
16765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16767 
      return
16768 
    iprot.readStructBegin()
16769 
    while True:
16770 
      (fname, ftype, fid) = iprot.readFieldBegin()
16771 
      if ftype == TType.STOP:
16772 
        break
16773 
      if fid == 0:
16774 
        if ftype == TType.BOOL:
16775 
          self.success = iprot.readBool();
16776 
        else:
16777 
          iprot.skip(ftype)
16778 
      elif fid == 1:
16779 
        if ftype == TType.STRUCT:
16780 
          self.ex = TransactionServiceException()
16781 
          self.ex.read(iprot)
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      else:
16785 
        iprot.skip(ftype)
16786 
      iprot.readFieldEnd()
16787 
    iprot.readStructEnd()
16788 
 
16789 
  def write(self, oprot):
16790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16792 
      return
16793 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16794 
    if self.success is not None:
16795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16796 
      oprot.writeBool(self.success)
16797 
      oprot.writeFieldEnd()
16798 
    if self.ex is not None:
16799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16800 
      self.ex.write(oprot)
16801 
      oprot.writeFieldEnd()
16802 
    oprot.writeFieldStop()
16803 
    oprot.writeStructEnd()
16804 
 
16805 
  def validate(self):
16806 
    return
16807 
 
16808 
 
16809 
  def __repr__(self):
16810 
    L = ['%s=%r' % (key, value)
16811 
      for key, value in self.__dict__.iteritems()]
16812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16813 
 
16814 
  def __eq__(self, other):
16815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16816 
 
16817 
  def __ne__(self, other):
16818 
    return not (self == other)
16819 
 
2536 chandransh 16820 
class requestPickupNumber_args:
16821 
  """
16822 
  Attributes:
16823 
   - orderId
4579 rajveer 16824 
   - providerId
2536 chandransh 16825 
  """
16826 
 
16827 
  thrift_spec = (
16828 
    None, # 0
16829 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16830 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16831 
  )
16832 
 
4579 rajveer 16833 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16834 
    self.orderId = orderId
4579 rajveer 16835 
    self.providerId = providerId
2536 chandransh 16836 
 
16837 
  def read(self, iprot):
16838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16840 
      return
16841 
    iprot.readStructBegin()
16842 
    while True:
16843 
      (fname, ftype, fid) = iprot.readFieldBegin()
16844 
      if ftype == TType.STOP:
16845 
        break
16846 
      if fid == 1:
16847 
        if ftype == TType.I64:
16848 
          self.orderId = iprot.readI64();
16849 
        else:
16850 
          iprot.skip(ftype)
4579 rajveer 16851 
      elif fid == 2:
16852 
        if ftype == TType.I64:
16853 
          self.providerId = iprot.readI64();
16854 
        else:
16855 
          iprot.skip(ftype)
2536 chandransh 16856 
      else:
16857 
        iprot.skip(ftype)
16858 
      iprot.readFieldEnd()
16859 
    iprot.readStructEnd()
16860 
 
16861 
  def write(self, oprot):
16862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16864 
      return
16865 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16866 
    if self.orderId is not None:
2536 chandransh 16867 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16868 
      oprot.writeI64(self.orderId)
16869 
      oprot.writeFieldEnd()
4579 rajveer 16870 
    if self.providerId is not None:
16871 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16872 
      oprot.writeI64(self.providerId)
16873 
      oprot.writeFieldEnd()
2536 chandransh 16874 
    oprot.writeFieldStop()
16875 
    oprot.writeStructEnd()
16876 
 
3431 rajveer 16877 
  def validate(self):
16878 
    return
16879 
 
16880 
 
2536 chandransh 16881 
  def __repr__(self):
16882 
    L = ['%s=%r' % (key, value)
16883 
      for key, value in self.__dict__.iteritems()]
16884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16885 
 
16886 
  def __eq__(self, other):
16887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16888 
 
16889 
  def __ne__(self, other):
16890 
    return not (self == other)
16891 
 
16892 
class requestPickupNumber_result:
16893 
  """
16894 
  Attributes:
16895 
   - success
16896 
   - ex
16897 
  """
16898 
 
16899 
  thrift_spec = (
16900 
    (0, TType.BOOL, 'success', None, None, ), # 0
16901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16902 
  )
16903 
 
16904 
  def __init__(self, success=None, ex=None,):
16905 
    self.success = success
16906 
    self.ex = ex
16907 
 
16908 
  def read(self, iprot):
16909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16911 
      return
16912 
    iprot.readStructBegin()
16913 
    while True:
16914 
      (fname, ftype, fid) = iprot.readFieldBegin()
16915 
      if ftype == TType.STOP:
16916 
        break
16917 
      if fid == 0:
16918 
        if ftype == TType.BOOL:
16919 
          self.success = iprot.readBool();
16920 
        else:
16921 
          iprot.skip(ftype)
16922 
      elif fid == 1:
16923 
        if ftype == TType.STRUCT:
16924 
          self.ex = TransactionServiceException()
16925 
          self.ex.read(iprot)
16926 
        else:
16927 
          iprot.skip(ftype)
16928 
      else:
16929 
        iprot.skip(ftype)
16930 
      iprot.readFieldEnd()
16931 
    iprot.readStructEnd()
16932 
 
16933 
  def write(self, oprot):
16934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16936 
      return
16937 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16938 
    if self.success is not None:
2536 chandransh 16939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16940 
      oprot.writeBool(self.success)
16941 
      oprot.writeFieldEnd()
3431 rajveer 16942 
    if self.ex is not None:
2536 chandransh 16943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16944 
      self.ex.write(oprot)
16945 
      oprot.writeFieldEnd()
16946 
    oprot.writeFieldStop()
16947 
    oprot.writeStructEnd()
16948 
 
3431 rajveer 16949 
  def validate(self):
16950 
    return
16951 
 
16952 
 
2536 chandransh 16953 
  def __repr__(self):
16954 
    L = ['%s=%r' % (key, value)
16955 
      for key, value in self.__dict__.iteritems()]
16956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16957 
 
16958 
  def __eq__(self, other):
16959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16960 
 
16961 
  def __ne__(self, other):
16962 
    return not (self == other)
16963 
 
16964 
class authorizePickup_args:
16965 
  """
16966 
  Attributes:
16967 
   - orderId
16968 
   - pickupNumber
4602 rajveer 16969 
   - providerId
2536 chandransh 16970 
  """
16971 
 
16972 
  thrift_spec = (
16973 
    None, # 0
16974 
    (1, TType.I64, 'orderId', None, None, ), # 1
16975 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16976 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16977 
  )
16978 
 
4602 rajveer 16979 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16980 
    self.orderId = orderId
16981 
    self.pickupNumber = pickupNumber
4602 rajveer 16982 
    self.providerId = providerId
2536 chandransh 16983 
 
16984 
  def read(self, iprot):
16985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16987 
      return
16988 
    iprot.readStructBegin()
16989 
    while True:
16990 
      (fname, ftype, fid) = iprot.readFieldBegin()
16991 
      if ftype == TType.STOP:
16992 
        break
16993 
      if fid == 1:
16994 
        if ftype == TType.I64:
16995 
          self.orderId = iprot.readI64();
16996 
        else:
16997 
          iprot.skip(ftype)
16998 
      elif fid == 2:
16999 
        if ftype == TType.STRING:
17000 
          self.pickupNumber = iprot.readString();
17001 
        else:
17002 
          iprot.skip(ftype)
4602 rajveer 17003 
      elif fid == 3:
17004 
        if ftype == TType.I64:
17005 
          self.providerId = iprot.readI64();
17006 
        else:
17007 
          iprot.skip(ftype)
2536 chandransh 17008 
      else:
17009 
        iprot.skip(ftype)
17010 
      iprot.readFieldEnd()
17011 
    iprot.readStructEnd()
17012 
 
17013 
  def write(self, oprot):
17014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17016 
      return
17017 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17018 
    if self.orderId is not None:
2536 chandransh 17019 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17020 
      oprot.writeI64(self.orderId)
17021 
      oprot.writeFieldEnd()
3431 rajveer 17022 
    if self.pickupNumber is not None:
2536 chandransh 17023 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17024 
      oprot.writeString(self.pickupNumber)
17025 
      oprot.writeFieldEnd()
4602 rajveer 17026 
    if self.providerId is not None:
17027 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17028 
      oprot.writeI64(self.providerId)
17029 
      oprot.writeFieldEnd()
2536 chandransh 17030 
    oprot.writeFieldStop()
17031 
    oprot.writeStructEnd()
17032 
 
3431 rajveer 17033 
  def validate(self):
17034 
    return
17035 
 
17036 
 
2536 chandransh 17037 
  def __repr__(self):
17038 
    L = ['%s=%r' % (key, value)
17039 
      for key, value in self.__dict__.iteritems()]
17040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17041 
 
17042 
  def __eq__(self, other):
17043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17044 
 
17045 
  def __ne__(self, other):
17046 
    return not (self == other)
17047 
 
17048 
class authorizePickup_result:
17049 
  """
17050 
  Attributes:
17051 
   - success
17052 
   - ex
17053 
  """
17054 
 
17055 
  thrift_spec = (
17056 
    (0, TType.BOOL, 'success', None, None, ), # 0
17057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17058 
  )
17059 
 
17060 
  def __init__(self, success=None, ex=None,):
17061 
    self.success = success
17062 
    self.ex = ex
17063 
 
17064 
  def read(self, iprot):
17065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17067 
      return
17068 
    iprot.readStructBegin()
17069 
    while True:
17070 
      (fname, ftype, fid) = iprot.readFieldBegin()
17071 
      if ftype == TType.STOP:
17072 
        break
17073 
      if fid == 0:
17074 
        if ftype == TType.BOOL:
17075 
          self.success = iprot.readBool();
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      elif fid == 1:
17079 
        if ftype == TType.STRUCT:
17080 
          self.ex = TransactionServiceException()
17081 
          self.ex.read(iprot)
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      else:
17085 
        iprot.skip(ftype)
17086 
      iprot.readFieldEnd()
17087 
    iprot.readStructEnd()
17088 
 
17089 
  def write(self, oprot):
17090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17092 
      return
17093 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17094 
    if self.success is not None:
2536 chandransh 17095 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17096 
      oprot.writeBool(self.success)
17097 
      oprot.writeFieldEnd()
3431 rajveer 17098 
    if self.ex is not None:
2536 chandransh 17099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17100 
      self.ex.write(oprot)
17101 
      oprot.writeFieldEnd()
17102 
    oprot.writeFieldStop()
17103 
    oprot.writeStructEnd()
17104 
 
3431 rajveer 17105 
  def validate(self):
17106 
    return
17107 
 
17108 
 
2536 chandransh 17109 
  def __repr__(self):
17110 
    L = ['%s=%r' % (key, value)
17111 
      for key, value in self.__dict__.iteritems()]
17112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17113 
 
17114 
  def __eq__(self, other):
17115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17116 
 
17117 
  def __ne__(self, other):
17118 
    return not (self == other)
17119 
 
2764 chandransh 17120 
class markDoasAsPickedUp_args:
17121 
  """
17122 
  Attributes:
17123 
   - providerId
17124 
   - pickupDetails
17125 
  """
17126 
 
17127 
  thrift_spec = (
17128 
    None, # 0
17129 
    (1, TType.I64, 'providerId', None, None, ), # 1
17130 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17131 
  )
17132 
 
17133 
  def __init__(self, providerId=None, pickupDetails=None,):
17134 
    self.providerId = providerId
17135 
    self.pickupDetails = pickupDetails
17136 
 
17137 
  def read(self, iprot):
17138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17140 
      return
17141 
    iprot.readStructBegin()
17142 
    while True:
17143 
      (fname, ftype, fid) = iprot.readFieldBegin()
17144 
      if ftype == TType.STOP:
17145 
        break
17146 
      if fid == 1:
17147 
        if ftype == TType.I64:
17148 
          self.providerId = iprot.readI64();
17149 
        else:
17150 
          iprot.skip(ftype)
17151 
      elif fid == 2:
17152 
        if ftype == TType.MAP:
17153 
          self.pickupDetails = {}
6188 rajveer 17154 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17155 
          for _i411 in xrange(_size407):
17156 
            _key412 = iprot.readString();
17157 
            _val413 = iprot.readString();
17158 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17159 
          iprot.readMapEnd()
17160 
        else:
17161 
          iprot.skip(ftype)
17162 
      else:
17163 
        iprot.skip(ftype)
17164 
      iprot.readFieldEnd()
17165 
    iprot.readStructEnd()
17166 
 
17167 
  def write(self, oprot):
17168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17170 
      return
17171 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17172 
    if self.providerId is not None:
2764 chandransh 17173 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17174 
      oprot.writeI64(self.providerId)
17175 
      oprot.writeFieldEnd()
3431 rajveer 17176 
    if self.pickupDetails is not None:
2764 chandransh 17177 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17178 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17179 
      for kiter414,viter415 in self.pickupDetails.items():
17180 
        oprot.writeString(kiter414)
17181 
        oprot.writeString(viter415)
2764 chandransh 17182 
      oprot.writeMapEnd()
17183 
      oprot.writeFieldEnd()
17184 
    oprot.writeFieldStop()
17185 
    oprot.writeStructEnd()
17186 
 
3431 rajveer 17187 
  def validate(self):
17188 
    return
17189 
 
17190 
 
2764 chandransh 17191 
  def __repr__(self):
17192 
    L = ['%s=%r' % (key, value)
17193 
      for key, value in self.__dict__.iteritems()]
17194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17195 
 
17196 
  def __eq__(self, other):
17197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17198 
 
17199 
  def __ne__(self, other):
17200 
    return not (self == other)
17201 
 
17202 
class markDoasAsPickedUp_result:
4910 phani.kuma 17203 
 
17204 
  thrift_spec = (
17205 
  )
17206 
 
17207 
  def read(self, iprot):
17208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17210 
      return
17211 
    iprot.readStructBegin()
17212 
    while True:
17213 
      (fname, ftype, fid) = iprot.readFieldBegin()
17214 
      if ftype == TType.STOP:
17215 
        break
17216 
      else:
17217 
        iprot.skip(ftype)
17218 
      iprot.readFieldEnd()
17219 
    iprot.readStructEnd()
17220 
 
17221 
  def write(self, oprot):
17222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17224 
      return
17225 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17226 
    oprot.writeFieldStop()
17227 
    oprot.writeStructEnd()
17228 
 
17229 
  def validate(self):
17230 
    return
17231 
 
17232 
 
17233 
  def __repr__(self):
17234 
    L = ['%s=%r' % (key, value)
17235 
      for key, value in self.__dict__.iteritems()]
17236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17237 
 
17238 
  def __eq__(self, other):
17239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17240 
 
17241 
  def __ne__(self, other):
17242 
    return not (self == other)
17243 
 
17244 
class getDoasNotPickedUp_args:
2764 chandransh 17245 
  """
17246 
  Attributes:
4910 phani.kuma 17247 
   - providerId
17248 
  """
17249 
 
17250 
  thrift_spec = (
17251 
    None, # 0
17252 
    (1, TType.I64, 'providerId', None, None, ), # 1
17253 
  )
17254 
 
17255 
  def __init__(self, providerId=None,):
17256 
    self.providerId = providerId
17257 
 
17258 
  def read(self, iprot):
17259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17261 
      return
17262 
    iprot.readStructBegin()
17263 
    while True:
17264 
      (fname, ftype, fid) = iprot.readFieldBegin()
17265 
      if ftype == TType.STOP:
17266 
        break
17267 
      if fid == 1:
17268 
        if ftype == TType.I64:
17269 
          self.providerId = iprot.readI64();
17270 
        else:
17271 
          iprot.skip(ftype)
17272 
      else:
17273 
        iprot.skip(ftype)
17274 
      iprot.readFieldEnd()
17275 
    iprot.readStructEnd()
17276 
 
17277 
  def write(self, oprot):
17278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17280 
      return
17281 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17282 
    if self.providerId is not None:
17283 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17284 
      oprot.writeI64(self.providerId)
17285 
      oprot.writeFieldEnd()
17286 
    oprot.writeFieldStop()
17287 
    oprot.writeStructEnd()
17288 
 
17289 
  def validate(self):
17290 
    return
17291 
 
17292 
 
17293 
  def __repr__(self):
17294 
    L = ['%s=%r' % (key, value)
17295 
      for key, value in self.__dict__.iteritems()]
17296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17297 
 
17298 
  def __eq__(self, other):
17299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17300 
 
17301 
  def __ne__(self, other):
17302 
    return not (self == other)
17303 
 
17304 
class getDoasNotPickedUp_result:
17305 
  """
17306 
  Attributes:
2764 chandransh 17307 
   - success
17308 
  """
17309 
 
17310 
  thrift_spec = (
17311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17312 
  )
17313 
 
17314 
  def __init__(self, success=None,):
17315 
    self.success = success
17316 
 
17317 
  def read(self, iprot):
17318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17320 
      return
17321 
    iprot.readStructBegin()
17322 
    while True:
17323 
      (fname, ftype, fid) = iprot.readFieldBegin()
17324 
      if ftype == TType.STOP:
17325 
        break
17326 
      if fid == 0:
17327 
        if ftype == TType.LIST:
17328 
          self.success = []
6188 rajveer 17329 
          (_etype419, _size416) = iprot.readListBegin()
17330 
          for _i420 in xrange(_size416):
17331 
            _elem421 = Order()
17332 
            _elem421.read(iprot)
17333 
            self.success.append(_elem421)
2764 chandransh 17334 
          iprot.readListEnd()
17335 
        else:
17336 
          iprot.skip(ftype)
17337 
      else:
17338 
        iprot.skip(ftype)
17339 
      iprot.readFieldEnd()
17340 
    iprot.readStructEnd()
17341 
 
17342 
  def write(self, oprot):
17343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17345 
      return
4910 phani.kuma 17346 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17347 
    if self.success is not None:
2764 chandransh 17348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17350 
      for iter422 in self.success:
17351 
        iter422.write(oprot)
2764 chandransh 17352 
      oprot.writeListEnd()
17353 
      oprot.writeFieldEnd()
17354 
    oprot.writeFieldStop()
17355 
    oprot.writeStructEnd()
17356 
 
3431 rajveer 17357 
  def validate(self):
17358 
    return
17359 
 
17360 
 
2764 chandransh 17361 
  def __repr__(self):
17362 
    L = ['%s=%r' % (key, value)
17363 
      for key, value in self.__dict__.iteritems()]
17364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17365 
 
17366 
  def __eq__(self, other):
17367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17368 
 
17369 
  def __ne__(self, other):
17370 
    return not (self == other)
17371 
 
4741 phani.kuma 17372 
class markReturnOrdersAsPickedUp_args:
17373 
  """
17374 
  Attributes:
17375 
   - providerId
17376 
   - pickupDetails
17377 
  """
17378 
 
17379 
  thrift_spec = (
17380 
    None, # 0
17381 
    (1, TType.I64, 'providerId', None, None, ), # 1
17382 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17383 
  )
17384 
 
17385 
  def __init__(self, providerId=None, pickupDetails=None,):
17386 
    self.providerId = providerId
17387 
    self.pickupDetails = pickupDetails
17388 
 
17389 
  def read(self, iprot):
17390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17392 
      return
17393 
    iprot.readStructBegin()
17394 
    while True:
17395 
      (fname, ftype, fid) = iprot.readFieldBegin()
17396 
      if ftype == TType.STOP:
17397 
        break
17398 
      if fid == 1:
17399 
        if ftype == TType.I64:
17400 
          self.providerId = iprot.readI64();
17401 
        else:
17402 
          iprot.skip(ftype)
17403 
      elif fid == 2:
17404 
        if ftype == TType.MAP:
17405 
          self.pickupDetails = {}
6188 rajveer 17406 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17407 
          for _i427 in xrange(_size423):
17408 
            _key428 = iprot.readString();
17409 
            _val429 = iprot.readString();
17410 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17411 
          iprot.readMapEnd()
17412 
        else:
17413 
          iprot.skip(ftype)
17414 
      else:
17415 
        iprot.skip(ftype)
17416 
      iprot.readFieldEnd()
17417 
    iprot.readStructEnd()
17418 
 
17419 
  def write(self, oprot):
17420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17422 
      return
17423 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17424 
    if self.providerId is not None:
17425 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17426 
      oprot.writeI64(self.providerId)
17427 
      oprot.writeFieldEnd()
17428 
    if self.pickupDetails is not None:
17429 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17430 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17431 
      for kiter430,viter431 in self.pickupDetails.items():
17432 
        oprot.writeString(kiter430)
17433 
        oprot.writeString(viter431)
4741 phani.kuma 17434 
      oprot.writeMapEnd()
17435 
      oprot.writeFieldEnd()
17436 
    oprot.writeFieldStop()
17437 
    oprot.writeStructEnd()
17438 
 
17439 
  def validate(self):
17440 
    return
17441 
 
17442 
 
17443 
  def __repr__(self):
17444 
    L = ['%s=%r' % (key, value)
17445 
      for key, value in self.__dict__.iteritems()]
17446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17447 
 
17448 
  def __eq__(self, other):
17449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17450 
 
17451 
  def __ne__(self, other):
17452 
    return not (self == other)
17453 
 
17454 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17455 
 
17456 
  thrift_spec = (
17457 
  )
17458 
 
17459 
  def read(self, iprot):
17460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17462 
      return
17463 
    iprot.readStructBegin()
17464 
    while True:
17465 
      (fname, ftype, fid) = iprot.readFieldBegin()
17466 
      if ftype == TType.STOP:
17467 
        break
17468 
      else:
17469 
        iprot.skip(ftype)
17470 
      iprot.readFieldEnd()
17471 
    iprot.readStructEnd()
17472 
 
17473 
  def write(self, oprot):
17474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17476 
      return
17477 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17478 
    oprot.writeFieldStop()
17479 
    oprot.writeStructEnd()
17480 
 
17481 
  def validate(self):
17482 
    return
17483 
 
17484 
 
17485 
  def __repr__(self):
17486 
    L = ['%s=%r' % (key, value)
17487 
      for key, value in self.__dict__.iteritems()]
17488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17489 
 
17490 
  def __eq__(self, other):
17491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17492 
 
17493 
  def __ne__(self, other):
17494 
    return not (self == other)
17495 
 
17496 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17497 
  """
17498 
  Attributes:
4910 phani.kuma 17499 
   - providerId
17500 
  """
17501 
 
17502 
  thrift_spec = (
17503 
    None, # 0
17504 
    (1, TType.I64, 'providerId', None, None, ), # 1
17505 
  )
17506 
 
17507 
  def __init__(self, providerId=None,):
17508 
    self.providerId = providerId
17509 
 
17510 
  def read(self, iprot):
17511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17513 
      return
17514 
    iprot.readStructBegin()
17515 
    while True:
17516 
      (fname, ftype, fid) = iprot.readFieldBegin()
17517 
      if ftype == TType.STOP:
17518 
        break
17519 
      if fid == 1:
17520 
        if ftype == TType.I64:
17521 
          self.providerId = iprot.readI64();
17522 
        else:
17523 
          iprot.skip(ftype)
17524 
      else:
17525 
        iprot.skip(ftype)
17526 
      iprot.readFieldEnd()
17527 
    iprot.readStructEnd()
17528 
 
17529 
  def write(self, oprot):
17530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17532 
      return
17533 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17534 
    if self.providerId is not None:
17535 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17536 
      oprot.writeI64(self.providerId)
17537 
      oprot.writeFieldEnd()
17538 
    oprot.writeFieldStop()
17539 
    oprot.writeStructEnd()
17540 
 
17541 
  def validate(self):
17542 
    return
17543 
 
17544 
 
17545 
  def __repr__(self):
17546 
    L = ['%s=%r' % (key, value)
17547 
      for key, value in self.__dict__.iteritems()]
17548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17549 
 
17550 
  def __eq__(self, other):
17551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17552 
 
17553 
  def __ne__(self, other):
17554 
    return not (self == other)
17555 
 
17556 
class getReturnOrdersNotPickedUp_result:
17557 
  """
17558 
  Attributes:
4741 phani.kuma 17559 
   - success
17560 
  """
17561 
 
17562 
  thrift_spec = (
17563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17564 
  )
17565 
 
17566 
  def __init__(self, success=None,):
17567 
    self.success = success
17568 
 
17569 
  def read(self, iprot):
17570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17572 
      return
17573 
    iprot.readStructBegin()
17574 
    while True:
17575 
      (fname, ftype, fid) = iprot.readFieldBegin()
17576 
      if ftype == TType.STOP:
17577 
        break
17578 
      if fid == 0:
17579 
        if ftype == TType.LIST:
17580 
          self.success = []
6188 rajveer 17581 
          (_etype435, _size432) = iprot.readListBegin()
17582 
          for _i436 in xrange(_size432):
17583 
            _elem437 = Order()
17584 
            _elem437.read(iprot)
17585 
            self.success.append(_elem437)
4741 phani.kuma 17586 
          iprot.readListEnd()
17587 
        else:
17588 
          iprot.skip(ftype)
17589 
      else:
17590 
        iprot.skip(ftype)
17591 
      iprot.readFieldEnd()
17592 
    iprot.readStructEnd()
17593 
 
17594 
  def write(self, oprot):
17595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17597 
      return
4910 phani.kuma 17598 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17599 
    if self.success is not None:
17600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17602 
      for iter438 in self.success:
17603 
        iter438.write(oprot)
4741 phani.kuma 17604 
      oprot.writeListEnd()
17605 
      oprot.writeFieldEnd()
17606 
    oprot.writeFieldStop()
17607 
    oprot.writeStructEnd()
17608 
 
17609 
  def validate(self):
17610 
    return
17611 
 
17612 
 
17613 
  def __repr__(self):
17614 
    L = ['%s=%r' % (key, value)
17615 
      for key, value in self.__dict__.iteritems()]
17616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17617 
 
17618 
  def __eq__(self, other):
17619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17620 
 
17621 
  def __ne__(self, other):
17622 
    return not (self == other)
17623 
 
2616 chandransh 17624 
class receiveReturn_args:
2591 chandransh 17625 
  """
17626 
  Attributes:
17627 
   - orderId
4479 rajveer 17628 
   - receiveCondition
2591 chandransh 17629 
  """
2536 chandransh 17630 
 
2591 chandransh 17631 
  thrift_spec = (
17632 
    None, # 0
17633 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17634 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17635 
  )
17636 
 
4479 rajveer 17637 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17638 
    self.orderId = orderId
4479 rajveer 17639 
    self.receiveCondition = receiveCondition
2591 chandransh 17640 
 
17641 
  def read(self, iprot):
17642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17644 
      return
17645 
    iprot.readStructBegin()
17646 
    while True:
17647 
      (fname, ftype, fid) = iprot.readFieldBegin()
17648 
      if ftype == TType.STOP:
17649 
        break
17650 
      if fid == 1:
17651 
        if ftype == TType.I64:
17652 
          self.orderId = iprot.readI64();
17653 
        else:
17654 
          iprot.skip(ftype)
4479 rajveer 17655 
      elif fid == 2:
17656 
        if ftype == TType.I64:
17657 
          self.receiveCondition = iprot.readI64();
17658 
        else:
17659 
          iprot.skip(ftype)
2591 chandransh 17660 
      else:
17661 
        iprot.skip(ftype)
17662 
      iprot.readFieldEnd()
17663 
    iprot.readStructEnd()
17664 
 
17665 
  def write(self, oprot):
17666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17668 
      return
2616 chandransh 17669 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17670 
    if self.orderId is not None:
2591 chandransh 17671 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17672 
      oprot.writeI64(self.orderId)
17673 
      oprot.writeFieldEnd()
4479 rajveer 17674 
    if self.receiveCondition is not None:
17675 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17676 
      oprot.writeI64(self.receiveCondition)
17677 
      oprot.writeFieldEnd()
2591 chandransh 17678 
    oprot.writeFieldStop()
17679 
    oprot.writeStructEnd()
17680 
 
3431 rajveer 17681 
  def validate(self):
17682 
    return
17683 
 
17684 
 
2591 chandransh 17685 
  def __repr__(self):
17686 
    L = ['%s=%r' % (key, value)
17687 
      for key, value in self.__dict__.iteritems()]
17688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17689 
 
17690 
  def __eq__(self, other):
17691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17692 
 
17693 
  def __ne__(self, other):
17694 
    return not (self == other)
17695 
 
2616 chandransh 17696 
class receiveReturn_result:
2591 chandransh 17697 
  """
17698 
  Attributes:
17699 
   - success
17700 
   - ex
17701 
  """
17702 
 
17703 
  thrift_spec = (
17704 
    (0, TType.BOOL, 'success', None, None, ), # 0
17705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17706 
  )
17707 
 
17708 
  def __init__(self, success=None, ex=None,):
17709 
    self.success = success
17710 
    self.ex = ex
17711 
 
17712 
  def read(self, iprot):
17713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17715 
      return
17716 
    iprot.readStructBegin()
17717 
    while True:
17718 
      (fname, ftype, fid) = iprot.readFieldBegin()
17719 
      if ftype == TType.STOP:
17720 
        break
17721 
      if fid == 0:
17722 
        if ftype == TType.BOOL:
17723 
          self.success = iprot.readBool();
17724 
        else:
17725 
          iprot.skip(ftype)
17726 
      elif fid == 1:
17727 
        if ftype == TType.STRUCT:
17728 
          self.ex = TransactionServiceException()
17729 
          self.ex.read(iprot)
17730 
        else:
17731 
          iprot.skip(ftype)
17732 
      else:
17733 
        iprot.skip(ftype)
17734 
      iprot.readFieldEnd()
17735 
    iprot.readStructEnd()
17736 
 
17737 
  def write(self, oprot):
17738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17740 
      return
2616 chandransh 17741 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17742 
    if self.success is not None:
2591 chandransh 17743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17744 
      oprot.writeBool(self.success)
17745 
      oprot.writeFieldEnd()
3431 rajveer 17746 
    if self.ex is not None:
2591 chandransh 17747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17748 
      self.ex.write(oprot)
17749 
      oprot.writeFieldEnd()
17750 
    oprot.writeFieldStop()
17751 
    oprot.writeStructEnd()
17752 
 
3431 rajveer 17753 
  def validate(self):
17754 
    return
17755 
 
17756 
 
2591 chandransh 17757 
  def __repr__(self):
17758 
    L = ['%s=%r' % (key, value)
17759 
      for key, value in self.__dict__.iteritems()]
17760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17761 
 
17762 
  def __eq__(self, other):
17763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17764 
 
17765 
  def __ne__(self, other):
17766 
    return not (self == other)
17767 
 
17768 
class validateDoa_args:
17769 
  """
17770 
  Attributes:
17771 
   - orderId
17772 
   - isValid
17773 
  """
17774 
 
17775 
  thrift_spec = (
17776 
    None, # 0
17777 
    (1, TType.I64, 'orderId', None, None, ), # 1
17778 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17779 
  )
17780 
 
17781 
  def __init__(self, orderId=None, isValid=None,):
17782 
    self.orderId = orderId
17783 
    self.isValid = isValid
17784 
 
17785 
  def read(self, iprot):
17786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17788 
      return
17789 
    iprot.readStructBegin()
17790 
    while True:
17791 
      (fname, ftype, fid) = iprot.readFieldBegin()
17792 
      if ftype == TType.STOP:
17793 
        break
17794 
      if fid == 1:
17795 
        if ftype == TType.I64:
17796 
          self.orderId = iprot.readI64();
17797 
        else:
17798 
          iprot.skip(ftype)
17799 
      elif fid == 2:
17800 
        if ftype == TType.BOOL:
17801 
          self.isValid = iprot.readBool();
17802 
        else:
17803 
          iprot.skip(ftype)
17804 
      else:
17805 
        iprot.skip(ftype)
17806 
      iprot.readFieldEnd()
17807 
    iprot.readStructEnd()
17808 
 
17809 
  def write(self, oprot):
17810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17812 
      return
17813 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17814 
    if self.orderId is not None:
2591 chandransh 17815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17816 
      oprot.writeI64(self.orderId)
17817 
      oprot.writeFieldEnd()
3431 rajveer 17818 
    if self.isValid is not None:
2591 chandransh 17819 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17820 
      oprot.writeBool(self.isValid)
17821 
      oprot.writeFieldEnd()
17822 
    oprot.writeFieldStop()
17823 
    oprot.writeStructEnd()
17824 
 
3431 rajveer 17825 
  def validate(self):
17826 
    return
17827 
 
17828 
 
2591 chandransh 17829 
  def __repr__(self):
17830 
    L = ['%s=%r' % (key, value)
17831 
      for key, value in self.__dict__.iteritems()]
17832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17833 
 
17834 
  def __eq__(self, other):
17835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17836 
 
17837 
  def __ne__(self, other):
17838 
    return not (self == other)
17839 
 
17840 
class validateDoa_result:
17841 
  """
17842 
  Attributes:
17843 
   - success
17844 
   - ex
17845 
  """
17846 
 
17847 
  thrift_spec = (
17848 
    (0, TType.BOOL, 'success', None, None, ), # 0
17849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17850 
  )
17851 
 
17852 
  def __init__(self, success=None, ex=None,):
17853 
    self.success = success
17854 
    self.ex = ex
17855 
 
17856 
  def read(self, iprot):
17857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17859 
      return
17860 
    iprot.readStructBegin()
17861 
    while True:
17862 
      (fname, ftype, fid) = iprot.readFieldBegin()
17863 
      if ftype == TType.STOP:
17864 
        break
17865 
      if fid == 0:
17866 
        if ftype == TType.BOOL:
17867 
          self.success = iprot.readBool();
17868 
        else:
17869 
          iprot.skip(ftype)
17870 
      elif fid == 1:
17871 
        if ftype == TType.STRUCT:
17872 
          self.ex = TransactionServiceException()
17873 
          self.ex.read(iprot)
17874 
        else:
17875 
          iprot.skip(ftype)
17876 
      else:
17877 
        iprot.skip(ftype)
17878 
      iprot.readFieldEnd()
17879 
    iprot.readStructEnd()
17880 
 
17881 
  def write(self, oprot):
17882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17884 
      return
17885 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17886 
    if self.success is not None:
2591 chandransh 17887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17888 
      oprot.writeBool(self.success)
17889 
      oprot.writeFieldEnd()
3431 rajveer 17890 
    if self.ex is not None:
2591 chandransh 17891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17892 
      self.ex.write(oprot)
17893 
      oprot.writeFieldEnd()
17894 
    oprot.writeFieldStop()
17895 
    oprot.writeStructEnd()
17896 
 
3431 rajveer 17897 
  def validate(self):
17898 
    return
17899 
 
17900 
 
2591 chandransh 17901 
  def __repr__(self):
17902 
    L = ['%s=%r' % (key, value)
17903 
      for key, value in self.__dict__.iteritems()]
17904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17905 
 
17906 
  def __eq__(self, other):
17907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17908 
 
17909 
  def __ne__(self, other):
17910 
    return not (self == other)
17911 
 
4495 rajveer 17912 
class validateReturnProduct_args:
17913 
  """
17914 
  Attributes:
17915 
   - orderId
17916 
   - isUsable
17917 
  """
17918 
 
17919 
  thrift_spec = (
17920 
    None, # 0
17921 
    (1, TType.I64, 'orderId', None, None, ), # 1
17922 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17923 
  )
17924 
 
17925 
  def __init__(self, orderId=None, isUsable=None,):
17926 
    self.orderId = orderId
17927 
    self.isUsable = isUsable
17928 
 
17929 
  def read(self, iprot):
17930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17932 
      return
17933 
    iprot.readStructBegin()
17934 
    while True:
17935 
      (fname, ftype, fid) = iprot.readFieldBegin()
17936 
      if ftype == TType.STOP:
17937 
        break
17938 
      if fid == 1:
17939 
        if ftype == TType.I64:
17940 
          self.orderId = iprot.readI64();
17941 
        else:
17942 
          iprot.skip(ftype)
17943 
      elif fid == 2:
17944 
        if ftype == TType.BOOL:
17945 
          self.isUsable = iprot.readBool();
17946 
        else:
17947 
          iprot.skip(ftype)
17948 
      else:
17949 
        iprot.skip(ftype)
17950 
      iprot.readFieldEnd()
17951 
    iprot.readStructEnd()
17952 
 
17953 
  def write(self, oprot):
17954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17956 
      return
17957 
    oprot.writeStructBegin('validateReturnProduct_args')
17958 
    if self.orderId is not None:
17959 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17960 
      oprot.writeI64(self.orderId)
17961 
      oprot.writeFieldEnd()
17962 
    if self.isUsable is not None:
17963 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17964 
      oprot.writeBool(self.isUsable)
17965 
      oprot.writeFieldEnd()
17966 
    oprot.writeFieldStop()
17967 
    oprot.writeStructEnd()
17968 
 
17969 
  def validate(self):
17970 
    return
17971 
 
17972 
 
17973 
  def __repr__(self):
17974 
    L = ['%s=%r' % (key, value)
17975 
      for key, value in self.__dict__.iteritems()]
17976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17977 
 
17978 
  def __eq__(self, other):
17979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17980 
 
17981 
  def __ne__(self, other):
17982 
    return not (self == other)
17983 
 
17984 
class validateReturnProduct_result:
17985 
  """
17986 
  Attributes:
17987 
   - success
17988 
   - ex
17989 
  """
17990 
 
17991 
  thrift_spec = (
17992 
    (0, TType.BOOL, 'success', None, None, ), # 0
17993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17994 
  )
17995 
 
17996 
  def __init__(self, success=None, ex=None,):
17997 
    self.success = success
17998 
    self.ex = ex
17999 
 
18000 
  def read(self, iprot):
18001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18003 
      return
18004 
    iprot.readStructBegin()
18005 
    while True:
18006 
      (fname, ftype, fid) = iprot.readFieldBegin()
18007 
      if ftype == TType.STOP:
18008 
        break
18009 
      if fid == 0:
18010 
        if ftype == TType.BOOL:
18011 
          self.success = iprot.readBool();
18012 
        else:
18013 
          iprot.skip(ftype)
18014 
      elif fid == 1:
18015 
        if ftype == TType.STRUCT:
18016 
          self.ex = TransactionServiceException()
18017 
          self.ex.read(iprot)
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('validateReturnProduct_result')
18030 
    if self.success is not None:
18031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18032 
      oprot.writeBool(self.success)
18033 
      oprot.writeFieldEnd()
18034 
    if self.ex is not None:
18035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18036 
      self.ex.write(oprot)
18037 
      oprot.writeFieldEnd()
18038 
    oprot.writeFieldStop()
18039 
    oprot.writeStructEnd()
18040 
 
18041 
  def validate(self):
18042 
    return
18043 
 
18044 
 
18045 
  def __repr__(self):
18046 
    L = ['%s=%r' % (key, value)
18047 
      for key, value in self.__dict__.iteritems()]
18048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18049 
 
18050 
  def __eq__(self, other):
18051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18052 
 
18053 
  def __ne__(self, other):
18054 
    return not (self == other)
18055 
 
2616 chandransh 18056 
class reshipOrder_args:
18057 
  """
18058 
  Attributes:
18059 
   - orderId
18060 
  """
2591 chandransh 18061 
 
2616 chandransh 18062 
  thrift_spec = (
18063 
    None, # 0
18064 
    (1, TType.I64, 'orderId', None, None, ), # 1
18065 
  )
18066 
 
18067 
  def __init__(self, orderId=None,):
18068 
    self.orderId = orderId
18069 
 
18070 
  def read(self, iprot):
18071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18073 
      return
18074 
    iprot.readStructBegin()
18075 
    while True:
18076 
      (fname, ftype, fid) = iprot.readFieldBegin()
18077 
      if ftype == TType.STOP:
18078 
        break
18079 
      if fid == 1:
18080 
        if ftype == TType.I64:
18081 
          self.orderId = iprot.readI64();
18082 
        else:
18083 
          iprot.skip(ftype)
18084 
      else:
18085 
        iprot.skip(ftype)
18086 
      iprot.readFieldEnd()
18087 
    iprot.readStructEnd()
18088 
 
18089 
  def write(self, oprot):
18090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18092 
      return
18093 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18094 
    if self.orderId is not None:
2616 chandransh 18095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18096 
      oprot.writeI64(self.orderId)
18097 
      oprot.writeFieldEnd()
18098 
    oprot.writeFieldStop()
18099 
    oprot.writeStructEnd()
18100 
 
3431 rajveer 18101 
  def validate(self):
18102 
    return
18103 
 
18104 
 
2616 chandransh 18105 
  def __repr__(self):
18106 
    L = ['%s=%r' % (key, value)
18107 
      for key, value in self.__dict__.iteritems()]
18108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18109 
 
18110 
  def __eq__(self, other):
18111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18112 
 
18113 
  def __ne__(self, other):
18114 
    return not (self == other)
18115 
 
18116 
class reshipOrder_result:
18117 
  """
18118 
  Attributes:
18119 
   - success
18120 
   - ex
18121 
  """
18122 
 
18123 
  thrift_spec = (
18124 
    (0, TType.I64, 'success', None, None, ), # 0
18125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18126 
  )
18127 
 
18128 
  def __init__(self, success=None, ex=None,):
18129 
    self.success = success
18130 
    self.ex = ex
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 0:
18142 
        if ftype == TType.I64:
18143 
          self.success = iprot.readI64();
18144 
        else:
18145 
          iprot.skip(ftype)
18146 
      elif fid == 1:
18147 
        if ftype == TType.STRUCT:
18148 
          self.ex = TransactionServiceException()
18149 
          self.ex.read(iprot)
18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      else:
18153 
        iprot.skip(ftype)
18154 
      iprot.readFieldEnd()
18155 
    iprot.readStructEnd()
18156 
 
18157 
  def write(self, oprot):
18158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18160 
      return
18161 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18162 
    if self.success is not None:
2616 chandransh 18163 
      oprot.writeFieldBegin('success', TType.I64, 0)
18164 
      oprot.writeI64(self.success)
18165 
      oprot.writeFieldEnd()
3431 rajveer 18166 
    if self.ex is not None:
2616 chandransh 18167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18168 
      self.ex.write(oprot)
18169 
      oprot.writeFieldEnd()
18170 
    oprot.writeFieldStop()
18171 
    oprot.writeStructEnd()
18172 
 
3431 rajveer 18173 
  def validate(self):
18174 
    return
18175 
 
18176 
 
2616 chandransh 18177 
  def __repr__(self):
18178 
    L = ['%s=%r' % (key, value)
18179 
      for key, value in self.__dict__.iteritems()]
18180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18181 
 
18182 
  def __eq__(self, other):
18183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18184 
 
18185 
  def __ne__(self, other):
18186 
    return not (self == other)
18187 
 
18188 
class refundOrder_args:
18189 
  """
18190 
  Attributes:
18191 
   - orderId
3226 chandransh 18192 
   - refundedBy
18193 
   - reason
2616 chandransh 18194 
  """
18195 
 
18196 
  thrift_spec = (
18197 
    None, # 0
18198 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18199 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18200 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18201 
  )
18202 
 
3226 chandransh 18203 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18204 
    self.orderId = orderId
3226 chandransh 18205 
    self.refundedBy = refundedBy
18206 
    self.reason = reason
2616 chandransh 18207 
 
18208 
  def read(self, iprot):
18209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18211 
      return
18212 
    iprot.readStructBegin()
18213 
    while True:
18214 
      (fname, ftype, fid) = iprot.readFieldBegin()
18215 
      if ftype == TType.STOP:
18216 
        break
18217 
      if fid == 1:
18218 
        if ftype == TType.I64:
18219 
          self.orderId = iprot.readI64();
18220 
        else:
18221 
          iprot.skip(ftype)
3226 chandransh 18222 
      elif fid == 2:
18223 
        if ftype == TType.STRING:
18224 
          self.refundedBy = iprot.readString();
18225 
        else:
18226 
          iprot.skip(ftype)
18227 
      elif fid == 3:
18228 
        if ftype == TType.STRING:
18229 
          self.reason = iprot.readString();
18230 
        else:
18231 
          iprot.skip(ftype)
2616 chandransh 18232 
      else:
18233 
        iprot.skip(ftype)
18234 
      iprot.readFieldEnd()
18235 
    iprot.readStructEnd()
18236 
 
18237 
  def write(self, oprot):
18238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18240 
      return
18241 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18242 
    if self.orderId is not None:
2616 chandransh 18243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18244 
      oprot.writeI64(self.orderId)
18245 
      oprot.writeFieldEnd()
3431 rajveer 18246 
    if self.refundedBy is not None:
3226 chandransh 18247 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18248 
      oprot.writeString(self.refundedBy)
18249 
      oprot.writeFieldEnd()
3431 rajveer 18250 
    if self.reason is not None:
3226 chandransh 18251 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18252 
      oprot.writeString(self.reason)
18253 
      oprot.writeFieldEnd()
2616 chandransh 18254 
    oprot.writeFieldStop()
18255 
    oprot.writeStructEnd()
18256 
 
3431 rajveer 18257 
  def validate(self):
18258 
    return
18259 
 
18260 
 
2616 chandransh 18261 
  def __repr__(self):
18262 
    L = ['%s=%r' % (key, value)
18263 
      for key, value in self.__dict__.iteritems()]
18264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18265 
 
18266 
  def __eq__(self, other):
18267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18268 
 
18269 
  def __ne__(self, other):
18270 
    return not (self == other)
18271 
 
18272 
class refundOrder_result:
18273 
  """
18274 
  Attributes:
18275 
   - success
18276 
   - ex
18277 
  """
18278 
 
18279 
  thrift_spec = (
18280 
    (0, TType.BOOL, 'success', None, None, ), # 0
18281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18282 
  )
18283 
 
18284 
  def __init__(self, success=None, ex=None,):
18285 
    self.success = success
18286 
    self.ex = ex
18287 
 
18288 
  def read(self, iprot):
18289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18291 
      return
18292 
    iprot.readStructBegin()
18293 
    while True:
18294 
      (fname, ftype, fid) = iprot.readFieldBegin()
18295 
      if ftype == TType.STOP:
18296 
        break
18297 
      if fid == 0:
18298 
        if ftype == TType.BOOL:
18299 
          self.success = iprot.readBool();
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      elif fid == 1:
18303 
        if ftype == TType.STRUCT:
18304 
          self.ex = TransactionServiceException()
18305 
          self.ex.read(iprot)
18306 
        else:
18307 
          iprot.skip(ftype)
18308 
      else:
18309 
        iprot.skip(ftype)
18310 
      iprot.readFieldEnd()
18311 
    iprot.readStructEnd()
18312 
 
18313 
  def write(self, oprot):
18314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18316 
      return
18317 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18318 
    if self.success is not None:
2616 chandransh 18319 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18320 
      oprot.writeBool(self.success)
18321 
      oprot.writeFieldEnd()
3431 rajveer 18322 
    if self.ex is not None:
2616 chandransh 18323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18324 
      self.ex.write(oprot)
18325 
      oprot.writeFieldEnd()
18326 
    oprot.writeFieldStop()
18327 
    oprot.writeStructEnd()
18328 
 
3431 rajveer 18329 
  def validate(self):
18330 
    return
18331 
 
18332 
 
2616 chandransh 18333 
  def __repr__(self):
18334 
    L = ['%s=%r' % (key, value)
18335 
      for key, value in self.__dict__.iteritems()]
18336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18337 
 
18338 
  def __eq__(self, other):
18339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18340 
 
18341 
  def __ne__(self, other):
18342 
    return not (self == other)
18343 
 
2690 chandransh 18344 
class getReturnOrders_args:
18345 
  """
18346 
  Attributes:
18347 
   - warehouseId
18348 
   - fromDate
18349 
   - toDate
18350 
  """
2616 chandransh 18351 
 
2690 chandransh 18352 
  thrift_spec = (
18353 
    None, # 0
18354 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18355 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18356 
    (3, TType.I64, 'toDate', None, None, ), # 3
18357 
  )
18358 
 
18359 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18360 
    self.warehouseId = warehouseId
18361 
    self.fromDate = fromDate
18362 
    self.toDate = toDate
18363 
 
18364 
  def read(self, iprot):
18365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18367 
      return
18368 
    iprot.readStructBegin()
18369 
    while True:
18370 
      (fname, ftype, fid) = iprot.readFieldBegin()
18371 
      if ftype == TType.STOP:
18372 
        break
18373 
      if fid == 1:
18374 
        if ftype == TType.I64:
18375 
          self.warehouseId = iprot.readI64();
18376 
        else:
18377 
          iprot.skip(ftype)
18378 
      elif fid == 2:
18379 
        if ftype == TType.I64:
18380 
          self.fromDate = iprot.readI64();
18381 
        else:
18382 
          iprot.skip(ftype)
18383 
      elif fid == 3:
18384 
        if ftype == TType.I64:
18385 
          self.toDate = iprot.readI64();
18386 
        else:
18387 
          iprot.skip(ftype)
18388 
      else:
18389 
        iprot.skip(ftype)
18390 
      iprot.readFieldEnd()
18391 
    iprot.readStructEnd()
18392 
 
18393 
  def write(self, oprot):
18394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18396 
      return
18397 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18398 
    if self.warehouseId is not None:
2690 chandransh 18399 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18400 
      oprot.writeI64(self.warehouseId)
18401 
      oprot.writeFieldEnd()
3431 rajveer 18402 
    if self.fromDate is not None:
2690 chandransh 18403 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18404 
      oprot.writeI64(self.fromDate)
18405 
      oprot.writeFieldEnd()
3431 rajveer 18406 
    if self.toDate is not None:
2690 chandransh 18407 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18408 
      oprot.writeI64(self.toDate)
18409 
      oprot.writeFieldEnd()
18410 
    oprot.writeFieldStop()
18411 
    oprot.writeStructEnd()
18412 
 
3431 rajveer 18413 
  def validate(self):
18414 
    return
18415 
 
18416 
 
2690 chandransh 18417 
  def __repr__(self):
18418 
    L = ['%s=%r' % (key, value)
18419 
      for key, value in self.__dict__.iteritems()]
18420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18421 
 
18422 
  def __eq__(self, other):
18423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18424 
 
18425 
  def __ne__(self, other):
18426 
    return not (self == other)
18427 
 
18428 
class getReturnOrders_result:
18429 
  """
18430 
  Attributes:
18431 
   - success
18432 
  """
18433 
 
18434 
  thrift_spec = (
18435 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18436 
  )
18437 
 
18438 
  def __init__(self, success=None,):
18439 
    self.success = success
18440 
 
18441 
  def read(self, iprot):
18442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18444 
      return
18445 
    iprot.readStructBegin()
18446 
    while True:
18447 
      (fname, ftype, fid) = iprot.readFieldBegin()
18448 
      if ftype == TType.STOP:
18449 
        break
18450 
      if fid == 0:
18451 
        if ftype == TType.LIST:
18452 
          self.success = []
6188 rajveer 18453 
          (_etype442, _size439) = iprot.readListBegin()
18454 
          for _i443 in xrange(_size439):
18455 
            _elem444 = ReturnOrder()
18456 
            _elem444.read(iprot)
18457 
            self.success.append(_elem444)
2690 chandransh 18458 
          iprot.readListEnd()
18459 
        else:
18460 
          iprot.skip(ftype)
18461 
      else:
18462 
        iprot.skip(ftype)
18463 
      iprot.readFieldEnd()
18464 
    iprot.readStructEnd()
18465 
 
18466 
  def write(self, oprot):
18467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18469 
      return
18470 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18471 
    if self.success is not None:
2690 chandransh 18472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18474 
      for iter445 in self.success:
18475 
        iter445.write(oprot)
2690 chandransh 18476 
      oprot.writeListEnd()
18477 
      oprot.writeFieldEnd()
18478 
    oprot.writeFieldStop()
18479 
    oprot.writeStructEnd()
18480 
 
3431 rajveer 18481 
  def validate(self):
18482 
    return
18483 
 
18484 
 
2690 chandransh 18485 
  def __repr__(self):
18486 
    L = ['%s=%r' % (key, value)
18487 
      for key, value in self.__dict__.iteritems()]
18488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18489 
 
18490 
  def __eq__(self, other):
18491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18492 
 
18493 
  def __ne__(self, other):
18494 
    return not (self == other)
18495 
 
5481 phani.kuma 18496 
class getAllReturnOrders_args:
18497 
  """
18498 
  Attributes:
18499 
   - onlyNotProcessed
18500 
   - fromDate
18501 
   - toDate
18502 
  """
18503 
 
18504 
  thrift_spec = (
18505 
    None, # 0
18506 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18507 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18508 
    (3, TType.I64, 'toDate', None, None, ), # 3
18509 
  )
18510 
 
18511 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18512 
    self.onlyNotProcessed = onlyNotProcessed
18513 
    self.fromDate = fromDate
18514 
    self.toDate = toDate
18515 
 
18516 
  def read(self, iprot):
18517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18519 
      return
18520 
    iprot.readStructBegin()
18521 
    while True:
18522 
      (fname, ftype, fid) = iprot.readFieldBegin()
18523 
      if ftype == TType.STOP:
18524 
        break
18525 
      if fid == 1:
18526 
        if ftype == TType.BOOL:
18527 
          self.onlyNotProcessed = iprot.readBool();
18528 
        else:
18529 
          iprot.skip(ftype)
18530 
      elif fid == 2:
18531 
        if ftype == TType.I64:
18532 
          self.fromDate = iprot.readI64();
18533 
        else:
18534 
          iprot.skip(ftype)
18535 
      elif fid == 3:
18536 
        if ftype == TType.I64:
18537 
          self.toDate = iprot.readI64();
18538 
        else:
18539 
          iprot.skip(ftype)
18540 
      else:
18541 
        iprot.skip(ftype)
18542 
      iprot.readFieldEnd()
18543 
    iprot.readStructEnd()
18544 
 
18545 
  def write(self, oprot):
18546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18548 
      return
18549 
    oprot.writeStructBegin('getAllReturnOrders_args')
18550 
    if self.onlyNotProcessed is not None:
18551 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18552 
      oprot.writeBool(self.onlyNotProcessed)
18553 
      oprot.writeFieldEnd()
18554 
    if self.fromDate is not None:
18555 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18556 
      oprot.writeI64(self.fromDate)
18557 
      oprot.writeFieldEnd()
18558 
    if self.toDate is not None:
18559 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18560 
      oprot.writeI64(self.toDate)
18561 
      oprot.writeFieldEnd()
18562 
    oprot.writeFieldStop()
18563 
    oprot.writeStructEnd()
18564 
 
18565 
  def validate(self):
18566 
    return
18567 
 
18568 
 
18569 
  def __repr__(self):
18570 
    L = ['%s=%r' % (key, value)
18571 
      for key, value in self.__dict__.iteritems()]
18572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18573 
 
18574 
  def __eq__(self, other):
18575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18576 
 
18577 
  def __ne__(self, other):
18578 
    return not (self == other)
18579 
 
18580 
class getAllReturnOrders_result:
18581 
  """
18582 
  Attributes:
18583 
   - success
18584 
  """
18585 
 
18586 
  thrift_spec = (
18587 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18588 
  )
18589 
 
18590 
  def __init__(self, success=None,):
18591 
    self.success = success
18592 
 
18593 
  def read(self, iprot):
18594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18596 
      return
18597 
    iprot.readStructBegin()
18598 
    while True:
18599 
      (fname, ftype, fid) = iprot.readFieldBegin()
18600 
      if ftype == TType.STOP:
18601 
        break
18602 
      if fid == 0:
18603 
        if ftype == TType.LIST:
18604 
          self.success = []
6188 rajveer 18605 
          (_etype449, _size446) = iprot.readListBegin()
18606 
          for _i450 in xrange(_size446):
18607 
            _elem451 = ReturnOrder()
18608 
            _elem451.read(iprot)
18609 
            self.success.append(_elem451)
5481 phani.kuma 18610 
          iprot.readListEnd()
18611 
        else:
18612 
          iprot.skip(ftype)
18613 
      else:
18614 
        iprot.skip(ftype)
18615 
      iprot.readFieldEnd()
18616 
    iprot.readStructEnd()
18617 
 
18618 
  def write(self, oprot):
18619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18621 
      return
18622 
    oprot.writeStructBegin('getAllReturnOrders_result')
18623 
    if self.success is not None:
18624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18626 
      for iter452 in self.success:
18627 
        iter452.write(oprot)
5481 phani.kuma 18628 
      oprot.writeListEnd()
18629 
      oprot.writeFieldEnd()
18630 
    oprot.writeFieldStop()
18631 
    oprot.writeStructEnd()
18632 
 
18633 
  def validate(self):
18634 
    return
18635 
 
18636 
 
18637 
  def __repr__(self):
18638 
    L = ['%s=%r' % (key, value)
18639 
      for key, value in self.__dict__.iteritems()]
18640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18641 
 
18642 
  def __eq__(self, other):
18643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18644 
 
18645 
  def __ne__(self, other):
18646 
    return not (self == other)
18647 
 
2700 chandransh 18648 
class getReturnOrder_args:
18649 
  """
18650 
  Attributes:
18651 
   - id
18652 
  """
18653 
 
18654 
  thrift_spec = (
18655 
    None, # 0
18656 
    (1, TType.I64, 'id', None, None, ), # 1
18657 
  )
18658 
 
18659 
  def __init__(self, id=None,):
18660 
    self.id = id
18661 
 
18662 
  def read(self, iprot):
18663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18665 
      return
18666 
    iprot.readStructBegin()
18667 
    while True:
18668 
      (fname, ftype, fid) = iprot.readFieldBegin()
18669 
      if ftype == TType.STOP:
18670 
        break
18671 
      if fid == 1:
18672 
        if ftype == TType.I64:
18673 
          self.id = iprot.readI64();
18674 
        else:
18675 
          iprot.skip(ftype)
18676 
      else:
18677 
        iprot.skip(ftype)
18678 
      iprot.readFieldEnd()
18679 
    iprot.readStructEnd()
18680 
 
18681 
  def write(self, oprot):
18682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18684 
      return
18685 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18686 
    if self.id is not None:
2700 chandransh 18687 
      oprot.writeFieldBegin('id', TType.I64, 1)
18688 
      oprot.writeI64(self.id)
18689 
      oprot.writeFieldEnd()
18690 
    oprot.writeFieldStop()
18691 
    oprot.writeStructEnd()
18692 
 
3431 rajveer 18693 
  def validate(self):
18694 
    return
18695 
 
18696 
 
2700 chandransh 18697 
  def __repr__(self):
18698 
    L = ['%s=%r' % (key, value)
18699 
      for key, value in self.__dict__.iteritems()]
18700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18701 
 
18702 
  def __eq__(self, other):
18703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18704 
 
18705 
  def __ne__(self, other):
18706 
    return not (self == other)
18707 
 
18708 
class getReturnOrder_result:
18709 
  """
18710 
  Attributes:
18711 
   - success
18712 
   - ex
18713 
  """
18714 
 
18715 
  thrift_spec = (
18716 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18718 
  )
18719 
 
18720 
  def __init__(self, success=None, ex=None,):
18721 
    self.success = success
18722 
    self.ex = ex
18723 
 
18724 
  def read(self, iprot):
18725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18727 
      return
18728 
    iprot.readStructBegin()
18729 
    while True:
18730 
      (fname, ftype, fid) = iprot.readFieldBegin()
18731 
      if ftype == TType.STOP:
18732 
        break
18733 
      if fid == 0:
18734 
        if ftype == TType.STRUCT:
18735 
          self.success = ReturnOrder()
18736 
          self.success.read(iprot)
18737 
        else:
18738 
          iprot.skip(ftype)
18739 
      elif fid == 1:
18740 
        if ftype == TType.STRUCT:
18741 
          self.ex = TransactionServiceException()
18742 
          self.ex.read(iprot)
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('getReturnOrder_result')
3431 rajveer 18755 
    if self.success is not None:
2700 chandransh 18756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18757 
      self.success.write(oprot)
18758 
      oprot.writeFieldEnd()
3431 rajveer 18759 
    if self.ex is not None:
2700 chandransh 18760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18761 
      self.ex.write(oprot)
18762 
      oprot.writeFieldEnd()
18763 
    oprot.writeFieldStop()
18764 
    oprot.writeStructEnd()
18765 
 
3431 rajveer 18766 
  def validate(self):
18767 
    return
18768 
 
18769 
 
2700 chandransh 18770 
  def __repr__(self):
18771 
    L = ['%s=%r' % (key, value)
18772 
      for key, value in self.__dict__.iteritems()]
18773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18774 
 
18775 
  def __eq__(self, other):
18776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18777 
 
18778 
  def __ne__(self, other):
18779 
    return not (self == other)
18780 
 
2690 chandransh 18781 
class processReturn_args:
18782 
  """
18783 
  Attributes:
18784 
   - returnOrderId
18785 
  """
18786 
 
18787 
  thrift_spec = (
18788 
    None, # 0
18789 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18790 
  )
18791 
 
18792 
  def __init__(self, returnOrderId=None,):
18793 
    self.returnOrderId = returnOrderId
18794 
 
18795 
  def read(self, iprot):
18796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18798 
      return
18799 
    iprot.readStructBegin()
18800 
    while True:
18801 
      (fname, ftype, fid) = iprot.readFieldBegin()
18802 
      if ftype == TType.STOP:
18803 
        break
18804 
      if fid == 1:
18805 
        if ftype == TType.I64:
18806 
          self.returnOrderId = iprot.readI64();
18807 
        else:
18808 
          iprot.skip(ftype)
18809 
      else:
18810 
        iprot.skip(ftype)
18811 
      iprot.readFieldEnd()
18812 
    iprot.readStructEnd()
18813 
 
18814 
  def write(self, oprot):
18815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18817 
      return
18818 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18819 
    if self.returnOrderId is not None:
2690 chandransh 18820 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18821 
      oprot.writeI64(self.returnOrderId)
18822 
      oprot.writeFieldEnd()
18823 
    oprot.writeFieldStop()
18824 
    oprot.writeStructEnd()
18825 
 
3431 rajveer 18826 
  def validate(self):
18827 
    return
18828 
 
18829 
 
2690 chandransh 18830 
  def __repr__(self):
18831 
    L = ['%s=%r' % (key, value)
18832 
      for key, value in self.__dict__.iteritems()]
18833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18834 
 
18835 
  def __eq__(self, other):
18836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18837 
 
18838 
  def __ne__(self, other):
18839 
    return not (self == other)
18840 
 
18841 
class processReturn_result:
18842 
  """
18843 
  Attributes:
18844 
   - ex
18845 
  """
18846 
 
18847 
  thrift_spec = (
18848 
    None, # 0
18849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18850 
  )
18851 
 
18852 
  def __init__(self, ex=None,):
18853 
    self.ex = ex
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.STRUCT:
18866 
          self.ex = TransactionServiceException()
18867 
          self.ex.read(iprot)
18868 
        else:
18869 
          iprot.skip(ftype)
18870 
      else:
18871 
        iprot.skip(ftype)
18872 
      iprot.readFieldEnd()
18873 
    iprot.readStructEnd()
18874 
 
18875 
  def write(self, oprot):
18876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18878 
      return
18879 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18880 
    if self.ex is not None:
2690 chandransh 18881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18882 
      self.ex.write(oprot)
18883 
      oprot.writeFieldEnd()
18884 
    oprot.writeFieldStop()
18885 
    oprot.writeStructEnd()
18886 
 
3431 rajveer 18887 
  def validate(self):
18888 
    return
18889 
 
18890 
 
2690 chandransh 18891 
  def __repr__(self):
18892 
    L = ['%s=%r' % (key, value)
18893 
      for key, value in self.__dict__.iteritems()]
18894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18895 
 
18896 
  def __eq__(self, other):
18897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18898 
 
18899 
  def __ne__(self, other):
18900 
    return not (self == other)
18901 
 
3451 chandransh 18902 
class updateWeight_args:
18903 
  """
18904 
  Attributes:
18905 
   - orderId
18906 
   - weight
18907 
  """
18908 
 
18909 
  thrift_spec = (
18910 
    None, # 0
18911 
    (1, TType.I64, 'orderId', None, None, ), # 1
18912 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18913 
  )
18914 
 
18915 
  def __init__(self, orderId=None, weight=None,):
18916 
    self.orderId = orderId
18917 
    self.weight = weight
18918 
 
18919 
  def read(self, iprot):
18920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18922 
      return
18923 
    iprot.readStructBegin()
18924 
    while True:
18925 
      (fname, ftype, fid) = iprot.readFieldBegin()
18926 
      if ftype == TType.STOP:
18927 
        break
18928 
      if fid == 1:
18929 
        if ftype == TType.I64:
18930 
          self.orderId = iprot.readI64();
18931 
        else:
18932 
          iprot.skip(ftype)
18933 
      elif fid == 2:
18934 
        if ftype == TType.DOUBLE:
18935 
          self.weight = iprot.readDouble();
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      else:
18939 
        iprot.skip(ftype)
18940 
      iprot.readFieldEnd()
18941 
    iprot.readStructEnd()
18942 
 
18943 
  def write(self, oprot):
18944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18946 
      return
18947 
    oprot.writeStructBegin('updateWeight_args')
18948 
    if self.orderId is not None:
18949 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18950 
      oprot.writeI64(self.orderId)
18951 
      oprot.writeFieldEnd()
18952 
    if self.weight is not None:
18953 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18954 
      oprot.writeDouble(self.weight)
18955 
      oprot.writeFieldEnd()
18956 
    oprot.writeFieldStop()
18957 
    oprot.writeStructEnd()
18958 
 
18959 
  def validate(self):
18960 
    return
18961 
 
18962 
 
18963 
  def __repr__(self):
18964 
    L = ['%s=%r' % (key, value)
18965 
      for key, value in self.__dict__.iteritems()]
18966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18967 
 
18968 
  def __eq__(self, other):
18969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18970 
 
18971 
  def __ne__(self, other):
18972 
    return not (self == other)
18973 
 
18974 
class updateWeight_result:
18975 
  """
18976 
  Attributes:
18977 
   - success
18978 
   - ex
18979 
  """
18980 
 
18981 
  thrift_spec = (
18982 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18984 
  )
18985 
 
18986 
  def __init__(self, success=None, ex=None,):
18987 
    self.success = success
18988 
    self.ex = ex
18989 
 
18990 
  def read(self, iprot):
18991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18993 
      return
18994 
    iprot.readStructBegin()
18995 
    while True:
18996 
      (fname, ftype, fid) = iprot.readFieldBegin()
18997 
      if ftype == TType.STOP:
18998 
        break
18999 
      if fid == 0:
19000 
        if ftype == TType.STRUCT:
19001 
          self.success = Order()
19002 
          self.success.read(iprot)
19003 
        else:
19004 
          iprot.skip(ftype)
19005 
      elif fid == 1:
19006 
        if ftype == TType.STRUCT:
19007 
          self.ex = TransactionServiceException()
19008 
          self.ex.read(iprot)
19009 
        else:
19010 
          iprot.skip(ftype)
19011 
      else:
19012 
        iprot.skip(ftype)
19013 
      iprot.readFieldEnd()
19014 
    iprot.readStructEnd()
19015 
 
19016 
  def write(self, oprot):
19017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19019 
      return
19020 
    oprot.writeStructBegin('updateWeight_result')
19021 
    if self.success is not None:
19022 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19023 
      self.success.write(oprot)
19024 
      oprot.writeFieldEnd()
19025 
    if self.ex is not None:
19026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19027 
      self.ex.write(oprot)
19028 
      oprot.writeFieldEnd()
19029 
    oprot.writeFieldStop()
19030 
    oprot.writeStructEnd()
19031 
 
19032 
  def validate(self):
19033 
    return
19034 
 
19035 
 
19036 
  def __repr__(self):
19037 
    L = ['%s=%r' % (key, value)
19038 
      for key, value in self.__dict__.iteritems()]
19039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19040 
 
19041 
  def __eq__(self, other):
19042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19043 
 
19044 
  def __ne__(self, other):
19045 
    return not (self == other)
3469 chandransh 19046 
 
19047 
class changeItem_args:
19048 
  """
19049 
  Attributes:
19050 
   - orderId
19051 
   - itemId
19052 
  """
19053 
 
19054 
  thrift_spec = (
19055 
    None, # 0
19056 
    (1, TType.I64, 'orderId', None, None, ), # 1
19057 
    (2, TType.I64, 'itemId', None, None, ), # 2
19058 
  )
19059 
 
19060 
  def __init__(self, orderId=None, itemId=None,):
19061 
    self.orderId = orderId
19062 
    self.itemId = itemId
19063 
 
19064 
  def read(self, iprot):
19065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19067 
      return
19068 
    iprot.readStructBegin()
19069 
    while True:
19070 
      (fname, ftype, fid) = iprot.readFieldBegin()
19071 
      if ftype == TType.STOP:
19072 
        break
19073 
      if fid == 1:
19074 
        if ftype == TType.I64:
19075 
          self.orderId = iprot.readI64();
19076 
        else:
19077 
          iprot.skip(ftype)
19078 
      elif fid == 2:
19079 
        if ftype == TType.I64:
19080 
          self.itemId = iprot.readI64();
19081 
        else:
19082 
          iprot.skip(ftype)
19083 
      else:
19084 
        iprot.skip(ftype)
19085 
      iprot.readFieldEnd()
19086 
    iprot.readStructEnd()
19087 
 
19088 
  def write(self, oprot):
19089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19091 
      return
19092 
    oprot.writeStructBegin('changeItem_args')
19093 
    if self.orderId is not None:
19094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19095 
      oprot.writeI64(self.orderId)
19096 
      oprot.writeFieldEnd()
19097 
    if self.itemId is not None:
19098 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19099 
      oprot.writeI64(self.itemId)
19100 
      oprot.writeFieldEnd()
19101 
    oprot.writeFieldStop()
19102 
    oprot.writeStructEnd()
19103 
 
19104 
  def validate(self):
19105 
    return
19106 
 
19107 
 
19108 
  def __repr__(self):
19109 
    L = ['%s=%r' % (key, value)
19110 
      for key, value in self.__dict__.iteritems()]
19111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19112 
 
19113 
  def __eq__(self, other):
19114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19115 
 
19116 
  def __ne__(self, other):
19117 
    return not (self == other)
19118 
 
19119 
class changeItem_result:
19120 
  """
19121 
  Attributes:
19122 
   - success
19123 
   - ex
19124 
  """
19125 
 
19126 
  thrift_spec = (
19127 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19129 
  )
19130 
 
19131 
  def __init__(self, success=None, ex=None,):
19132 
    self.success = success
19133 
    self.ex = ex
19134 
 
19135 
  def read(self, iprot):
19136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19138 
      return
19139 
    iprot.readStructBegin()
19140 
    while True:
19141 
      (fname, ftype, fid) = iprot.readFieldBegin()
19142 
      if ftype == TType.STOP:
19143 
        break
19144 
      if fid == 0:
19145 
        if ftype == TType.STRUCT:
19146 
          self.success = Order()
19147 
          self.success.read(iprot)
19148 
        else:
19149 
          iprot.skip(ftype)
19150 
      elif fid == 1:
19151 
        if ftype == TType.STRUCT:
19152 
          self.ex = TransactionServiceException()
19153 
          self.ex.read(iprot)
19154 
        else:
19155 
          iprot.skip(ftype)
19156 
      else:
19157 
        iprot.skip(ftype)
19158 
      iprot.readFieldEnd()
19159 
    iprot.readStructEnd()
19160 
 
19161 
  def write(self, oprot):
19162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19164 
      return
19165 
    oprot.writeStructBegin('changeItem_result')
19166 
    if self.success is not None:
19167 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19168 
      self.success.write(oprot)
19169 
      oprot.writeFieldEnd()
19170 
    if self.ex is not None:
19171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19172 
      self.ex.write(oprot)
19173 
      oprot.writeFieldEnd()
19174 
    oprot.writeFieldStop()
19175 
    oprot.writeStructEnd()
19176 
 
19177 
  def validate(self):
19178 
    return
19179 
 
19180 
 
19181 
  def __repr__(self):
19182 
    L = ['%s=%r' % (key, value)
19183 
      for key, value in self.__dict__.iteritems()]
19184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19185 
 
19186 
  def __eq__(self, other):
19187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19188 
 
19189 
  def __ne__(self, other):
19190 
    return not (self == other)
19191 
 
19192 
class shiftToWarehouse_args:
19193 
  """
19194 
  Attributes:
19195 
   - orderId
19196 
   - warehouseId
19197 
  """
19198 
 
19199 
  thrift_spec = (
19200 
    None, # 0
19201 
    (1, TType.I64, 'orderId', None, None, ), # 1
19202 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19203 
  )
19204 
 
19205 
  def __init__(self, orderId=None, warehouseId=None,):
19206 
    self.orderId = orderId
19207 
    self.warehouseId = warehouseId
19208 
 
19209 
  def read(self, iprot):
19210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19212 
      return
19213 
    iprot.readStructBegin()
19214 
    while True:
19215 
      (fname, ftype, fid) = iprot.readFieldBegin()
19216 
      if ftype == TType.STOP:
19217 
        break
19218 
      if fid == 1:
19219 
        if ftype == TType.I64:
19220 
          self.orderId = iprot.readI64();
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      elif fid == 2:
19224 
        if ftype == TType.I64:
19225 
          self.warehouseId = iprot.readI64();
19226 
        else:
19227 
          iprot.skip(ftype)
19228 
      else:
19229 
        iprot.skip(ftype)
19230 
      iprot.readFieldEnd()
19231 
    iprot.readStructEnd()
19232 
 
19233 
  def write(self, oprot):
19234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19236 
      return
19237 
    oprot.writeStructBegin('shiftToWarehouse_args')
19238 
    if self.orderId is not None:
19239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19240 
      oprot.writeI64(self.orderId)
19241 
      oprot.writeFieldEnd()
19242 
    if self.warehouseId is not None:
19243 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19244 
      oprot.writeI64(self.warehouseId)
19245 
      oprot.writeFieldEnd()
19246 
    oprot.writeFieldStop()
19247 
    oprot.writeStructEnd()
19248 
 
19249 
  def validate(self):
19250 
    return
19251 
 
19252 
 
19253 
  def __repr__(self):
19254 
    L = ['%s=%r' % (key, value)
19255 
      for key, value in self.__dict__.iteritems()]
19256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19257 
 
19258 
  def __eq__(self, other):
19259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19260 
 
19261 
  def __ne__(self, other):
19262 
    return not (self == other)
19263 
 
19264 
class shiftToWarehouse_result:
19265 
  """
19266 
  Attributes:
19267 
   - success
19268 
   - ex
19269 
  """
19270 
 
19271 
  thrift_spec = (
19272 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19274 
  )
19275 
 
19276 
  def __init__(self, success=None, ex=None,):
19277 
    self.success = success
19278 
    self.ex = ex
19279 
 
19280 
  def read(self, iprot):
19281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19283 
      return
19284 
    iprot.readStructBegin()
19285 
    while True:
19286 
      (fname, ftype, fid) = iprot.readFieldBegin()
19287 
      if ftype == TType.STOP:
19288 
        break
19289 
      if fid == 0:
19290 
        if ftype == TType.STRUCT:
19291 
          self.success = Order()
19292 
          self.success.read(iprot)
19293 
        else:
19294 
          iprot.skip(ftype)
19295 
      elif fid == 1:
19296 
        if ftype == TType.STRUCT:
19297 
          self.ex = TransactionServiceException()
19298 
          self.ex.read(iprot)
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      else:
19302 
        iprot.skip(ftype)
19303 
      iprot.readFieldEnd()
19304 
    iprot.readStructEnd()
19305 
 
19306 
  def write(self, oprot):
19307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19309 
      return
19310 
    oprot.writeStructBegin('shiftToWarehouse_result')
19311 
    if self.success is not None:
19312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19313 
      self.success.write(oprot)
19314 
      oprot.writeFieldEnd()
19315 
    if self.ex is not None:
19316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19317 
      self.ex.write(oprot)
19318 
      oprot.writeFieldEnd()
19319 
    oprot.writeFieldStop()
19320 
    oprot.writeStructEnd()
19321 
 
19322 
  def validate(self):
19323 
    return
19324 
 
19325 
 
19326 
  def __repr__(self):
19327 
    L = ['%s=%r' % (key, value)
19328 
      for key, value in self.__dict__.iteritems()]
19329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19330 
 
19331 
  def __eq__(self, other):
19332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19333 
 
19334 
  def __ne__(self, other):
19335 
    return not (self == other)
3553 chandransh 19336 
 
19337 
class addDelayReason_args:
19338 
  """
19339 
  Attributes:
19340 
   - orderId
19341 
   - delayReason
3986 chandransh 19342 
   - furtherDelay
4647 rajveer 19343 
   - delayReasonText
3553 chandransh 19344 
  """
19345 
 
19346 
  thrift_spec = (
19347 
    None, # 0
19348 
    (1, TType.I64, 'orderId', None, None, ), # 1
19349 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19350 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19351 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19352 
  )
19353 
 
4647 rajveer 19354 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19355 
    self.orderId = orderId
19356 
    self.delayReason = delayReason
3986 chandransh 19357 
    self.furtherDelay = furtherDelay
4647 rajveer 19358 
    self.delayReasonText = delayReasonText
3553 chandransh 19359 
 
19360 
  def read(self, iprot):
19361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19363 
      return
19364 
    iprot.readStructBegin()
19365 
    while True:
19366 
      (fname, ftype, fid) = iprot.readFieldBegin()
19367 
      if ftype == TType.STOP:
19368 
        break
19369 
      if fid == 1:
19370 
        if ftype == TType.I64:
19371 
          self.orderId = iprot.readI64();
19372 
        else:
19373 
          iprot.skip(ftype)
19374 
      elif fid == 2:
19375 
        if ftype == TType.I32:
19376 
          self.delayReason = iprot.readI32();
19377 
        else:
19378 
          iprot.skip(ftype)
3986 chandransh 19379 
      elif fid == 3:
19380 
        if ftype == TType.I64:
19381 
          self.furtherDelay = iprot.readI64();
19382 
        else:
19383 
          iprot.skip(ftype)
4647 rajveer 19384 
      elif fid == 4:
19385 
        if ftype == TType.STRING:
19386 
          self.delayReasonText = iprot.readString();
19387 
        else:
19388 
          iprot.skip(ftype)
3553 chandransh 19389 
      else:
19390 
        iprot.skip(ftype)
19391 
      iprot.readFieldEnd()
19392 
    iprot.readStructEnd()
19393 
 
19394 
  def write(self, oprot):
19395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19397 
      return
19398 
    oprot.writeStructBegin('addDelayReason_args')
19399 
    if self.orderId is not None:
19400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19401 
      oprot.writeI64(self.orderId)
19402 
      oprot.writeFieldEnd()
19403 
    if self.delayReason is not None:
19404 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19405 
      oprot.writeI32(self.delayReason)
19406 
      oprot.writeFieldEnd()
3986 chandransh 19407 
    if self.furtherDelay is not None:
19408 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19409 
      oprot.writeI64(self.furtherDelay)
19410 
      oprot.writeFieldEnd()
4647 rajveer 19411 
    if self.delayReasonText is not None:
19412 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19413 
      oprot.writeString(self.delayReasonText)
19414 
      oprot.writeFieldEnd()
3553 chandransh 19415 
    oprot.writeFieldStop()
19416 
    oprot.writeStructEnd()
19417 
 
19418 
  def validate(self):
19419 
    return
19420 
 
19421 
 
19422 
  def __repr__(self):
19423 
    L = ['%s=%r' % (key, value)
19424 
      for key, value in self.__dict__.iteritems()]
19425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19426 
 
19427 
  def __eq__(self, other):
19428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19429 
 
19430 
  def __ne__(self, other):
19431 
    return not (self == other)
19432 
 
19433 
class addDelayReason_result:
19434 
  """
19435 
  Attributes:
19436 
   - success
19437 
   - ex
19438 
  """
19439 
 
19440 
  thrift_spec = (
19441 
    (0, TType.BOOL, 'success', None, None, ), # 0
19442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19443 
  )
19444 
 
19445 
  def __init__(self, success=None, ex=None,):
19446 
    self.success = success
19447 
    self.ex = ex
19448 
 
19449 
  def read(self, iprot):
19450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19452 
      return
19453 
    iprot.readStructBegin()
19454 
    while True:
19455 
      (fname, ftype, fid) = iprot.readFieldBegin()
19456 
      if ftype == TType.STOP:
19457 
        break
19458 
      if fid == 0:
19459 
        if ftype == TType.BOOL:
19460 
          self.success = iprot.readBool();
19461 
        else:
19462 
          iprot.skip(ftype)
19463 
      elif fid == 1:
19464 
        if ftype == TType.STRUCT:
19465 
          self.ex = TransactionServiceException()
19466 
          self.ex.read(iprot)
19467 
        else:
19468 
          iprot.skip(ftype)
19469 
      else:
19470 
        iprot.skip(ftype)
19471 
      iprot.readFieldEnd()
19472 
    iprot.readStructEnd()
19473 
 
19474 
  def write(self, oprot):
19475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19477 
      return
19478 
    oprot.writeStructBegin('addDelayReason_result')
19479 
    if self.success is not None:
19480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19481 
      oprot.writeBool(self.success)
19482 
      oprot.writeFieldEnd()
19483 
    if self.ex is not None:
19484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19485 
      self.ex.write(oprot)
19486 
      oprot.writeFieldEnd()
19487 
    oprot.writeFieldStop()
19488 
    oprot.writeStructEnd()
19489 
 
19490 
  def validate(self):
19491 
    return
19492 
 
19493 
 
19494 
  def __repr__(self):
19495 
    L = ['%s=%r' % (key, value)
19496 
      for key, value in self.__dict__.iteritems()]
19497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19498 
 
19499 
  def __eq__(self, other):
19500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19501 
 
19502 
  def __ne__(self, other):
19503 
    return not (self == other)
3956 chandransh 19504 
 
19505 
class reconcileCodCollection_args:
19506 
  """
19507 
  Attributes:
19508 
   - collectedAmountMap
19509 
   - xferBy
19510 
   - xferTxnId
19511 
   - xferDate
19512 
  """
19513 
 
19514 
  thrift_spec = (
19515 
    None, # 0
19516 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19517 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19518 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19519 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19520 
  )
19521 
 
19522 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19523 
    self.collectedAmountMap = collectedAmountMap
19524 
    self.xferBy = xferBy
19525 
    self.xferTxnId = xferTxnId
19526 
    self.xferDate = xferDate
19527 
 
19528 
  def read(self, iprot):
19529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19531 
      return
19532 
    iprot.readStructBegin()
19533 
    while True:
19534 
      (fname, ftype, fid) = iprot.readFieldBegin()
19535 
      if ftype == TType.STOP:
19536 
        break
19537 
      if fid == 1:
19538 
        if ftype == TType.MAP:
19539 
          self.collectedAmountMap = {}
6188 rajveer 19540 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19541 
          for _i457 in xrange(_size453):
19542 
            _key458 = iprot.readString();
19543 
            _val459 = iprot.readDouble();
19544 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19545 
          iprot.readMapEnd()
19546 
        else:
19547 
          iprot.skip(ftype)
19548 
      elif fid == 2:
19549 
        if ftype == TType.STRING:
19550 
          self.xferBy = iprot.readString();
19551 
        else:
19552 
          iprot.skip(ftype)
19553 
      elif fid == 3:
19554 
        if ftype == TType.STRING:
19555 
          self.xferTxnId = iprot.readString();
19556 
        else:
19557 
          iprot.skip(ftype)
19558 
      elif fid == 4:
19559 
        if ftype == TType.I64:
19560 
          self.xferDate = iprot.readI64();
19561 
        else:
19562 
          iprot.skip(ftype)
19563 
      else:
19564 
        iprot.skip(ftype)
19565 
      iprot.readFieldEnd()
19566 
    iprot.readStructEnd()
19567 
 
19568 
  def write(self, oprot):
19569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19571 
      return
19572 
    oprot.writeStructBegin('reconcileCodCollection_args')
19573 
    if self.collectedAmountMap is not None:
19574 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19575 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19576 
      for kiter460,viter461 in self.collectedAmountMap.items():
19577 
        oprot.writeString(kiter460)
19578 
        oprot.writeDouble(viter461)
3956 chandransh 19579 
      oprot.writeMapEnd()
19580 
      oprot.writeFieldEnd()
19581 
    if self.xferBy is not None:
19582 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19583 
      oprot.writeString(self.xferBy)
19584 
      oprot.writeFieldEnd()
19585 
    if self.xferTxnId is not None:
19586 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19587 
      oprot.writeString(self.xferTxnId)
19588 
      oprot.writeFieldEnd()
19589 
    if self.xferDate is not None:
19590 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19591 
      oprot.writeI64(self.xferDate)
19592 
      oprot.writeFieldEnd()
19593 
    oprot.writeFieldStop()
19594 
    oprot.writeStructEnd()
19595 
 
19596 
  def validate(self):
19597 
    return
19598 
 
19599 
 
19600 
  def __repr__(self):
19601 
    L = ['%s=%r' % (key, value)
19602 
      for key, value in self.__dict__.iteritems()]
19603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19604 
 
19605 
  def __eq__(self, other):
19606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19607 
 
19608 
  def __ne__(self, other):
19609 
    return not (self == other)
19610 
 
19611 
class reconcileCodCollection_result:
19612 
  """
19613 
  Attributes:
19614 
   - success
19615 
   - ex
19616 
  """
19617 
 
19618 
  thrift_spec = (
19619 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19621 
  )
19622 
 
19623 
  def __init__(self, success=None, ex=None,):
19624 
    self.success = success
19625 
    self.ex = ex
19626 
 
19627 
  def read(self, iprot):
19628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19630 
      return
19631 
    iprot.readStructBegin()
19632 
    while True:
19633 
      (fname, ftype, fid) = iprot.readFieldBegin()
19634 
      if ftype == TType.STOP:
19635 
        break
19636 
      if fid == 0:
19637 
        if ftype == TType.MAP:
19638 
          self.success = {}
6188 rajveer 19639 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19640 
          for _i466 in xrange(_size462):
19641 
            _key467 = iprot.readString();
19642 
            _val468 = iprot.readString();
19643 
            self.success[_key467] = _val468
3956 chandransh 19644 
          iprot.readMapEnd()
19645 
        else:
19646 
          iprot.skip(ftype)
19647 
      elif fid == 1:
19648 
        if ftype == TType.STRUCT:
19649 
          self.ex = TransactionServiceException()
19650 
          self.ex.read(iprot)
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      else:
19654 
        iprot.skip(ftype)
19655 
      iprot.readFieldEnd()
19656 
    iprot.readStructEnd()
19657 
 
19658 
  def write(self, oprot):
19659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19661 
      return
19662 
    oprot.writeStructBegin('reconcileCodCollection_result')
19663 
    if self.success is not None:
19664 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19666 
      for kiter469,viter470 in self.success.items():
19667 
        oprot.writeString(kiter469)
19668 
        oprot.writeString(viter470)
3956 chandransh 19669 
      oprot.writeMapEnd()
19670 
      oprot.writeFieldEnd()
19671 
    if self.ex is not None:
19672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19673 
      self.ex.write(oprot)
19674 
      oprot.writeFieldEnd()
19675 
    oprot.writeFieldStop()
19676 
    oprot.writeStructEnd()
19677 
 
19678 
  def validate(self):
19679 
    return
19680 
 
19681 
 
19682 
  def __repr__(self):
19683 
    L = ['%s=%r' % (key, value)
19684 
      for key, value in self.__dict__.iteritems()]
19685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19686 
 
19687 
  def __eq__(self, other):
19688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19689 
 
19690 
  def __ne__(self, other):
19691 
    return not (self == other)
4008 mandeep.dh 19692 
 
19693 
class getTransactionsRequiringExtraProcessing_args:
19694 
  """
19695 
  Attributes:
19696 
   - category
19697 
  """
19698 
 
19699 
  thrift_spec = (
19700 
    None, # 0
19701 
    (1, TType.I32, 'category', None, None, ), # 1
19702 
  )
19703 
 
19704 
  def __init__(self, category=None,):
19705 
    self.category = category
19706 
 
19707 
  def read(self, iprot):
19708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19710 
      return
19711 
    iprot.readStructBegin()
19712 
    while True:
19713 
      (fname, ftype, fid) = iprot.readFieldBegin()
19714 
      if ftype == TType.STOP:
19715 
        break
19716 
      if fid == 1:
19717 
        if ftype == TType.I32:
19718 
          self.category = iprot.readI32();
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_args')
19731 
    if self.category is not None:
19732 
      oprot.writeFieldBegin('category', TType.I32, 1)
19733 
      oprot.writeI32(self.category)
19734 
      oprot.writeFieldEnd()
19735 
    oprot.writeFieldStop()
19736 
    oprot.writeStructEnd()
19737 
 
19738 
  def validate(self):
19739 
    return
19740 
 
19741 
 
19742 
  def __repr__(self):
19743 
    L = ['%s=%r' % (key, value)
19744 
      for key, value in self.__dict__.iteritems()]
19745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19746 
 
19747 
  def __eq__(self, other):
19748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19749 
 
19750 
  def __ne__(self, other):
19751 
    return not (self == other)
19752 
 
19753 
class getTransactionsRequiringExtraProcessing_result:
19754 
  """
19755 
  Attributes:
19756 
   - success
19757 
  """
19758 
 
19759 
  thrift_spec = (
19760 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19761 
  )
19762 
 
19763 
  def __init__(self, success=None,):
19764 
    self.success = success
19765 
 
19766 
  def read(self, iprot):
19767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19769 
      return
19770 
    iprot.readStructBegin()
19771 
    while True:
19772 
      (fname, ftype, fid) = iprot.readFieldBegin()
19773 
      if ftype == TType.STOP:
19774 
        break
19775 
      if fid == 0:
19776 
        if ftype == TType.LIST:
19777 
          self.success = []
6188 rajveer 19778 
          (_etype474, _size471) = iprot.readListBegin()
19779 
          for _i475 in xrange(_size471):
19780 
            _elem476 = iprot.readI64();
19781 
            self.success.append(_elem476)
4008 mandeep.dh 19782 
          iprot.readListEnd()
19783 
        else:
19784 
          iprot.skip(ftype)
19785 
      else:
19786 
        iprot.skip(ftype)
19787 
      iprot.readFieldEnd()
19788 
    iprot.readStructEnd()
19789 
 
19790 
  def write(self, oprot):
19791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19793 
      return
19794 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19795 
    if self.success is not None:
19796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19797 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19798 
      for iter477 in self.success:
19799 
        oprot.writeI64(iter477)
4008 mandeep.dh 19800 
      oprot.writeListEnd()
19801 
      oprot.writeFieldEnd()
19802 
    oprot.writeFieldStop()
19803 
    oprot.writeStructEnd()
19804 
 
19805 
  def validate(self):
19806 
    return
19807 
 
19808 
 
19809 
  def __repr__(self):
19810 
    L = ['%s=%r' % (key, value)
19811 
      for key, value in self.__dict__.iteritems()]
19812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19813 
 
19814 
  def __eq__(self, other):
19815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19816 
 
19817 
  def __ne__(self, other):
19818 
    return not (self == other)
19819 
 
19820 
class markTransactionAsProcessed_args:
19821 
  """
19822 
  Attributes:
19823 
   - transactionId
19824 
   - category
19825 
  """
19826 
 
19827 
  thrift_spec = (
19828 
    None, # 0
19829 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19830 
    (2, TType.I32, 'category', None, None, ), # 2
19831 
  )
19832 
 
19833 
  def __init__(self, transactionId=None, category=None,):
19834 
    self.transactionId = transactionId
19835 
    self.category = category
19836 
 
19837 
  def read(self, iprot):
19838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19840 
      return
19841 
    iprot.readStructBegin()
19842 
    while True:
19843 
      (fname, ftype, fid) = iprot.readFieldBegin()
19844 
      if ftype == TType.STOP:
19845 
        break
19846 
      if fid == 1:
19847 
        if ftype == TType.I64:
19848 
          self.transactionId = iprot.readI64();
19849 
        else:
19850 
          iprot.skip(ftype)
19851 
      elif fid == 2:
19852 
        if ftype == TType.I32:
19853 
          self.category = iprot.readI32();
19854 
        else:
19855 
          iprot.skip(ftype)
19856 
      else:
19857 
        iprot.skip(ftype)
19858 
      iprot.readFieldEnd()
19859 
    iprot.readStructEnd()
19860 
 
19861 
  def write(self, oprot):
19862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19864 
      return
19865 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19866 
    if self.transactionId is not None:
19867 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19868 
      oprot.writeI64(self.transactionId)
19869 
      oprot.writeFieldEnd()
19870 
    if self.category is not None:
19871 
      oprot.writeFieldBegin('category', TType.I32, 2)
19872 
      oprot.writeI32(self.category)
19873 
      oprot.writeFieldEnd()
19874 
    oprot.writeFieldStop()
19875 
    oprot.writeStructEnd()
19876 
 
19877 
  def validate(self):
19878 
    return
19879 
 
19880 
 
19881 
  def __repr__(self):
19882 
    L = ['%s=%r' % (key, value)
19883 
      for key, value in self.__dict__.iteritems()]
19884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19885 
 
19886 
  def __eq__(self, other):
19887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19888 
 
19889 
  def __ne__(self, other):
19890 
    return not (self == other)
19891 
 
19892 
class markTransactionAsProcessed_result:
19893 
 
19894 
  thrift_spec = (
19895 
  )
19896 
 
19897 
  def read(self, iprot):
19898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19900 
      return
19901 
    iprot.readStructBegin()
19902 
    while True:
19903 
      (fname, ftype, fid) = iprot.readFieldBegin()
19904 
      if ftype == TType.STOP:
19905 
        break
19906 
      else:
19907 
        iprot.skip(ftype)
19908 
      iprot.readFieldEnd()
19909 
    iprot.readStructEnd()
19910 
 
19911 
  def write(self, oprot):
19912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19914 
      return
19915 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19916 
    oprot.writeFieldStop()
19917 
    oprot.writeStructEnd()
19918 
 
19919 
  def validate(self):
19920 
    return
19921 
 
19922 
 
19923 
  def __repr__(self):
19924 
    L = ['%s=%r' % (key, value)
19925 
      for key, value in self.__dict__.iteritems()]
19926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19927 
 
19928 
  def __eq__(self, other):
19929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19930 
 
19931 
  def __ne__(self, other):
19932 
    return not (self == other)
4018 chandransh 19933 
 
19934 
class getItemWiseRiskyOrdersCount_args:
19935 
 
19936 
  thrift_spec = (
19937 
  )
19938 
 
19939 
  def read(self, iprot):
19940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19942 
      return
19943 
    iprot.readStructBegin()
19944 
    while True:
19945 
      (fname, ftype, fid) = iprot.readFieldBegin()
19946 
      if ftype == TType.STOP:
19947 
        break
19948 
      else:
19949 
        iprot.skip(ftype)
19950 
      iprot.readFieldEnd()
19951 
    iprot.readStructEnd()
19952 
 
19953 
  def write(self, oprot):
19954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19956 
      return
19957 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19958 
    oprot.writeFieldStop()
19959 
    oprot.writeStructEnd()
19960 
 
19961 
  def validate(self):
19962 
    return
19963 
 
19964 
 
19965 
  def __repr__(self):
19966 
    L = ['%s=%r' % (key, value)
19967 
      for key, value in self.__dict__.iteritems()]
19968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19969 
 
19970 
  def __eq__(self, other):
19971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19972 
 
19973 
  def __ne__(self, other):
19974 
    return not (self == other)
19975 
 
19976 
class getItemWiseRiskyOrdersCount_result:
19977 
  """
19978 
  Attributes:
19979 
   - success
19980 
  """
19981 
 
19982 
  thrift_spec = (
19983 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19984 
  )
19985 
 
19986 
  def __init__(self, success=None,):
19987 
    self.success = success
19988 
 
19989 
  def read(self, iprot):
19990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19992 
      return
19993 
    iprot.readStructBegin()
19994 
    while True:
19995 
      (fname, ftype, fid) = iprot.readFieldBegin()
19996 
      if ftype == TType.STOP:
19997 
        break
19998 
      if fid == 0:
19999 
        if ftype == TType.MAP:
20000 
          self.success = {}
6188 rajveer 20001 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20002 
          for _i482 in xrange(_size478):
20003 
            _key483 = iprot.readI64();
20004 
            _val484 = iprot.readI64();
20005 
            self.success[_key483] = _val484
4018 chandransh 20006 
          iprot.readMapEnd()
20007 
        else:
20008 
          iprot.skip(ftype)
20009 
      else:
20010 
        iprot.skip(ftype)
20011 
      iprot.readFieldEnd()
20012 
    iprot.readStructEnd()
20013 
 
20014 
  def write(self, oprot):
20015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20017 
      return
20018 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20019 
    if self.success is not None:
20020 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20021 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20022 
      for kiter485,viter486 in self.success.items():
20023 
        oprot.writeI64(kiter485)
20024 
        oprot.writeI64(viter486)
4018 chandransh 20025 
      oprot.writeMapEnd()
20026 
      oprot.writeFieldEnd()
20027 
    oprot.writeFieldStop()
20028 
    oprot.writeStructEnd()
20029 
 
20030 
  def validate(self):
20031 
    return
20032 
 
20033 
 
20034 
  def __repr__(self):
20035 
    L = ['%s=%r' % (key, value)
20036 
      for key, value in self.__dict__.iteritems()]
20037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20038 
 
20039 
  def __eq__(self, other):
20040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20041 
 
20042 
  def __ne__(self, other):
20043 
    return not (self == other)
4247 rajveer 20044 
 
4295 varun.gupt 20045 
class getOrdersForItemIds_args:
20046 
  """
20047 
  Attributes:
20048 
   - itemIds
20049 
  """
20050 
 
20051 
  thrift_spec = (
20052 
    None, # 0
20053 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20054 
  )
20055 
 
20056 
  def __init__(self, itemIds=None,):
20057 
    self.itemIds = itemIds
20058 
 
20059 
  def read(self, iprot):
20060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20062 
      return
20063 
    iprot.readStructBegin()
20064 
    while True:
20065 
      (fname, ftype, fid) = iprot.readFieldBegin()
20066 
      if ftype == TType.STOP:
20067 
        break
20068 
      if fid == 1:
20069 
        if ftype == TType.LIST:
20070 
          self.itemIds = []
6188 rajveer 20071 
          (_etype490, _size487) = iprot.readListBegin()
20072 
          for _i491 in xrange(_size487):
20073 
            _elem492 = iprot.readI64();
20074 
            self.itemIds.append(_elem492)
4295 varun.gupt 20075 
          iprot.readListEnd()
20076 
        else:
20077 
          iprot.skip(ftype)
20078 
      else:
20079 
        iprot.skip(ftype)
20080 
      iprot.readFieldEnd()
20081 
    iprot.readStructEnd()
20082 
 
20083 
  def write(self, oprot):
20084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20086 
      return
20087 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20088 
    if self.itemIds is not None:
20089 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20090 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20091 
      for iter493 in self.itemIds:
20092 
        oprot.writeI64(iter493)
4295 varun.gupt 20093 
      oprot.writeListEnd()
20094 
      oprot.writeFieldEnd()
20095 
    oprot.writeFieldStop()
20096 
    oprot.writeStructEnd()
20097 
 
20098 
  def validate(self):
20099 
    return
20100 
 
20101 
 
20102 
  def __repr__(self):
20103 
    L = ['%s=%r' % (key, value)
20104 
      for key, value in self.__dict__.iteritems()]
20105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20106 
 
20107 
  def __eq__(self, other):
20108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20109 
 
20110 
  def __ne__(self, other):
20111 
    return not (self == other)
20112 
 
20113 
class getOrdersForItemIds_result:
20114 
  """
20115 
  Attributes:
20116 
   - success
20117 
  """
20118 
 
20119 
  thrift_spec = (
20120 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20121 
  )
20122 
 
20123 
  def __init__(self, success=None,):
20124 
    self.success = success
20125 
 
20126 
  def read(self, iprot):
20127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20129 
      return
20130 
    iprot.readStructBegin()
20131 
    while True:
20132 
      (fname, ftype, fid) = iprot.readFieldBegin()
20133 
      if ftype == TType.STOP:
20134 
        break
20135 
      if fid == 0:
20136 
        if ftype == TType.LIST:
20137 
          self.success = []
6188 rajveer 20138 
          (_etype497, _size494) = iprot.readListBegin()
20139 
          for _i498 in xrange(_size494):
20140 
            _elem499 = Order()
20141 
            _elem499.read(iprot)
20142 
            self.success.append(_elem499)
4295 varun.gupt 20143 
          iprot.readListEnd()
20144 
        else:
20145 
          iprot.skip(ftype)
20146 
      else:
20147 
        iprot.skip(ftype)
20148 
      iprot.readFieldEnd()
20149 
    iprot.readStructEnd()
20150 
 
20151 
  def write(self, oprot):
20152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20154 
      return
20155 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20156 
    if self.success is not None:
20157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20159 
      for iter500 in self.success:
20160 
        iter500.write(oprot)
4295 varun.gupt 20161 
      oprot.writeListEnd()
20162 
      oprot.writeFieldEnd()
20163 
    oprot.writeFieldStop()
20164 
    oprot.writeStructEnd()
20165 
 
20166 
  def validate(self):
20167 
    return
20168 
 
20169 
 
20170 
  def __repr__(self):
20171 
    L = ['%s=%r' % (key, value)
20172 
      for key, value in self.__dict__.iteritems()]
20173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20174 
 
20175 
  def __eq__(self, other):
20176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20177 
 
20178 
  def __ne__(self, other):
20179 
    return not (self == other)
20180 
 
4247 rajveer 20181 
class markOrderCancellationRequestReceived_args:
20182 
  """
20183 
  Attributes:
20184 
   - orderId
20185 
  """
20186 
 
20187 
  thrift_spec = (
20188 
    None, # 0
20189 
    (1, TType.I64, 'orderId', None, None, ), # 1
20190 
  )
20191 
 
20192 
  def __init__(self, orderId=None,):
20193 
    self.orderId = orderId
20194 
 
20195 
  def read(self, iprot):
20196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20198 
      return
20199 
    iprot.readStructBegin()
20200 
    while True:
20201 
      (fname, ftype, fid) = iprot.readFieldBegin()
20202 
      if ftype == TType.STOP:
20203 
        break
20204 
      if fid == 1:
20205 
        if ftype == TType.I64:
20206 
          self.orderId = iprot.readI64();
20207 
        else:
20208 
          iprot.skip(ftype)
20209 
      else:
20210 
        iprot.skip(ftype)
20211 
      iprot.readFieldEnd()
20212 
    iprot.readStructEnd()
20213 
 
20214 
  def write(self, oprot):
20215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20217 
      return
20218 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20219 
    if self.orderId is not None:
20220 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20221 
      oprot.writeI64(self.orderId)
20222 
      oprot.writeFieldEnd()
20223 
    oprot.writeFieldStop()
20224 
    oprot.writeStructEnd()
20225 
 
20226 
  def validate(self):
20227 
    return
20228 
 
20229 
 
20230 
  def __repr__(self):
20231 
    L = ['%s=%r' % (key, value)
20232 
      for key, value in self.__dict__.iteritems()]
20233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20234 
 
20235 
  def __eq__(self, other):
20236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20237 
 
20238 
  def __ne__(self, other):
20239 
    return not (self == other)
20240 
 
20241 
class markOrderCancellationRequestReceived_result:
20242 
  """
20243 
  Attributes:
20244 
   - ex
20245 
  """
20246 
 
20247 
  thrift_spec = (
20248 
    None, # 0
20249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20250 
  )
20251 
 
20252 
  def __init__(self, ex=None,):
20253 
    self.ex = ex
20254 
 
20255 
  def read(self, iprot):
20256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20258 
      return
20259 
    iprot.readStructBegin()
20260 
    while True:
20261 
      (fname, ftype, fid) = iprot.readFieldBegin()
20262 
      if ftype == TType.STOP:
20263 
        break
20264 
      if fid == 1:
20265 
        if ftype == TType.STRUCT:
20266 
          self.ex = TransactionServiceException()
20267 
          self.ex.read(iprot)
20268 
        else:
20269 
          iprot.skip(ftype)
20270 
      else:
20271 
        iprot.skip(ftype)
20272 
      iprot.readFieldEnd()
20273 
    iprot.readStructEnd()
20274 
 
20275 
  def write(self, oprot):
20276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20278 
      return
20279 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20280 
    if self.ex is not None:
20281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20282 
      self.ex.write(oprot)
20283 
      oprot.writeFieldEnd()
20284 
    oprot.writeFieldStop()
20285 
    oprot.writeStructEnd()
20286 
 
20287 
  def validate(self):
20288 
    return
20289 
 
20290 
 
20291 
  def __repr__(self):
20292 
    L = ['%s=%r' % (key, value)
20293 
      for key, value in self.__dict__.iteritems()]
20294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20295 
 
20296 
  def __eq__(self, other):
20297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20298 
 
20299 
  def __ne__(self, other):
20300 
    return not (self == other)
20301 
 
20302 
class markOrderCancellationRequestConfirmed_args:
20303 
  """
20304 
  Attributes:
20305 
   - orderId
20306 
  """
20307 
 
20308 
  thrift_spec = (
20309 
    None, # 0
20310 
    (1, TType.I64, 'orderId', None, None, ), # 1
20311 
  )
20312 
 
20313 
  def __init__(self, orderId=None,):
20314 
    self.orderId = orderId
20315 
 
20316 
  def read(self, iprot):
20317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20319 
      return
20320 
    iprot.readStructBegin()
20321 
    while True:
20322 
      (fname, ftype, fid) = iprot.readFieldBegin()
20323 
      if ftype == TType.STOP:
20324 
        break
20325 
      if fid == 1:
20326 
        if ftype == TType.I64:
20327 
          self.orderId = iprot.readI64();
20328 
        else:
20329 
          iprot.skip(ftype)
20330 
      else:
20331 
        iprot.skip(ftype)
20332 
      iprot.readFieldEnd()
20333 
    iprot.readStructEnd()
20334 
 
20335 
  def write(self, oprot):
20336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20338 
      return
20339 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20340 
    if self.orderId is not None:
20341 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20342 
      oprot.writeI64(self.orderId)
20343 
      oprot.writeFieldEnd()
20344 
    oprot.writeFieldStop()
20345 
    oprot.writeStructEnd()
20346 
 
20347 
  def validate(self):
20348 
    return
20349 
 
20350 
 
20351 
  def __repr__(self):
20352 
    L = ['%s=%r' % (key, value)
20353 
      for key, value in self.__dict__.iteritems()]
20354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20355 
 
20356 
  def __eq__(self, other):
20357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20358 
 
20359 
  def __ne__(self, other):
20360 
    return not (self == other)
20361 
 
20362 
class markOrderCancellationRequestConfirmed_result:
20363 
  """
20364 
  Attributes:
20365 
   - ex
20366 
  """
20367 
 
20368 
  thrift_spec = (
20369 
    None, # 0
20370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20371 
  )
20372 
 
20373 
  def __init__(self, ex=None,):
20374 
    self.ex = ex
20375 
 
20376 
  def read(self, iprot):
20377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20379 
      return
20380 
    iprot.readStructBegin()
20381 
    while True:
20382 
      (fname, ftype, fid) = iprot.readFieldBegin()
20383 
      if ftype == TType.STOP:
20384 
        break
20385 
      if fid == 1:
20386 
        if ftype == TType.STRUCT:
20387 
          self.ex = TransactionServiceException()
20388 
          self.ex.read(iprot)
20389 
        else:
20390 
          iprot.skip(ftype)
20391 
      else:
20392 
        iprot.skip(ftype)
20393 
      iprot.readFieldEnd()
20394 
    iprot.readStructEnd()
20395 
 
20396 
  def write(self, oprot):
20397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20399 
      return
20400 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20401 
    if self.ex is not None:
20402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20403 
      self.ex.write(oprot)
20404 
      oprot.writeFieldEnd()
20405 
    oprot.writeFieldStop()
20406 
    oprot.writeStructEnd()
20407 
 
20408 
  def validate(self):
20409 
    return
20410 
 
20411 
 
20412 
  def __repr__(self):
20413 
    L = ['%s=%r' % (key, value)
20414 
      for key, value in self.__dict__.iteritems()]
20415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20416 
 
20417 
  def __eq__(self, other):
20418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20419 
 
20420 
  def __ne__(self, other):
20421 
    return not (self == other)
20422 
 
20423 
class markOrderCancellationRequestDenied_args:
20424 
  """
20425 
  Attributes:
20426 
   - orderId
20427 
  """
20428 
 
20429 
  thrift_spec = (
20430 
    None, # 0
20431 
    (1, TType.I64, 'orderId', None, None, ), # 1
20432 
  )
20433 
 
20434 
  def __init__(self, orderId=None,):
20435 
    self.orderId = orderId
20436 
 
20437 
  def read(self, iprot):
20438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20440 
      return
20441 
    iprot.readStructBegin()
20442 
    while True:
20443 
      (fname, ftype, fid) = iprot.readFieldBegin()
20444 
      if ftype == TType.STOP:
20445 
        break
20446 
      if fid == 1:
20447 
        if ftype == TType.I64:
20448 
          self.orderId = iprot.readI64();
20449 
        else:
20450 
          iprot.skip(ftype)
20451 
      else:
20452 
        iprot.skip(ftype)
20453 
      iprot.readFieldEnd()
20454 
    iprot.readStructEnd()
20455 
 
20456 
  def write(self, oprot):
20457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20459 
      return
20460 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20461 
    if self.orderId is not None:
20462 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20463 
      oprot.writeI64(self.orderId)
20464 
      oprot.writeFieldEnd()
20465 
    oprot.writeFieldStop()
20466 
    oprot.writeStructEnd()
20467 
 
20468 
  def validate(self):
20469 
    return
20470 
 
20471 
 
20472 
  def __repr__(self):
20473 
    L = ['%s=%r' % (key, value)
20474 
      for key, value in self.__dict__.iteritems()]
20475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20476 
 
20477 
  def __eq__(self, other):
20478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20479 
 
20480 
  def __ne__(self, other):
20481 
    return not (self == other)
20482 
 
20483 
class markOrderCancellationRequestDenied_result:
20484 
  """
20485 
  Attributes:
20486 
   - ex
20487 
  """
20488 
 
20489 
  thrift_spec = (
20490 
    None, # 0
20491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20492 
  )
20493 
 
20494 
  def __init__(self, ex=None,):
20495 
    self.ex = ex
20496 
 
20497 
  def read(self, iprot):
20498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20500 
      return
20501 
    iprot.readStructBegin()
20502 
    while True:
20503 
      (fname, ftype, fid) = iprot.readFieldBegin()
20504 
      if ftype == TType.STOP:
20505 
        break
20506 
      if fid == 1:
20507 
        if ftype == TType.STRUCT:
20508 
          self.ex = TransactionServiceException()
20509 
          self.ex.read(iprot)
20510 
        else:
20511 
          iprot.skip(ftype)
20512 
      else:
20513 
        iprot.skip(ftype)
20514 
      iprot.readFieldEnd()
20515 
    iprot.readStructEnd()
20516 
 
20517 
  def write(self, oprot):
20518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20520 
      return
20521 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20522 
    if self.ex is not None:
20523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20524 
      self.ex.write(oprot)
20525 
      oprot.writeFieldEnd()
20526 
    oprot.writeFieldStop()
20527 
    oprot.writeStructEnd()
20528 
 
20529 
  def validate(self):
20530 
    return
20531 
 
20532 
 
20533 
  def __repr__(self):
20534 
    L = ['%s=%r' % (key, value)
20535 
      for key, value in self.__dict__.iteritems()]
20536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20537 
 
20538 
  def __eq__(self, other):
20539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20540 
 
20541 
  def __ne__(self, other):
20542 
    return not (self == other)
20543 
 
4258 rajveer 20544 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20545 
  """
20546 
  Attributes:
4258 rajveer 20547 
   - transactionId
4247 rajveer 20548 
  """
20549 
 
20550 
  thrift_spec = (
20551 
    None, # 0
4258 rajveer 20552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20553 
  )
20554 
 
4258 rajveer 20555 
  def __init__(self, transactionId=None,):
20556 
    self.transactionId = transactionId
4247 rajveer 20557 
 
20558 
  def read(self, iprot):
20559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20561 
      return
20562 
    iprot.readStructBegin()
20563 
    while True:
20564 
      (fname, ftype, fid) = iprot.readFieldBegin()
20565 
      if ftype == TType.STOP:
20566 
        break
20567 
      if fid == 1:
20568 
        if ftype == TType.I64:
4258 rajveer 20569 
          self.transactionId = iprot.readI64();
4247 rajveer 20570 
        else:
20571 
          iprot.skip(ftype)
20572 
      else:
20573 
        iprot.skip(ftype)
20574 
      iprot.readFieldEnd()
20575 
    iprot.readStructEnd()
20576 
 
20577 
  def write(self, oprot):
20578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20580 
      return
4258 rajveer 20581 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20582 
    if self.transactionId is not None:
20583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20584 
      oprot.writeI64(self.transactionId)
4247 rajveer 20585 
      oprot.writeFieldEnd()
20586 
    oprot.writeFieldStop()
20587 
    oprot.writeStructEnd()
20588 
 
20589 
  def validate(self):
20590 
    return
20591 
 
20592 
 
20593 
  def __repr__(self):
20594 
    L = ['%s=%r' % (key, value)
20595 
      for key, value in self.__dict__.iteritems()]
20596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20597 
 
20598 
  def __eq__(self, other):
20599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20600 
 
20601 
  def __ne__(self, other):
20602 
    return not (self == other)
20603 
 
4258 rajveer 20604 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20605 
  """
20606 
  Attributes:
20607 
   - ex
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    None, # 0
20612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20613 
  )
20614 
 
20615 
  def __init__(self, ex=None,):
20616 
    self.ex = ex
20617 
 
20618 
  def read(self, iprot):
20619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20621 
      return
20622 
    iprot.readStructBegin()
20623 
    while True:
20624 
      (fname, ftype, fid) = iprot.readFieldBegin()
20625 
      if ftype == TType.STOP:
20626 
        break
20627 
      if fid == 1:
20628 
        if ftype == TType.STRUCT:
20629 
          self.ex = TransactionServiceException()
20630 
          self.ex.read(iprot)
20631 
        else:
20632 
          iprot.skip(ftype)
20633 
      else:
20634 
        iprot.skip(ftype)
20635 
      iprot.readFieldEnd()
20636 
    iprot.readStructEnd()
20637 
 
20638 
  def write(self, oprot):
20639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20641 
      return
4258 rajveer 20642 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20643 
    if self.ex is not None:
20644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20645 
      self.ex.write(oprot)
20646 
      oprot.writeFieldEnd()
20647 
    oprot.writeFieldStop()
20648 
    oprot.writeStructEnd()
20649 
 
20650 
  def validate(self):
20651 
    return
20652 
 
20653 
 
20654 
  def __repr__(self):
20655 
    L = ['%s=%r' % (key, value)
20656 
      for key, value in self.__dict__.iteritems()]
20657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20658 
 
20659 
  def __eq__(self, other):
20660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20661 
 
20662 
  def __ne__(self, other):
20663 
    return not (self == other)
4259 anupam.sin 20664 
 
20665 
class refundTransaction_args:
20666 
  """
20667 
  Attributes:
20668 
   - transactionId
20669 
   - refundedBy
20670 
   - reason
20671 
  """
20672 
 
20673 
  thrift_spec = (
20674 
    None, # 0
20675 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20676 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20677 
    (3, TType.STRING, 'reason', None, None, ), # 3
20678 
  )
20679 
 
20680 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20681 
    self.transactionId = transactionId
20682 
    self.refundedBy = refundedBy
20683 
    self.reason = reason
20684 
 
20685 
  def read(self, iprot):
20686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20688 
      return
20689 
    iprot.readStructBegin()
20690 
    while True:
20691 
      (fname, ftype, fid) = iprot.readFieldBegin()
20692 
      if ftype == TType.STOP:
20693 
        break
20694 
      if fid == 1:
20695 
        if ftype == TType.I64:
20696 
          self.transactionId = iprot.readI64();
20697 
        else:
20698 
          iprot.skip(ftype)
20699 
      elif fid == 2:
20700 
        if ftype == TType.STRING:
20701 
          self.refundedBy = iprot.readString();
20702 
        else:
20703 
          iprot.skip(ftype)
20704 
      elif fid == 3:
20705 
        if ftype == TType.STRING:
20706 
          self.reason = iprot.readString();
20707 
        else:
20708 
          iprot.skip(ftype)
20709 
      else:
20710 
        iprot.skip(ftype)
20711 
      iprot.readFieldEnd()
20712 
    iprot.readStructEnd()
20713 
 
20714 
  def write(self, oprot):
20715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20717 
      return
20718 
    oprot.writeStructBegin('refundTransaction_args')
20719 
    if self.transactionId is not None:
20720 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20721 
      oprot.writeI64(self.transactionId)
20722 
      oprot.writeFieldEnd()
20723 
    if self.refundedBy is not None:
20724 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20725 
      oprot.writeString(self.refundedBy)
20726 
      oprot.writeFieldEnd()
20727 
    if self.reason is not None:
20728 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20729 
      oprot.writeString(self.reason)
20730 
      oprot.writeFieldEnd()
20731 
    oprot.writeFieldStop()
20732 
    oprot.writeStructEnd()
20733 
 
20734 
  def validate(self):
20735 
    return
20736 
 
20737 
 
20738 
  def __repr__(self):
20739 
    L = ['%s=%r' % (key, value)
20740 
      for key, value in self.__dict__.iteritems()]
20741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20742 
 
20743 
  def __eq__(self, other):
20744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20745 
 
20746 
  def __ne__(self, other):
20747 
    return not (self == other)
20748 
 
20749 
class refundTransaction_result:
20750 
  """
20751 
  Attributes:
20752 
   - ex
20753 
  """
20754 
 
20755 
  thrift_spec = (
20756 
    None, # 0
20757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20758 
  )
20759 
 
20760 
  def __init__(self, ex=None,):
20761 
    self.ex = ex
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.STRUCT:
20774 
          self.ex = TransactionServiceException()
20775 
          self.ex.read(iprot)
20776 
        else:
20777 
          iprot.skip(ftype)
20778 
      else:
20779 
        iprot.skip(ftype)
20780 
      iprot.readFieldEnd()
20781 
    iprot.readStructEnd()
20782 
 
20783 
  def write(self, oprot):
20784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20786 
      return
20787 
    oprot.writeStructBegin('refundTransaction_result')
20788 
    if self.ex is not None:
20789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20790 
      self.ex.write(oprot)
20791 
      oprot.writeFieldEnd()
20792 
    oprot.writeFieldStop()
20793 
    oprot.writeStructEnd()
20794 
 
20795 
  def validate(self):
20796 
    return
20797 
 
20798 
 
20799 
  def __repr__(self):
20800 
    L = ['%s=%r' % (key, value)
20801 
      for key, value in self.__dict__.iteritems()]
20802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20803 
 
20804 
  def __eq__(self, other):
20805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20806 
 
20807 
  def __ne__(self, other):
20808 
    return not (self == other)
4285 rajveer 20809 
 
4324 mandeep.dh 20810 
class updateShipmentAddress_args:
20811 
  """
20812 
  Attributes:
20813 
   - orderId
20814 
   - addressId
20815 
  """
20816 
 
20817 
  thrift_spec = (
20818 
    None, # 0
20819 
    (1, TType.I64, 'orderId', None, None, ), # 1
20820 
    (2, TType.I64, 'addressId', None, None, ), # 2
20821 
  )
20822 
 
20823 
  def __init__(self, orderId=None, addressId=None,):
20824 
    self.orderId = orderId
20825 
    self.addressId = addressId
20826 
 
20827 
  def read(self, iprot):
20828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20830 
      return
20831 
    iprot.readStructBegin()
20832 
    while True:
20833 
      (fname, ftype, fid) = iprot.readFieldBegin()
20834 
      if ftype == TType.STOP:
20835 
        break
20836 
      if fid == 1:
20837 
        if ftype == TType.I64:
20838 
          self.orderId = iprot.readI64();
20839 
        else:
20840 
          iprot.skip(ftype)
20841 
      elif fid == 2:
20842 
        if ftype == TType.I64:
20843 
          self.addressId = iprot.readI64();
20844 
        else:
20845 
          iprot.skip(ftype)
20846 
      else:
20847 
        iprot.skip(ftype)
20848 
      iprot.readFieldEnd()
20849 
    iprot.readStructEnd()
20850 
 
20851 
  def write(self, oprot):
20852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20854 
      return
20855 
    oprot.writeStructBegin('updateShipmentAddress_args')
20856 
    if self.orderId is not None:
20857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20858 
      oprot.writeI64(self.orderId)
20859 
      oprot.writeFieldEnd()
20860 
    if self.addressId is not None:
20861 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20862 
      oprot.writeI64(self.addressId)
20863 
      oprot.writeFieldEnd()
20864 
    oprot.writeFieldStop()
20865 
    oprot.writeStructEnd()
20866 
 
20867 
  def validate(self):
20868 
    return
20869 
 
20870 
 
20871 
  def __repr__(self):
20872 
    L = ['%s=%r' % (key, value)
20873 
      for key, value in self.__dict__.iteritems()]
20874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20875 
 
20876 
  def __eq__(self, other):
20877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20878 
 
20879 
  def __ne__(self, other):
20880 
    return not (self == other)
20881 
 
20882 
class updateShipmentAddress_result:
20883 
  """
20884 
  Attributes:
20885 
   - ex
20886 
  """
20887 
 
20888 
  thrift_spec = (
20889 
    None, # 0
20890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20891 
  )
20892 
 
20893 
  def __init__(self, ex=None,):
20894 
    self.ex = ex
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.STRUCT:
20907 
          self.ex = TransactionServiceException()
20908 
          self.ex.read(iprot)
20909 
        else:
20910 
          iprot.skip(ftype)
20911 
      else:
20912 
        iprot.skip(ftype)
20913 
      iprot.readFieldEnd()
20914 
    iprot.readStructEnd()
20915 
 
20916 
  def write(self, oprot):
20917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20919 
      return
20920 
    oprot.writeStructBegin('updateShipmentAddress_result')
20921 
    if self.ex is not None:
20922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20923 
      self.ex.write(oprot)
20924 
      oprot.writeFieldEnd()
20925 
    oprot.writeFieldStop()
20926 
    oprot.writeStructEnd()
20927 
 
20928 
  def validate(self):
20929 
    return
20930 
 
20931 
 
20932 
  def __repr__(self):
20933 
    L = ['%s=%r' % (key, value)
20934 
      for key, value in self.__dict__.iteritems()]
20935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20936 
 
20937 
  def __eq__(self, other):
20938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20939 
 
20940 
  def __ne__(self, other):
20941 
    return not (self == other)
20942 
 
4285 rajveer 20943 
class acceptOrdersForItemId_args:
20944 
  """
20945 
  Attributes:
20946 
   - itemId
20947 
   - inventory
20948 
  """
20949 
 
20950 
  thrift_spec = (
20951 
    None, # 0
20952 
    (1, TType.I64, 'itemId', None, None, ), # 1
20953 
    (2, TType.I64, 'inventory', None, None, ), # 2
20954 
  )
20955 
 
20956 
  def __init__(self, itemId=None, inventory=None,):
20957 
    self.itemId = itemId
20958 
    self.inventory = inventory
20959 
 
20960 
  def read(self, iprot):
20961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20963 
      return
20964 
    iprot.readStructBegin()
20965 
    while True:
20966 
      (fname, ftype, fid) = iprot.readFieldBegin()
20967 
      if ftype == TType.STOP:
20968 
        break
20969 
      if fid == 1:
20970 
        if ftype == TType.I64:
20971 
          self.itemId = iprot.readI64();
20972 
        else:
20973 
          iprot.skip(ftype)
20974 
      elif fid == 2:
20975 
        if ftype == TType.I64:
20976 
          self.inventory = iprot.readI64();
20977 
        else:
20978 
          iprot.skip(ftype)
20979 
      else:
20980 
        iprot.skip(ftype)
20981 
      iprot.readFieldEnd()
20982 
    iprot.readStructEnd()
20983 
 
20984 
  def write(self, oprot):
20985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20987 
      return
20988 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20989 
    if self.itemId is not None:
20990 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20991 
      oprot.writeI64(self.itemId)
20992 
      oprot.writeFieldEnd()
20993 
    if self.inventory is not None:
20994 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20995 
      oprot.writeI64(self.inventory)
20996 
      oprot.writeFieldEnd()
20997 
    oprot.writeFieldStop()
20998 
    oprot.writeStructEnd()
20999 
 
21000 
  def validate(self):
21001 
    return
21002 
 
21003 
 
21004 
  def __repr__(self):
21005 
    L = ['%s=%r' % (key, value)
21006 
      for key, value in self.__dict__.iteritems()]
21007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21008 
 
21009 
  def __eq__(self, other):
21010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21011 
 
21012 
  def __ne__(self, other):
21013 
    return not (self == other)
21014 
 
21015 
class acceptOrdersForItemId_result:
21016 
  """
21017 
  Attributes:
21018 
   - success
21019 
   - ex
21020 
  """
21021 
 
21022 
  thrift_spec = (
21023 
    (0, TType.BOOL, 'success', None, None, ), # 0
21024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21025 
  )
21026 
 
21027 
  def __init__(self, success=None, ex=None,):
21028 
    self.success = success
21029 
    self.ex = ex
21030 
 
21031 
  def read(self, iprot):
21032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21034 
      return
21035 
    iprot.readStructBegin()
21036 
    while True:
21037 
      (fname, ftype, fid) = iprot.readFieldBegin()
21038 
      if ftype == TType.STOP:
21039 
        break
21040 
      if fid == 0:
21041 
        if ftype == TType.BOOL:
21042 
          self.success = iprot.readBool();
21043 
        else:
21044 
          iprot.skip(ftype)
21045 
      elif fid == 1:
21046 
        if ftype == TType.STRUCT:
21047 
          self.ex = TransactionServiceException()
21048 
          self.ex.read(iprot)
21049 
        else:
21050 
          iprot.skip(ftype)
21051 
      else:
21052 
        iprot.skip(ftype)
21053 
      iprot.readFieldEnd()
21054 
    iprot.readStructEnd()
21055 
 
21056 
  def write(self, oprot):
21057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21059 
      return
21060 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21061 
    if self.success is not None:
21062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21063 
      oprot.writeBool(self.success)
21064 
      oprot.writeFieldEnd()
21065 
    if self.ex is not None:
21066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21067 
      self.ex.write(oprot)
21068 
      oprot.writeFieldEnd()
21069 
    oprot.writeFieldStop()
21070 
    oprot.writeStructEnd()
21071 
 
21072 
  def validate(self):
21073 
    return
21074 
 
21075 
 
21076 
  def __repr__(self):
21077 
    L = ['%s=%r' % (key, value)
21078 
      for key, value in self.__dict__.iteritems()]
21079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21080 
 
21081 
  def __eq__(self, other):
21082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21083 
 
21084 
  def __ne__(self, other):
21085 
    return not (self == other)
4303 rajveer 21086 
 
21087 
class markOrdersAsPORaised_args:
21088 
  """
21089 
  Attributes:
21090 
   - vendorId
21091 
   - itemId
21092 
   - quantity
21093 
   - estimate
4369 rajveer 21094 
   - isReminder
4303 rajveer 21095 
  """
21096 
 
21097 
  thrift_spec = (
21098 
    None, # 0
21099 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21100 
    (2, TType.I64, 'itemId', None, None, ), # 2
21101 
    (3, TType.I64, 'quantity', None, None, ), # 3
21102 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21103 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21104 
  )
21105 
 
4369 rajveer 21106 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21107 
    self.vendorId = vendorId
21108 
    self.itemId = itemId
21109 
    self.quantity = quantity
21110 
    self.estimate = estimate
4369 rajveer 21111 
    self.isReminder = isReminder
4303 rajveer 21112 
 
21113 
  def read(self, iprot):
21114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21116 
      return
21117 
    iprot.readStructBegin()
21118 
    while True:
21119 
      (fname, ftype, fid) = iprot.readFieldBegin()
21120 
      if ftype == TType.STOP:
21121 
        break
21122 
      if fid == 1:
21123 
        if ftype == TType.I64:
21124 
          self.vendorId = iprot.readI64();
21125 
        else:
21126 
          iprot.skip(ftype)
21127 
      elif fid == 2:
21128 
        if ftype == TType.I64:
21129 
          self.itemId = iprot.readI64();
21130 
        else:
21131 
          iprot.skip(ftype)
21132 
      elif fid == 3:
21133 
        if ftype == TType.I64:
21134 
          self.quantity = iprot.readI64();
21135 
        else:
21136 
          iprot.skip(ftype)
21137 
      elif fid == 4:
21138 
        if ftype == TType.I64:
21139 
          self.estimate = iprot.readI64();
21140 
        else:
21141 
          iprot.skip(ftype)
4369 rajveer 21142 
      elif fid == 5:
21143 
        if ftype == TType.BOOL:
21144 
          self.isReminder = iprot.readBool();
21145 
        else:
21146 
          iprot.skip(ftype)
4303 rajveer 21147 
      else:
21148 
        iprot.skip(ftype)
21149 
      iprot.readFieldEnd()
21150 
    iprot.readStructEnd()
21151 
 
21152 
  def write(self, oprot):
21153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21155 
      return
21156 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21157 
    if self.vendorId is not None:
21158 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21159 
      oprot.writeI64(self.vendorId)
21160 
      oprot.writeFieldEnd()
21161 
    if self.itemId is not None:
21162 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21163 
      oprot.writeI64(self.itemId)
21164 
      oprot.writeFieldEnd()
21165 
    if self.quantity is not None:
21166 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21167 
      oprot.writeI64(self.quantity)
21168 
      oprot.writeFieldEnd()
21169 
    if self.estimate is not None:
21170 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21171 
      oprot.writeI64(self.estimate)
21172 
      oprot.writeFieldEnd()
4369 rajveer 21173 
    if self.isReminder is not None:
21174 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21175 
      oprot.writeBool(self.isReminder)
21176 
      oprot.writeFieldEnd()
4303 rajveer 21177 
    oprot.writeFieldStop()
21178 
    oprot.writeStructEnd()
21179 
 
21180 
  def validate(self):
21181 
    return
21182 
 
21183 
 
21184 
  def __repr__(self):
21185 
    L = ['%s=%r' % (key, value)
21186 
      for key, value in self.__dict__.iteritems()]
21187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21188 
 
21189 
  def __eq__(self, other):
21190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21191 
 
21192 
  def __ne__(self, other):
21193 
    return not (self == other)
21194 
 
21195 
class markOrdersAsPORaised_result:
21196 
  """
21197 
  Attributes:
21198 
   - ex
21199 
  """
21200 
 
21201 
  thrift_spec = (
21202 
    None, # 0
21203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21204 
  )
21205 
 
21206 
  def __init__(self, ex=None,):
21207 
    self.ex = ex
21208 
 
21209 
  def read(self, iprot):
21210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21212 
      return
21213 
    iprot.readStructBegin()
21214 
    while True:
21215 
      (fname, ftype, fid) = iprot.readFieldBegin()
21216 
      if ftype == TType.STOP:
21217 
        break
21218 
      if fid == 1:
21219 
        if ftype == TType.STRUCT:
21220 
          self.ex = TransactionServiceException()
21221 
          self.ex.read(iprot)
21222 
        else:
21223 
          iprot.skip(ftype)
21224 
      else:
21225 
        iprot.skip(ftype)
21226 
      iprot.readFieldEnd()
21227 
    iprot.readStructEnd()
21228 
 
21229 
  def write(self, oprot):
21230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21232 
      return
21233 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21234 
    if self.ex is not None:
21235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21236 
      self.ex.write(oprot)
21237 
      oprot.writeFieldEnd()
21238 
    oprot.writeFieldStop()
21239 
    oprot.writeStructEnd()
21240 
 
21241 
  def validate(self):
21242 
    return
21243 
 
21244 
 
21245 
  def __repr__(self):
21246 
    L = ['%s=%r' % (key, value)
21247 
      for key, value in self.__dict__.iteritems()]
21248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21249 
 
21250 
  def __eq__(self, other):
21251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21252 
 
21253 
  def __ne__(self, other):
21254 
    return not (self == other)
21255 
 
21256 
class markOrdersAsReversalInitiated_args:
21257 
  """
21258 
  Attributes:
21259 
   - vendorId
21260 
   - itemId
21261 
   - quantity
21262 
   - estimate
4369 rajveer 21263 
   - isReminder
4303 rajveer 21264 
  """
21265 
 
21266 
  thrift_spec = (
21267 
    None, # 0
21268 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21269 
    (2, TType.I64, 'itemId', None, None, ), # 2
21270 
    (3, TType.I64, 'quantity', None, None, ), # 3
21271 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21272 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21273 
  )
21274 
 
4369 rajveer 21275 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21276 
    self.vendorId = vendorId
21277 
    self.itemId = itemId
21278 
    self.quantity = quantity
21279 
    self.estimate = estimate
4369 rajveer 21280 
    self.isReminder = isReminder
4303 rajveer 21281 
 
21282 
  def read(self, iprot):
21283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21285 
      return
21286 
    iprot.readStructBegin()
21287 
    while True:
21288 
      (fname, ftype, fid) = iprot.readFieldBegin()
21289 
      if ftype == TType.STOP:
21290 
        break
21291 
      if fid == 1:
21292 
        if ftype == TType.I64:
21293 
          self.vendorId = iprot.readI64();
21294 
        else:
21295 
          iprot.skip(ftype)
21296 
      elif fid == 2:
21297 
        if ftype == TType.I64:
21298 
          self.itemId = iprot.readI64();
21299 
        else:
21300 
          iprot.skip(ftype)
21301 
      elif fid == 3:
21302 
        if ftype == TType.I64:
21303 
          self.quantity = iprot.readI64();
21304 
        else:
21305 
          iprot.skip(ftype)
21306 
      elif fid == 4:
21307 
        if ftype == TType.I64:
21308 
          self.estimate = iprot.readI64();
21309 
        else:
21310 
          iprot.skip(ftype)
4369 rajveer 21311 
      elif fid == 5:
21312 
        if ftype == TType.BOOL:
21313 
          self.isReminder = iprot.readBool();
21314 
        else:
21315 
          iprot.skip(ftype)
4303 rajveer 21316 
      else:
21317 
        iprot.skip(ftype)
21318 
      iprot.readFieldEnd()
21319 
    iprot.readStructEnd()
21320 
 
21321 
  def write(self, oprot):
21322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21324 
      return
21325 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21326 
    if self.vendorId is not None:
21327 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21328 
      oprot.writeI64(self.vendorId)
21329 
      oprot.writeFieldEnd()
21330 
    if self.itemId is not None:
21331 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21332 
      oprot.writeI64(self.itemId)
21333 
      oprot.writeFieldEnd()
21334 
    if self.quantity is not None:
21335 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21336 
      oprot.writeI64(self.quantity)
21337 
      oprot.writeFieldEnd()
21338 
    if self.estimate is not None:
21339 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21340 
      oprot.writeI64(self.estimate)
21341 
      oprot.writeFieldEnd()
4369 rajveer 21342 
    if self.isReminder is not None:
21343 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21344 
      oprot.writeBool(self.isReminder)
21345 
      oprot.writeFieldEnd()
4303 rajveer 21346 
    oprot.writeFieldStop()
21347 
    oprot.writeStructEnd()
21348 
 
21349 
  def validate(self):
21350 
    return
21351 
 
21352 
 
21353 
  def __repr__(self):
21354 
    L = ['%s=%r' % (key, value)
21355 
      for key, value in self.__dict__.iteritems()]
21356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21357 
 
21358 
  def __eq__(self, other):
21359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21360 
 
21361 
  def __ne__(self, other):
21362 
    return not (self == other)
21363 
 
21364 
class markOrdersAsReversalInitiated_result:
21365 
  """
21366 
  Attributes:
21367 
   - ex
21368 
  """
21369 
 
21370 
  thrift_spec = (
21371 
    None, # 0
21372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21373 
  )
21374 
 
21375 
  def __init__(self, ex=None,):
21376 
    self.ex = ex
21377 
 
21378 
  def read(self, iprot):
21379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21381 
      return
21382 
    iprot.readStructBegin()
21383 
    while True:
21384 
      (fname, ftype, fid) = iprot.readFieldBegin()
21385 
      if ftype == TType.STOP:
21386 
        break
21387 
      if fid == 1:
21388 
        if ftype == TType.STRUCT:
21389 
          self.ex = TransactionServiceException()
21390 
          self.ex.read(iprot)
21391 
        else:
21392 
          iprot.skip(ftype)
21393 
      else:
21394 
        iprot.skip(ftype)
21395 
      iprot.readFieldEnd()
21396 
    iprot.readStructEnd()
21397 
 
21398 
  def write(self, oprot):
21399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21401 
      return
21402 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21403 
    if self.ex is not None:
21404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21405 
      self.ex.write(oprot)
21406 
      oprot.writeFieldEnd()
21407 
    oprot.writeFieldStop()
21408 
    oprot.writeStructEnd()
21409 
 
21410 
  def validate(self):
21411 
    return
21412 
 
21413 
 
21414 
  def __repr__(self):
21415 
    L = ['%s=%r' % (key, value)
21416 
      for key, value in self.__dict__.iteritems()]
21417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21418 
 
21419 
  def __eq__(self, other):
21420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21421 
 
21422 
  def __ne__(self, other):
21423 
    return not (self == other)
21424 
 
21425 
class markOrdersAsNotAvailabke_args:
21426 
  """
21427 
  Attributes:
21428 
   - vendorId
21429 
   - itemId
21430 
   - quantity
21431 
   - estimate
4369 rajveer 21432 
   - isReminder
4303 rajveer 21433 
  """
21434 
 
21435 
  thrift_spec = (
21436 
    None, # 0
21437 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21438 
    (2, TType.I64, 'itemId', None, None, ), # 2
21439 
    (3, TType.I64, 'quantity', None, None, ), # 3
21440 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21441 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21442 
  )
21443 
 
4369 rajveer 21444 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21445 
    self.vendorId = vendorId
21446 
    self.itemId = itemId
21447 
    self.quantity = quantity
21448 
    self.estimate = estimate
4369 rajveer 21449 
    self.isReminder = isReminder
4303 rajveer 21450 
 
21451 
  def read(self, iprot):
21452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21454 
      return
21455 
    iprot.readStructBegin()
21456 
    while True:
21457 
      (fname, ftype, fid) = iprot.readFieldBegin()
21458 
      if ftype == TType.STOP:
21459 
        break
21460 
      if fid == 1:
21461 
        if ftype == TType.I64:
21462 
          self.vendorId = iprot.readI64();
21463 
        else:
21464 
          iprot.skip(ftype)
21465 
      elif fid == 2:
21466 
        if ftype == TType.I64:
21467 
          self.itemId = iprot.readI64();
21468 
        else:
21469 
          iprot.skip(ftype)
21470 
      elif fid == 3:
21471 
        if ftype == TType.I64:
21472 
          self.quantity = iprot.readI64();
21473 
        else:
21474 
          iprot.skip(ftype)
21475 
      elif fid == 4:
21476 
        if ftype == TType.I64:
21477 
          self.estimate = iprot.readI64();
21478 
        else:
21479 
          iprot.skip(ftype)
4369 rajveer 21480 
      elif fid == 5:
21481 
        if ftype == TType.BOOL:
21482 
          self.isReminder = iprot.readBool();
21483 
        else:
21484 
          iprot.skip(ftype)
4303 rajveer 21485 
      else:
21486 
        iprot.skip(ftype)
21487 
      iprot.readFieldEnd()
21488 
    iprot.readStructEnd()
21489 
 
21490 
  def write(self, oprot):
21491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21493 
      return
21494 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21495 
    if self.vendorId is not None:
21496 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21497 
      oprot.writeI64(self.vendorId)
21498 
      oprot.writeFieldEnd()
21499 
    if self.itemId is not None:
21500 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21501 
      oprot.writeI64(self.itemId)
21502 
      oprot.writeFieldEnd()
21503 
    if self.quantity is not None:
21504 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21505 
      oprot.writeI64(self.quantity)
21506 
      oprot.writeFieldEnd()
21507 
    if self.estimate is not None:
21508 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21509 
      oprot.writeI64(self.estimate)
21510 
      oprot.writeFieldEnd()
4369 rajveer 21511 
    if self.isReminder is not None:
21512 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21513 
      oprot.writeBool(self.isReminder)
21514 
      oprot.writeFieldEnd()
4303 rajveer 21515 
    oprot.writeFieldStop()
21516 
    oprot.writeStructEnd()
21517 
 
21518 
  def validate(self):
21519 
    return
21520 
 
21521 
 
21522 
  def __repr__(self):
21523 
    L = ['%s=%r' % (key, value)
21524 
      for key, value in self.__dict__.iteritems()]
21525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21526 
 
21527 
  def __eq__(self, other):
21528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21529 
 
21530 
  def __ne__(self, other):
21531 
    return not (self == other)
21532 
 
21533 
class markOrdersAsNotAvailabke_result:
21534 
  """
21535 
  Attributes:
21536 
   - ex
21537 
  """
21538 
 
21539 
  thrift_spec = (
21540 
    None, # 0
21541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21542 
  )
21543 
 
21544 
  def __init__(self, ex=None,):
21545 
    self.ex = ex
21546 
 
21547 
  def read(self, iprot):
21548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21550 
      return
21551 
    iprot.readStructBegin()
21552 
    while True:
21553 
      (fname, ftype, fid) = iprot.readFieldBegin()
21554 
      if ftype == TType.STOP:
21555 
        break
21556 
      if fid == 1:
21557 
        if ftype == TType.STRUCT:
21558 
          self.ex = TransactionServiceException()
21559 
          self.ex.read(iprot)
21560 
        else:
21561 
          iprot.skip(ftype)
21562 
      else:
21563 
        iprot.skip(ftype)
21564 
      iprot.readFieldEnd()
21565 
    iprot.readStructEnd()
21566 
 
21567 
  def write(self, oprot):
21568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21570 
      return
21571 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21572 
    if self.ex is not None:
21573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21574 
      self.ex.write(oprot)
21575 
      oprot.writeFieldEnd()
21576 
    oprot.writeFieldStop()
21577 
    oprot.writeStructEnd()
21578 
 
21579 
  def validate(self):
21580 
    return
21581 
 
21582 
 
21583 
  def __repr__(self):
21584 
    L = ['%s=%r' % (key, value)
21585 
      for key, value in self.__dict__.iteritems()]
21586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21587 
 
21588 
  def __eq__(self, other):
21589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21590 
 
21591 
  def __ne__(self, other):
21592 
    return not (self == other)
4369 rajveer 21593 
 
21594 
class markOrdersAsTimeout_args:
21595 
  """
21596 
  Attributes:
21597 
   - vendorId
21598 
  """
21599 
 
21600 
  thrift_spec = (
21601 
    None, # 0
21602 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21603 
  )
21604 
 
21605 
  def __init__(self, vendorId=None,):
21606 
    self.vendorId = vendorId
21607 
 
21608 
  def read(self, iprot):
21609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21611 
      return
21612 
    iprot.readStructBegin()
21613 
    while True:
21614 
      (fname, ftype, fid) = iprot.readFieldBegin()
21615 
      if ftype == TType.STOP:
21616 
        break
21617 
      if fid == 1:
21618 
        if ftype == TType.I64:
21619 
          self.vendorId = iprot.readI64();
21620 
        else:
21621 
          iprot.skip(ftype)
21622 
      else:
21623 
        iprot.skip(ftype)
21624 
      iprot.readFieldEnd()
21625 
    iprot.readStructEnd()
21626 
 
21627 
  def write(self, oprot):
21628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21630 
      return
21631 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21632 
    if self.vendorId is not None:
21633 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21634 
      oprot.writeI64(self.vendorId)
21635 
      oprot.writeFieldEnd()
21636 
    oprot.writeFieldStop()
21637 
    oprot.writeStructEnd()
21638 
 
21639 
  def validate(self):
21640 
    return
21641 
 
21642 
 
21643 
  def __repr__(self):
21644 
    L = ['%s=%r' % (key, value)
21645 
      for key, value in self.__dict__.iteritems()]
21646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21647 
 
21648 
  def __eq__(self, other):
21649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21650 
 
21651 
  def __ne__(self, other):
21652 
    return not (self == other)
21653 
 
21654 
class markOrdersAsTimeout_result:
21655 
  """
21656 
  Attributes:
21657 
   - success
21658 
   - ex
21659 
  """
21660 
 
21661 
  thrift_spec = (
21662 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21663 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21664 
  )
21665 
 
21666 
  def __init__(self, success=None, ex=None,):
21667 
    self.success = success
21668 
    self.ex = ex
21669 
 
21670 
  def read(self, iprot):
21671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21673 
      return
21674 
    iprot.readStructBegin()
21675 
    while True:
21676 
      (fname, ftype, fid) = iprot.readFieldBegin()
21677 
      if ftype == TType.STOP:
21678 
        break
21679 
      if fid == 0:
21680 
        if ftype == TType.MAP:
21681 
          self.success = {}
6188 rajveer 21682 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21683 
          for _i505 in xrange(_size501):
21684 
            _key506 = iprot.readI32();
21685 
            _val507 = TimeoutSummary()
21686 
            _val507.read(iprot)
21687 
            self.success[_key506] = _val507
4369 rajveer 21688 
          iprot.readMapEnd()
21689 
        else:
21690 
          iprot.skip(ftype)
21691 
      elif fid == 1:
21692 
        if ftype == TType.STRUCT:
21693 
          self.ex = TransactionServiceException()
21694 
          self.ex.read(iprot)
21695 
        else:
21696 
          iprot.skip(ftype)
21697 
      else:
21698 
        iprot.skip(ftype)
21699 
      iprot.readFieldEnd()
21700 
    iprot.readStructEnd()
21701 
 
21702 
  def write(self, oprot):
21703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21705 
      return
21706 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21707 
    if self.success is not None:
21708 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21709 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21710 
      for kiter508,viter509 in self.success.items():
21711 
        oprot.writeI32(kiter508)
21712 
        viter509.write(oprot)
4369 rajveer 21713 
      oprot.writeMapEnd()
21714 
      oprot.writeFieldEnd()
21715 
    if self.ex is not None:
21716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21717 
      self.ex.write(oprot)
21718 
      oprot.writeFieldEnd()
21719 
    oprot.writeFieldStop()
21720 
    oprot.writeStructEnd()
21721 
 
21722 
  def validate(self):
21723 
    return
21724 
 
21725 
 
21726 
  def __repr__(self):
21727 
    L = ['%s=%r' % (key, value)
21728 
      for key, value in self.__dict__.iteritems()]
21729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21730 
 
21731 
  def __eq__(self, other):
21732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21733 
 
21734 
  def __ne__(self, other):
21735 
    return not (self == other)
4386 anupam.sin 21736 
 
4662 rajveer 21737 
class markOrderAsLostInTransit_args:
21738 
  """
21739 
  Attributes:
21740 
   - orderId
21741 
  """
21742 
 
21743 
  thrift_spec = (
21744 
    None, # 0
21745 
    (1, TType.I64, 'orderId', None, None, ), # 1
21746 
  )
21747 
 
21748 
  def __init__(self, orderId=None,):
21749 
    self.orderId = orderId
21750 
 
21751 
  def read(self, iprot):
21752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21754 
      return
21755 
    iprot.readStructBegin()
21756 
    while True:
21757 
      (fname, ftype, fid) = iprot.readFieldBegin()
21758 
      if ftype == TType.STOP:
21759 
        break
21760 
      if fid == 1:
21761 
        if ftype == TType.I64:
21762 
          self.orderId = iprot.readI64();
21763 
        else:
21764 
          iprot.skip(ftype)
21765 
      else:
21766 
        iprot.skip(ftype)
21767 
      iprot.readFieldEnd()
21768 
    iprot.readStructEnd()
21769 
 
21770 
  def write(self, oprot):
21771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21773 
      return
21774 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21775 
    if self.orderId is not None:
21776 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21777 
      oprot.writeI64(self.orderId)
21778 
      oprot.writeFieldEnd()
21779 
    oprot.writeFieldStop()
21780 
    oprot.writeStructEnd()
21781 
 
21782 
  def validate(self):
21783 
    return
21784 
 
21785 
 
21786 
  def __repr__(self):
21787 
    L = ['%s=%r' % (key, value)
21788 
      for key, value in self.__dict__.iteritems()]
21789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21790 
 
21791 
  def __eq__(self, other):
21792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21793 
 
21794 
  def __ne__(self, other):
21795 
    return not (self == other)
21796 
 
21797 
class markOrderAsLostInTransit_result:
21798 
  """
21799 
  Attributes:
21800 
   - success
21801 
   - ex
21802 
  """
21803 
 
21804 
  thrift_spec = (
21805 
    (0, TType.BOOL, 'success', None, None, ), # 0
21806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21807 
  )
21808 
 
21809 
  def __init__(self, success=None, ex=None,):
21810 
    self.success = success
21811 
    self.ex = ex
21812 
 
21813 
  def read(self, iprot):
21814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21816 
      return
21817 
    iprot.readStructBegin()
21818 
    while True:
21819 
      (fname, ftype, fid) = iprot.readFieldBegin()
21820 
      if ftype == TType.STOP:
21821 
        break
21822 
      if fid == 0:
21823 
        if ftype == TType.BOOL:
21824 
          self.success = iprot.readBool();
21825 
        else:
21826 
          iprot.skip(ftype)
21827 
      elif fid == 1:
21828 
        if ftype == TType.STRUCT:
21829 
          self.ex = TransactionServiceException()
21830 
          self.ex.read(iprot)
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('markOrderAsLostInTransit_result')
21843 
    if self.success is not None:
21844 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21845 
      oprot.writeBool(self.success)
21846 
      oprot.writeFieldEnd()
21847 
    if self.ex is not None:
21848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21849 
      self.ex.write(oprot)
21850 
      oprot.writeFieldEnd()
21851 
    oprot.writeFieldStop()
21852 
    oprot.writeStructEnd()
21853 
 
21854 
  def validate(self):
21855 
    return
21856 
 
21857 
 
21858 
  def __repr__(self):
21859 
    L = ['%s=%r' % (key, value)
21860 
      for key, value in self.__dict__.iteritems()]
21861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21862 
 
21863 
  def __eq__(self, other):
21864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21865 
 
21866 
  def __ne__(self, other):
21867 
    return not (self == other)
21868 
 
4386 anupam.sin 21869 
class getOrderForAwb_args:
21870 
  """
21871 
  Attributes:
21872 
   - awb
21873 
  """
21874 
 
21875 
  thrift_spec = (
21876 
    None, # 0
21877 
    (1, TType.STRING, 'awb', None, None, ), # 1
21878 
  )
21879 
 
21880 
  def __init__(self, awb=None,):
21881 
    self.awb = awb
21882 
 
21883 
  def read(self, iprot):
21884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21886 
      return
21887 
    iprot.readStructBegin()
21888 
    while True:
21889 
      (fname, ftype, fid) = iprot.readFieldBegin()
21890 
      if ftype == TType.STOP:
21891 
        break
21892 
      if fid == 1:
21893 
        if ftype == TType.STRING:
21894 
          self.awb = iprot.readString();
21895 
        else:
21896 
          iprot.skip(ftype)
21897 
      else:
21898 
        iprot.skip(ftype)
21899 
      iprot.readFieldEnd()
21900 
    iprot.readStructEnd()
21901 
 
21902 
  def write(self, oprot):
21903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21905 
      return
21906 
    oprot.writeStructBegin('getOrderForAwb_args')
21907 
    if self.awb is not None:
21908 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21909 
      oprot.writeString(self.awb)
21910 
      oprot.writeFieldEnd()
21911 
    oprot.writeFieldStop()
21912 
    oprot.writeStructEnd()
21913 
 
21914 
  def validate(self):
21915 
    return
21916 
 
21917 
 
21918 
  def __repr__(self):
21919 
    L = ['%s=%r' % (key, value)
21920 
      for key, value in self.__dict__.iteritems()]
21921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21922 
 
21923 
  def __eq__(self, other):
21924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21925 
 
21926 
  def __ne__(self, other):
21927 
    return not (self == other)
21928 
 
21929 
class getOrderForAwb_result:
21930 
  """
21931 
  Attributes:
21932 
   - success
21933 
   - ex
21934 
  """
21935 
 
21936 
  thrift_spec = (
21937 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21939 
  )
21940 
 
21941 
  def __init__(self, success=None, ex=None,):
21942 
    self.success = success
21943 
    self.ex = ex
21944 
 
21945 
  def read(self, iprot):
21946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21948 
      return
21949 
    iprot.readStructBegin()
21950 
    while True:
21951 
      (fname, ftype, fid) = iprot.readFieldBegin()
21952 
      if ftype == TType.STOP:
21953 
        break
21954 
      if fid == 0:
21955 
        if ftype == TType.STRUCT:
21956 
          self.success = Order()
21957 
          self.success.read(iprot)
21958 
        else:
21959 
          iprot.skip(ftype)
21960 
      elif fid == 1:
21961 
        if ftype == TType.STRUCT:
21962 
          self.ex = TransactionServiceException()
21963 
          self.ex.read(iprot)
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      else:
21967 
        iprot.skip(ftype)
21968 
      iprot.readFieldEnd()
21969 
    iprot.readStructEnd()
21970 
 
21971 
  def write(self, oprot):
21972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21974 
      return
21975 
    oprot.writeStructBegin('getOrderForAwb_result')
21976 
    if self.success is not None:
21977 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21978 
      self.success.write(oprot)
21979 
      oprot.writeFieldEnd()
21980 
    if self.ex is not None:
21981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21982 
      self.ex.write(oprot)
21983 
      oprot.writeFieldEnd()
21984 
    oprot.writeFieldStop()
21985 
    oprot.writeStructEnd()
21986 
 
21987 
  def validate(self):
21988 
    return
21989 
 
21990 
 
21991 
  def __repr__(self):
21992 
    L = ['%s=%r' % (key, value)
21993 
      for key, value in self.__dict__.iteritems()]
21994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21995 
 
21996 
  def __eq__(self, other):
21997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21998 
 
21999 
  def __ne__(self, other):
22000 
    return not (self == other)
4506 phani.kuma 22001 
 
22002 
class getOrdersForProviderForStatus_args:
22003 
  """
22004 
  Attributes:
22005 
   - logistics_provider_id
4910 phani.kuma 22006 
   - order_status_list
4506 phani.kuma 22007 
  """
22008 
 
22009 
  thrift_spec = (
22010 
    None, # 0
22011 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22012 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22013 
  )
22014 
 
4910 phani.kuma 22015 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22016 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22017 
    self.order_status_list = order_status_list
4506 phani.kuma 22018 
 
22019 
  def read(self, iprot):
22020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22022 
      return
22023 
    iprot.readStructBegin()
22024 
    while True:
22025 
      (fname, ftype, fid) = iprot.readFieldBegin()
22026 
      if ftype == TType.STOP:
22027 
        break
22028 
      if fid == 1:
22029 
        if ftype == TType.I64:
22030 
          self.logistics_provider_id = iprot.readI64();
22031 
        else:
22032 
          iprot.skip(ftype)
22033 
      elif fid == 2:
4910 phani.kuma 22034 
        if ftype == TType.LIST:
22035 
          self.order_status_list = []
6188 rajveer 22036 
          (_etype513, _size510) = iprot.readListBegin()
22037 
          for _i514 in xrange(_size510):
22038 
            _elem515 = iprot.readI32();
22039 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22040 
          iprot.readListEnd()
4506 phani.kuma 22041 
        else:
22042 
          iprot.skip(ftype)
22043 
      else:
22044 
        iprot.skip(ftype)
22045 
      iprot.readFieldEnd()
22046 
    iprot.readStructEnd()
22047 
 
22048 
  def write(self, oprot):
22049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22051 
      return
22052 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22053 
    if self.logistics_provider_id is not None:
22054 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22055 
      oprot.writeI64(self.logistics_provider_id)
22056 
      oprot.writeFieldEnd()
4910 phani.kuma 22057 
    if self.order_status_list is not None:
22058 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22059 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22060 
      for iter516 in self.order_status_list:
22061 
        oprot.writeI32(iter516)
4910 phani.kuma 22062 
      oprot.writeListEnd()
4506 phani.kuma 22063 
      oprot.writeFieldEnd()
22064 
    oprot.writeFieldStop()
22065 
    oprot.writeStructEnd()
22066 
 
22067 
  def validate(self):
22068 
    return
22069 
 
22070 
 
22071 
  def __repr__(self):
22072 
    L = ['%s=%r' % (key, value)
22073 
      for key, value in self.__dict__.iteritems()]
22074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22075 
 
22076 
  def __eq__(self, other):
22077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22078 
 
22079 
  def __ne__(self, other):
22080 
    return not (self == other)
22081 
 
22082 
class getOrdersForProviderForStatus_result:
22083 
  """
22084 
  Attributes:
22085 
   - success
22086 
   - ex
22087 
  """
22088 
 
22089 
  thrift_spec = (
22090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22092 
  )
22093 
 
22094 
  def __init__(self, success=None, ex=None,):
22095 
    self.success = success
22096 
    self.ex = ex
22097 
 
22098 
  def read(self, iprot):
22099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22101 
      return
22102 
    iprot.readStructBegin()
22103 
    while True:
22104 
      (fname, ftype, fid) = iprot.readFieldBegin()
22105 
      if ftype == TType.STOP:
22106 
        break
22107 
      if fid == 0:
22108 
        if ftype == TType.LIST:
22109 
          self.success = []
6188 rajveer 22110 
          (_etype520, _size517) = iprot.readListBegin()
22111 
          for _i521 in xrange(_size517):
22112 
            _elem522 = Order()
22113 
            _elem522.read(iprot)
22114 
            self.success.append(_elem522)
4506 phani.kuma 22115 
          iprot.readListEnd()
22116 
        else:
22117 
          iprot.skip(ftype)
22118 
      elif fid == 1:
22119 
        if ftype == TType.STRUCT:
22120 
          self.ex = TransactionServiceException()
22121 
          self.ex.read(iprot)
22122 
        else:
22123 
          iprot.skip(ftype)
22124 
      else:
22125 
        iprot.skip(ftype)
22126 
      iprot.readFieldEnd()
22127 
    iprot.readStructEnd()
22128 
 
22129 
  def write(self, oprot):
22130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22132 
      return
22133 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22134 
    if self.success is not None:
22135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22137 
      for iter523 in self.success:
22138 
        iter523.write(oprot)
4506 phani.kuma 22139 
      oprot.writeListEnd()
22140 
      oprot.writeFieldEnd()
22141 
    if self.ex is not None:
22142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22143 
      self.ex.write(oprot)
22144 
      oprot.writeFieldEnd()
22145 
    oprot.writeFieldStop()
22146 
    oprot.writeStructEnd()
22147 
 
22148 
  def validate(self):
22149 
    return
22150 
 
22151 
 
22152 
  def __repr__(self):
22153 
    L = ['%s=%r' % (key, value)
22154 
      for key, value in self.__dict__.iteritems()]
22155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22156 
 
22157 
  def __eq__(self, other):
22158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22159 
 
22160 
  def __ne__(self, other):
22161 
    return not (self == other)
4600 varun.gupt 22162 
 
22163 
class getBilledOrdersForVendor_args:
22164 
  """
22165 
  Attributes:
22166 
   - vendorId
22167 
   - billingDateFrom
22168 
   - billingDateTo
22169 
  """
22170 
 
22171 
  thrift_spec = (
22172 
    None, # 0
22173 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22174 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22175 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22176 
  )
22177 
 
22178 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22179 
    self.vendorId = vendorId
22180 
    self.billingDateFrom = billingDateFrom
22181 
    self.billingDateTo = billingDateTo
22182 
 
22183 
  def read(self, iprot):
22184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22186 
      return
22187 
    iprot.readStructBegin()
22188 
    while True:
22189 
      (fname, ftype, fid) = iprot.readFieldBegin()
22190 
      if ftype == TType.STOP:
22191 
        break
22192 
      if fid == 1:
22193 
        if ftype == TType.I64:
22194 
          self.vendorId = iprot.readI64();
22195 
        else:
22196 
          iprot.skip(ftype)
22197 
      elif fid == 2:
22198 
        if ftype == TType.I64:
22199 
          self.billingDateFrom = iprot.readI64();
22200 
        else:
22201 
          iprot.skip(ftype)
22202 
      elif fid == 3:
22203 
        if ftype == TType.I64:
22204 
          self.billingDateTo = iprot.readI64();
22205 
        else:
22206 
          iprot.skip(ftype)
22207 
      else:
22208 
        iprot.skip(ftype)
22209 
      iprot.readFieldEnd()
22210 
    iprot.readStructEnd()
22211 
 
22212 
  def write(self, oprot):
22213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22215 
      return
22216 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22217 
    if self.vendorId is not None:
22218 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22219 
      oprot.writeI64(self.vendorId)
22220 
      oprot.writeFieldEnd()
22221 
    if self.billingDateFrom is not None:
22222 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22223 
      oprot.writeI64(self.billingDateFrom)
22224 
      oprot.writeFieldEnd()
22225 
    if self.billingDateTo is not None:
22226 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22227 
      oprot.writeI64(self.billingDateTo)
22228 
      oprot.writeFieldEnd()
22229 
    oprot.writeFieldStop()
22230 
    oprot.writeStructEnd()
22231 
 
22232 
  def validate(self):
22233 
    return
22234 
 
22235 
 
22236 
  def __repr__(self):
22237 
    L = ['%s=%r' % (key, value)
22238 
      for key, value in self.__dict__.iteritems()]
22239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22240 
 
22241 
  def __eq__(self, other):
22242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22243 
 
22244 
  def __ne__(self, other):
22245 
    return not (self == other)
22246 
 
22247 
class getBilledOrdersForVendor_result:
22248 
  """
22249 
  Attributes:
22250 
   - success
22251 
   - ex
22252 
  """
22253 
 
22254 
  thrift_spec = (
22255 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22257 
  )
22258 
 
22259 
  def __init__(self, success=None, ex=None,):
22260 
    self.success = success
22261 
    self.ex = ex
22262 
 
22263 
  def read(self, iprot):
22264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22266 
      return
22267 
    iprot.readStructBegin()
22268 
    while True:
22269 
      (fname, ftype, fid) = iprot.readFieldBegin()
22270 
      if ftype == TType.STOP:
22271 
        break
22272 
      if fid == 0:
22273 
        if ftype == TType.LIST:
22274 
          self.success = []
6188 rajveer 22275 
          (_etype527, _size524) = iprot.readListBegin()
22276 
          for _i528 in xrange(_size524):
22277 
            _elem529 = Order()
22278 
            _elem529.read(iprot)
22279 
            self.success.append(_elem529)
4600 varun.gupt 22280 
          iprot.readListEnd()
22281 
        else:
22282 
          iprot.skip(ftype)
22283 
      elif fid == 1:
22284 
        if ftype == TType.STRUCT:
22285 
          self.ex = TransactionServiceException()
22286 
          self.ex.read(iprot)
22287 
        else:
22288 
          iprot.skip(ftype)
22289 
      else:
22290 
        iprot.skip(ftype)
22291 
      iprot.readFieldEnd()
22292 
    iprot.readStructEnd()
22293 
 
22294 
  def write(self, oprot):
22295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22297 
      return
22298 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22299 
    if self.success is not None:
22300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22302 
      for iter530 in self.success:
22303 
        iter530.write(oprot)
4600 varun.gupt 22304 
      oprot.writeListEnd()
22305 
      oprot.writeFieldEnd()
22306 
    if self.ex is not None:
22307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22308 
      self.ex.write(oprot)
22309 
      oprot.writeFieldEnd()
22310 
    oprot.writeFieldStop()
22311 
    oprot.writeStructEnd()
22312 
 
22313 
  def validate(self):
22314 
    return
22315 
 
22316 
 
22317 
  def __repr__(self):
22318 
    L = ['%s=%r' % (key, value)
22319 
      for key, value in self.__dict__.iteritems()]
22320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22321 
 
22322 
  def __eq__(self, other):
22323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22324 
 
22325 
  def __ne__(self, other):
22326 
    return not (self == other)
22327 
 
4607 rajveer 22328 
class getSlippedSippingDateOrders_args:
22329 
 
22330 
  thrift_spec = (
22331 
  )
22332 
 
22333 
  def read(self, iprot):
22334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22336 
      return
22337 
    iprot.readStructBegin()
22338 
    while True:
22339 
      (fname, ftype, fid) = iprot.readFieldBegin()
22340 
      if ftype == TType.STOP:
22341 
        break
22342 
      else:
22343 
        iprot.skip(ftype)
22344 
      iprot.readFieldEnd()
22345 
    iprot.readStructEnd()
22346 
 
22347 
  def write(self, oprot):
22348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22350 
      return
22351 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22352 
    oprot.writeFieldStop()
22353 
    oprot.writeStructEnd()
22354 
 
22355 
  def validate(self):
22356 
    return
22357 
 
22358 
 
22359 
  def __repr__(self):
22360 
    L = ['%s=%r' % (key, value)
22361 
      for key, value in self.__dict__.iteritems()]
22362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22363 
 
22364 
  def __eq__(self, other):
22365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22366 
 
22367 
  def __ne__(self, other):
22368 
    return not (self == other)
22369 
 
22370 
class getSlippedSippingDateOrders_result:
22371 
  """
22372 
  Attributes:
22373 
   - success
22374 
   - ex
22375 
  """
22376 
 
22377 
  thrift_spec = (
22378 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22380 
  )
22381 
 
22382 
  def __init__(self, success=None, ex=None,):
22383 
    self.success = success
22384 
    self.ex = ex
22385 
 
22386 
  def read(self, iprot):
22387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22389 
      return
22390 
    iprot.readStructBegin()
22391 
    while True:
22392 
      (fname, ftype, fid) = iprot.readFieldBegin()
22393 
      if ftype == TType.STOP:
22394 
        break
22395 
      if fid == 0:
22396 
        if ftype == TType.LIST:
22397 
          self.success = []
6188 rajveer 22398 
          (_etype534, _size531) = iprot.readListBegin()
22399 
          for _i535 in xrange(_size531):
22400 
            _elem536 = Order()
22401 
            _elem536.read(iprot)
22402 
            self.success.append(_elem536)
4607 rajveer 22403 
          iprot.readListEnd()
22404 
        else:
22405 
          iprot.skip(ftype)
22406 
      elif fid == 1:
22407 
        if ftype == TType.STRUCT:
22408 
          self.ex = TransactionServiceException()
22409 
          self.ex.read(iprot)
22410 
        else:
22411 
          iprot.skip(ftype)
22412 
      else:
22413 
        iprot.skip(ftype)
22414 
      iprot.readFieldEnd()
22415 
    iprot.readStructEnd()
22416 
 
22417 
  def write(self, oprot):
22418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22420 
      return
22421 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22422 
    if self.success is not None:
22423 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22424 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22425 
      for iter537 in self.success:
22426 
        iter537.write(oprot)
4607 rajveer 22427 
      oprot.writeListEnd()
22428 
      oprot.writeFieldEnd()
22429 
    if self.ex is not None:
22430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22431 
      self.ex.write(oprot)
22432 
      oprot.writeFieldEnd()
22433 
    oprot.writeFieldStop()
22434 
    oprot.writeStructEnd()
22435 
 
22436 
  def validate(self):
22437 
    return
22438 
 
22439 
 
22440 
  def __repr__(self):
22441 
    L = ['%s=%r' % (key, value)
22442 
      for key, value in self.__dict__.iteritems()]
22443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22444 
 
22445 
  def __eq__(self, other):
22446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22447 
 
22448 
  def __ne__(self, other):
22449 
    return not (self == other)
22450 
 
4709 rajveer 22451 
class getCancelledOrders_args:
22452 
  """
22453 
  Attributes:
22454 
   - cancelDateFrom
22455 
   - cancelDateTo
22456 
  """
22457 
 
22458 
  thrift_spec = (
22459 
    None, # 0
22460 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22461 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22462 
  )
22463 
 
22464 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22465 
    self.cancelDateFrom = cancelDateFrom
22466 
    self.cancelDateTo = cancelDateTo
22467 
 
22468 
  def read(self, iprot):
22469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22471 
      return
22472 
    iprot.readStructBegin()
22473 
    while True:
22474 
      (fname, ftype, fid) = iprot.readFieldBegin()
22475 
      if ftype == TType.STOP:
22476 
        break
22477 
      if fid == 1:
22478 
        if ftype == TType.I64:
22479 
          self.cancelDateFrom = iprot.readI64();
22480 
        else:
22481 
          iprot.skip(ftype)
22482 
      elif fid == 2:
22483 
        if ftype == TType.I64:
22484 
          self.cancelDateTo = iprot.readI64();
22485 
        else:
22486 
          iprot.skip(ftype)
22487 
      else:
22488 
        iprot.skip(ftype)
22489 
      iprot.readFieldEnd()
22490 
    iprot.readStructEnd()
22491 
 
22492 
  def write(self, oprot):
22493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22495 
      return
22496 
    oprot.writeStructBegin('getCancelledOrders_args')
22497 
    if self.cancelDateFrom is not None:
22498 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22499 
      oprot.writeI64(self.cancelDateFrom)
22500 
      oprot.writeFieldEnd()
22501 
    if self.cancelDateTo is not None:
22502 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22503 
      oprot.writeI64(self.cancelDateTo)
22504 
      oprot.writeFieldEnd()
22505 
    oprot.writeFieldStop()
22506 
    oprot.writeStructEnd()
22507 
 
22508 
  def validate(self):
22509 
    return
22510 
 
22511 
 
22512 
  def __repr__(self):
22513 
    L = ['%s=%r' % (key, value)
22514 
      for key, value in self.__dict__.iteritems()]
22515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22516 
 
22517 
  def __eq__(self, other):
22518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22519 
 
22520 
  def __ne__(self, other):
22521 
    return not (self == other)
22522 
 
22523 
class getCancelledOrders_result:
22524 
  """
22525 
  Attributes:
22526 
   - success
22527 
   - ex
22528 
  """
22529 
 
22530 
  thrift_spec = (
22531 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22533 
  )
22534 
 
22535 
  def __init__(self, success=None, ex=None,):
22536 
    self.success = success
22537 
    self.ex = ex
22538 
 
22539 
  def read(self, iprot):
22540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22542 
      return
22543 
    iprot.readStructBegin()
22544 
    while True:
22545 
      (fname, ftype, fid) = iprot.readFieldBegin()
22546 
      if ftype == TType.STOP:
22547 
        break
22548 
      if fid == 0:
22549 
        if ftype == TType.LIST:
22550 
          self.success = []
6188 rajveer 22551 
          (_etype541, _size538) = iprot.readListBegin()
22552 
          for _i542 in xrange(_size538):
22553 
            _elem543 = Order()
22554 
            _elem543.read(iprot)
22555 
            self.success.append(_elem543)
4709 rajveer 22556 
          iprot.readListEnd()
22557 
        else:
22558 
          iprot.skip(ftype)
22559 
      elif fid == 1:
22560 
        if ftype == TType.STRUCT:
22561 
          self.ex = TransactionServiceException()
22562 
          self.ex.read(iprot)
22563 
        else:
22564 
          iprot.skip(ftype)
22565 
      else:
22566 
        iprot.skip(ftype)
22567 
      iprot.readFieldEnd()
22568 
    iprot.readStructEnd()
22569 
 
22570 
  def write(self, oprot):
22571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22573 
      return
22574 
    oprot.writeStructBegin('getCancelledOrders_result')
22575 
    if self.success is not None:
22576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22578 
      for iter544 in self.success:
22579 
        iter544.write(oprot)
4709 rajveer 22580 
      oprot.writeListEnd()
22581 
      oprot.writeFieldEnd()
22582 
    if self.ex is not None:
22583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22584 
      self.ex.write(oprot)
22585 
      oprot.writeFieldEnd()
22586 
    oprot.writeFieldStop()
22587 
    oprot.writeStructEnd()
22588 
 
22589 
  def validate(self):
22590 
    return
22591 
 
22592 
 
22593 
  def __repr__(self):
22594 
    L = ['%s=%r' % (key, value)
22595 
      for key, value in self.__dict__.iteritems()]
22596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22597 
 
22598 
  def __eq__(self, other):
22599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22600 
 
22601 
  def __ne__(self, other):
22602 
    return not (self == other)
22603 
 
4600 varun.gupt 22604 
class saveBluedartSettlements_args:
22605 
  """
22606 
  Attributes:
22607 
   - mapAWBAndAmount
22608 
  """
22609 
 
22610 
  thrift_spec = (
22611 
    None, # 0
22612 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22613 
  )
22614 
 
22615 
  def __init__(self, mapAWBAndAmount=None,):
22616 
    self.mapAWBAndAmount = mapAWBAndAmount
22617 
 
22618 
  def read(self, iprot):
22619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22621 
      return
22622 
    iprot.readStructBegin()
22623 
    while True:
22624 
      (fname, ftype, fid) = iprot.readFieldBegin()
22625 
      if ftype == TType.STOP:
22626 
        break
22627 
      if fid == 1:
22628 
        if ftype == TType.MAP:
22629 
          self.mapAWBAndAmount = {}
6188 rajveer 22630 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22631 
          for _i549 in xrange(_size545):
22632 
            _key550 = iprot.readI64();
22633 
            _val551 = iprot.readDouble();
22634 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22635 
          iprot.readMapEnd()
22636 
        else:
22637 
          iprot.skip(ftype)
22638 
      else:
22639 
        iprot.skip(ftype)
22640 
      iprot.readFieldEnd()
22641 
    iprot.readStructEnd()
22642 
 
22643 
  def write(self, oprot):
22644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22646 
      return
22647 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22648 
    if self.mapAWBAndAmount is not None:
22649 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22650 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22651 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22652 
        oprot.writeI64(kiter552)
22653 
        oprot.writeDouble(viter553)
4600 varun.gupt 22654 
      oprot.writeMapEnd()
22655 
      oprot.writeFieldEnd()
22656 
    oprot.writeFieldStop()
22657 
    oprot.writeStructEnd()
22658 
 
22659 
  def validate(self):
22660 
    return
22661 
 
22662 
 
22663 
  def __repr__(self):
22664 
    L = ['%s=%r' % (key, value)
22665 
      for key, value in self.__dict__.iteritems()]
22666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22667 
 
22668 
  def __eq__(self, other):
22669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22670 
 
22671 
  def __ne__(self, other):
22672 
    return not (self == other)
22673 
 
22674 
class saveBluedartSettlements_result:
22675 
  """
22676 
  Attributes:
22677 
   - ex
22678 
  """
22679 
 
22680 
  thrift_spec = (
22681 
    None, # 0
22682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22683 
  )
22684 
 
22685 
  def __init__(self, ex=None,):
22686 
    self.ex = ex
22687 
 
22688 
  def read(self, iprot):
22689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22691 
      return
22692 
    iprot.readStructBegin()
22693 
    while True:
22694 
      (fname, ftype, fid) = iprot.readFieldBegin()
22695 
      if ftype == TType.STOP:
22696 
        break
22697 
      if fid == 1:
22698 
        if ftype == TType.STRUCT:
22699 
          self.ex = TransactionServiceException()
22700 
          self.ex.read(iprot)
22701 
        else:
22702 
          iprot.skip(ftype)
22703 
      else:
22704 
        iprot.skip(ftype)
22705 
      iprot.readFieldEnd()
22706 
    iprot.readStructEnd()
22707 
 
22708 
  def write(self, oprot):
22709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22711 
      return
22712 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22713 
    if self.ex is not None:
22714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22715 
      self.ex.write(oprot)
22716 
      oprot.writeFieldEnd()
22717 
    oprot.writeFieldStop()
22718 
    oprot.writeStructEnd()
22719 
 
22720 
  def validate(self):
22721 
    return
22722 
 
22723 
 
22724 
  def __repr__(self):
22725 
    L = ['%s=%r' % (key, value)
22726 
      for key, value in self.__dict__.iteritems()]
22727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22728 
 
22729 
  def __eq__(self, other):
22730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22731 
 
22732 
  def __ne__(self, other):
22733 
    return not (self == other)
22734 
 
22735 
class savePaymentSettlements_args:
22736 
  """
22737 
  Attributes:
22738 
   - settlementDate
22739 
   - paymentGatewayId
4905 varun.gupt 22740 
   - referenceId
4600 varun.gupt 22741 
   - serviceTax
22742 
   - otherCharges
22743 
   - netCollection
22744 
  """
22745 
 
22746 
  thrift_spec = (
22747 
    None, # 0
22748 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22749 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22750 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22751 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22752 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22753 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22754 
  )
22755 
 
4905 varun.gupt 22756 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22757 
    self.settlementDate = settlementDate
22758 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22759 
    self.referenceId = referenceId
4600 varun.gupt 22760 
    self.serviceTax = serviceTax
22761 
    self.otherCharges = otherCharges
22762 
    self.netCollection = netCollection
22763 
 
22764 
  def read(self, iprot):
22765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22767 
      return
22768 
    iprot.readStructBegin()
22769 
    while True:
22770 
      (fname, ftype, fid) = iprot.readFieldBegin()
22771 
      if ftype == TType.STOP:
22772 
        break
22773 
      if fid == 1:
22774 
        if ftype == TType.I64:
22775 
          self.settlementDate = iprot.readI64();
22776 
        else:
22777 
          iprot.skip(ftype)
22778 
      elif fid == 2:
22779 
        if ftype == TType.I64:
22780 
          self.paymentGatewayId = iprot.readI64();
22781 
        else:
22782 
          iprot.skip(ftype)
22783 
      elif fid == 3:
22784 
        if ftype == TType.I64:
4905 varun.gupt 22785 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22786 
        else:
22787 
          iprot.skip(ftype)
22788 
      elif fid == 4:
22789 
        if ftype == TType.DOUBLE:
22790 
          self.serviceTax = iprot.readDouble();
22791 
        else:
22792 
          iprot.skip(ftype)
22793 
      elif fid == 5:
22794 
        if ftype == TType.DOUBLE:
22795 
          self.otherCharges = iprot.readDouble();
22796 
        else:
22797 
          iprot.skip(ftype)
22798 
      elif fid == 6:
22799 
        if ftype == TType.DOUBLE:
22800 
          self.netCollection = iprot.readDouble();
22801 
        else:
22802 
          iprot.skip(ftype)
22803 
      else:
22804 
        iprot.skip(ftype)
22805 
      iprot.readFieldEnd()
22806 
    iprot.readStructEnd()
22807 
 
22808 
  def write(self, oprot):
22809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22811 
      return
22812 
    oprot.writeStructBegin('savePaymentSettlements_args')
22813 
    if self.settlementDate is not None:
22814 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22815 
      oprot.writeI64(self.settlementDate)
22816 
      oprot.writeFieldEnd()
22817 
    if self.paymentGatewayId is not None:
22818 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22819 
      oprot.writeI64(self.paymentGatewayId)
22820 
      oprot.writeFieldEnd()
4905 varun.gupt 22821 
    if self.referenceId is not None:
22822 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22823 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22824 
      oprot.writeFieldEnd()
22825 
    if self.serviceTax is not None:
22826 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22827 
      oprot.writeDouble(self.serviceTax)
22828 
      oprot.writeFieldEnd()
22829 
    if self.otherCharges is not None:
22830 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22831 
      oprot.writeDouble(self.otherCharges)
22832 
      oprot.writeFieldEnd()
22833 
    if self.netCollection is not None:
22834 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22835 
      oprot.writeDouble(self.netCollection)
22836 
      oprot.writeFieldEnd()
22837 
    oprot.writeFieldStop()
22838 
    oprot.writeStructEnd()
22839 
 
22840 
  def validate(self):
22841 
    return
22842 
 
22843 
 
22844 
  def __repr__(self):
22845 
    L = ['%s=%r' % (key, value)
22846 
      for key, value in self.__dict__.iteritems()]
22847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22848 
 
22849 
  def __eq__(self, other):
22850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22851 
 
22852 
  def __ne__(self, other):
22853 
    return not (self == other)
22854 
 
22855 
class savePaymentSettlements_result:
22856 
  """
22857 
  Attributes:
22858 
   - ex
22859 
  """
22860 
 
22861 
  thrift_spec = (
22862 
    None, # 0
22863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22864 
  )
22865 
 
22866 
  def __init__(self, ex=None,):
22867 
    self.ex = ex
22868 
 
22869 
  def read(self, iprot):
22870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22872 
      return
22873 
    iprot.readStructBegin()
22874 
    while True:
22875 
      (fname, ftype, fid) = iprot.readFieldBegin()
22876 
      if ftype == TType.STOP:
22877 
        break
22878 
      if fid == 1:
22879 
        if ftype == TType.STRUCT:
22880 
          self.ex = TransactionServiceException()
22881 
          self.ex.read(iprot)
22882 
        else:
22883 
          iprot.skip(ftype)
22884 
      else:
22885 
        iprot.skip(ftype)
22886 
      iprot.readFieldEnd()
22887 
    iprot.readStructEnd()
22888 
 
22889 
  def write(self, oprot):
22890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22892 
      return
22893 
    oprot.writeStructBegin('savePaymentSettlements_result')
22894 
    if self.ex is not None:
22895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22896 
      self.ex.write(oprot)
22897 
      oprot.writeFieldEnd()
22898 
    oprot.writeFieldStop()
22899 
    oprot.writeStructEnd()
22900 
 
22901 
  def validate(self):
22902 
    return
22903 
 
22904 
 
22905 
  def __repr__(self):
22906 
    L = ['%s=%r' % (key, value)
22907 
      for key, value in self.__dict__.iteritems()]
22908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22909 
 
22910 
  def __eq__(self, other):
22911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22912 
 
22913 
  def __ne__(self, other):
22914 
    return not (self == other)
22915 
 
22916 
class saveEBSSettlementSummary_args:
22917 
  """
22918 
  Attributes:
22919 
   - settlementId
22920 
   - settlementDate
22921 
   - transactionDateFrom
22922 
   - transactionDateTo
22923 
   - amount
22924 
  """
22925 
 
22926 
  thrift_spec = (
22927 
    None, # 0
22928 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22929 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22930 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22931 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22932 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22933 
  )
22934 
 
22935 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22936 
    self.settlementId = settlementId
22937 
    self.settlementDate = settlementDate
22938 
    self.transactionDateFrom = transactionDateFrom
22939 
    self.transactionDateTo = transactionDateTo
22940 
    self.amount = amount
22941 
 
22942 
  def read(self, iprot):
22943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22945 
      return
22946 
    iprot.readStructBegin()
22947 
    while True:
22948 
      (fname, ftype, fid) = iprot.readFieldBegin()
22949 
      if ftype == TType.STOP:
22950 
        break
22951 
      if fid == 1:
22952 
        if ftype == TType.I64:
22953 
          self.settlementId = iprot.readI64();
22954 
        else:
22955 
          iprot.skip(ftype)
22956 
      elif fid == 2:
22957 
        if ftype == TType.I64:
22958 
          self.settlementDate = iprot.readI64();
22959 
        else:
22960 
          iprot.skip(ftype)
22961 
      elif fid == 3:
22962 
        if ftype == TType.I64:
22963 
          self.transactionDateFrom = iprot.readI64();
22964 
        else:
22965 
          iprot.skip(ftype)
22966 
      elif fid == 4:
22967 
        if ftype == TType.I64:
22968 
          self.transactionDateTo = iprot.readI64();
22969 
        else:
22970 
          iprot.skip(ftype)
22971 
      elif fid == 5:
22972 
        if ftype == TType.DOUBLE:
22973 
          self.amount = iprot.readDouble();
22974 
        else:
22975 
          iprot.skip(ftype)
22976 
      else:
22977 
        iprot.skip(ftype)
22978 
      iprot.readFieldEnd()
22979 
    iprot.readStructEnd()
22980 
 
22981 
  def write(self, oprot):
22982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22984 
      return
22985 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22986 
    if self.settlementId is not None:
22987 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22988 
      oprot.writeI64(self.settlementId)
22989 
      oprot.writeFieldEnd()
22990 
    if self.settlementDate is not None:
22991 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22992 
      oprot.writeI64(self.settlementDate)
22993 
      oprot.writeFieldEnd()
22994 
    if self.transactionDateFrom is not None:
22995 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22996 
      oprot.writeI64(self.transactionDateFrom)
22997 
      oprot.writeFieldEnd()
22998 
    if self.transactionDateTo is not None:
22999 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23000 
      oprot.writeI64(self.transactionDateTo)
23001 
      oprot.writeFieldEnd()
23002 
    if self.amount is not None:
23003 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23004 
      oprot.writeDouble(self.amount)
23005 
      oprot.writeFieldEnd()
23006 
    oprot.writeFieldStop()
23007 
    oprot.writeStructEnd()
23008 
 
23009 
  def validate(self):
23010 
    return
23011 
 
23012 
 
23013 
  def __repr__(self):
23014 
    L = ['%s=%r' % (key, value)
23015 
      for key, value in self.__dict__.iteritems()]
23016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23017 
 
23018 
  def __eq__(self, other):
23019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23020 
 
23021 
  def __ne__(self, other):
23022 
    return not (self == other)
23023 
 
23024 
class saveEBSSettlementSummary_result:
23025 
  """
23026 
  Attributes:
23027 
   - ex
23028 
  """
23029 
 
23030 
  thrift_spec = (
23031 
    None, # 0
23032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23033 
  )
23034 
 
23035 
  def __init__(self, ex=None,):
23036 
    self.ex = ex
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.STRUCT:
23049 
          self.ex = TransactionServiceException()
23050 
          self.ex.read(iprot)
23051 
        else:
23052 
          iprot.skip(ftype)
23053 
      else:
23054 
        iprot.skip(ftype)
23055 
      iprot.readFieldEnd()
23056 
    iprot.readStructEnd()
23057 
 
23058 
  def write(self, oprot):
23059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23061 
      return
23062 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23063 
    if self.ex is not None:
23064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23065 
      self.ex.write(oprot)
23066 
      oprot.writeFieldEnd()
23067 
    oprot.writeFieldStop()
23068 
    oprot.writeStructEnd()
23069 
 
23070 
  def validate(self):
23071 
    return
23072 
 
23073 
 
23074 
  def __repr__(self):
23075 
    L = ['%s=%r' % (key, value)
23076 
      for key, value in self.__dict__.iteritems()]
23077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23078 
 
23079 
  def __eq__(self, other):
23080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23081 
 
23082 
  def __ne__(self, other):
23083 
    return not (self == other)
23084 
 
5386 phani.kuma 23085 
class getSettlementForPrepaid_args:
4600 varun.gupt 23086 
  """
23087 
  Attributes:
5189 varun.gupt 23088 
   - referenceId
23089 
   - isRefund
4600 varun.gupt 23090 
  """
23091 
 
23092 
  thrift_spec = (
23093 
    None, # 0
5189 varun.gupt 23094 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23095 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23096 
  )
23097 
 
5386 phani.kuma 23098 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23099 
    self.referenceId = referenceId
23100 
    self.isRefund = isRefund
4600 varun.gupt 23101 
 
23102 
  def read(self, iprot):
23103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23105 
      return
23106 
    iprot.readStructBegin()
23107 
    while True:
23108 
      (fname, ftype, fid) = iprot.readFieldBegin()
23109 
      if ftype == TType.STOP:
23110 
        break
23111 
      if fid == 1:
23112 
        if ftype == TType.I64:
5189 varun.gupt 23113 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23114 
        else:
23115 
          iprot.skip(ftype)
5189 varun.gupt 23116 
      elif fid == 2:
23117 
        if ftype == TType.BOOL:
23118 
          self.isRefund = iprot.readBool();
23119 
        else:
23120 
          iprot.skip(ftype)
4600 varun.gupt 23121 
      else:
23122 
        iprot.skip(ftype)
23123 
      iprot.readFieldEnd()
23124 
    iprot.readStructEnd()
23125 
 
23126 
  def write(self, oprot):
23127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23129 
      return
5386 phani.kuma 23130 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23131 
    if self.referenceId is not None:
23132 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23133 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23134 
      oprot.writeFieldEnd()
5386 phani.kuma 23135 
    if self.isRefund is not None:
23136 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23137 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23138 
      oprot.writeFieldEnd()
5386 phani.kuma 23139 
    oprot.writeFieldStop()
23140 
    oprot.writeStructEnd()
23141 
 
23142 
  def validate(self):
23143 
    return
23144 
 
23145 
 
23146 
  def __repr__(self):
23147 
    L = ['%s=%r' % (key, value)
23148 
      for key, value in self.__dict__.iteritems()]
23149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23150 
 
23151 
  def __eq__(self, other):
23152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23153 
 
23154 
  def __ne__(self, other):
23155 
    return not (self == other)
23156 
 
23157 
class getSettlementForPrepaid_result:
23158 
  """
23159 
  Attributes:
23160 
   - success
23161 
   - ex
23162 
  """
23163 
 
23164 
  thrift_spec = (
23165 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23167 
  )
23168 
 
23169 
  def __init__(self, success=None, ex=None,):
23170 
    self.success = success
23171 
    self.ex = ex
23172 
 
23173 
  def read(self, iprot):
23174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23176 
      return
23177 
    iprot.readStructBegin()
23178 
    while True:
23179 
      (fname, ftype, fid) = iprot.readFieldBegin()
23180 
      if ftype == TType.STOP:
23181 
        break
23182 
      if fid == 0:
23183 
        if ftype == TType.STRUCT:
23184 
          self.success = PaymentSettlement()
23185 
          self.success.read(iprot)
23186 
        else:
23187 
          iprot.skip(ftype)
23188 
      elif fid == 1:
23189 
        if ftype == TType.STRUCT:
23190 
          self.ex = TransactionServiceException()
23191 
          self.ex.read(iprot)
23192 
        else:
23193 
          iprot.skip(ftype)
23194 
      else:
23195 
        iprot.skip(ftype)
23196 
      iprot.readFieldEnd()
23197 
    iprot.readStructEnd()
23198 
 
23199 
  def write(self, oprot):
23200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23202 
      return
23203 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23204 
    if self.success is not None:
23205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23206 
      self.success.write(oprot)
23207 
      oprot.writeFieldEnd()
23208 
    if self.ex is not None:
23209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23210 
      self.ex.write(oprot)
23211 
      oprot.writeFieldEnd()
23212 
    oprot.writeFieldStop()
23213 
    oprot.writeStructEnd()
23214 
 
23215 
  def validate(self):
23216 
    return
23217 
 
23218 
 
23219 
  def __repr__(self):
23220 
    L = ['%s=%r' % (key, value)
23221 
      for key, value in self.__dict__.iteritems()]
23222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23223 
 
23224 
  def __eq__(self, other):
23225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23226 
 
23227 
  def __ne__(self, other):
23228 
    return not (self == other)
23229 
 
23230 
class getSettlementForCod_args:
23231 
  """
23232 
  Attributes:
23233 
   - orderId
23234 
   - isRefund
23235 
  """
23236 
 
23237 
  thrift_spec = (
23238 
    None, # 0
23239 
    (1, TType.I64, 'orderId', None, None, ), # 1
23240 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23241 
  )
23242 
 
23243 
  def __init__(self, orderId=None, isRefund=None,):
23244 
    self.orderId = orderId
23245 
    self.isRefund = isRefund
23246 
 
23247 
  def read(self, iprot):
23248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23250 
      return
23251 
    iprot.readStructBegin()
23252 
    while True:
23253 
      (fname, ftype, fid) = iprot.readFieldBegin()
23254 
      if ftype == TType.STOP:
23255 
        break
23256 
      if fid == 1:
23257 
        if ftype == TType.I64:
23258 
          self.orderId = iprot.readI64();
23259 
        else:
23260 
          iprot.skip(ftype)
23261 
      elif fid == 2:
23262 
        if ftype == TType.BOOL:
23263 
          self.isRefund = iprot.readBool();
23264 
        else:
23265 
          iprot.skip(ftype)
23266 
      else:
23267 
        iprot.skip(ftype)
23268 
      iprot.readFieldEnd()
23269 
    iprot.readStructEnd()
23270 
 
23271 
  def write(self, oprot):
23272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23274 
      return
23275 
    oprot.writeStructBegin('getSettlementForCod_args')
23276 
    if self.orderId is not None:
23277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23278 
      oprot.writeI64(self.orderId)
23279 
      oprot.writeFieldEnd()
5189 varun.gupt 23280 
    if self.isRefund is not None:
5386 phani.kuma 23281 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23282 
      oprot.writeBool(self.isRefund)
23283 
      oprot.writeFieldEnd()
4600 varun.gupt 23284 
    oprot.writeFieldStop()
23285 
    oprot.writeStructEnd()
23286 
 
23287 
  def validate(self):
23288 
    return
23289 
 
23290 
 
23291 
  def __repr__(self):
23292 
    L = ['%s=%r' % (key, value)
23293 
      for key, value in self.__dict__.iteritems()]
23294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23295 
 
23296 
  def __eq__(self, other):
23297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23298 
 
23299 
  def __ne__(self, other):
23300 
    return not (self == other)
23301 
 
5386 phani.kuma 23302 
class getSettlementForCod_result:
4600 varun.gupt 23303 
  """
23304 
  Attributes:
23305 
   - success
23306 
   - ex
23307 
  """
23308 
 
23309 
  thrift_spec = (
23310 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23312 
  )
23313 
 
23314 
  def __init__(self, success=None, ex=None,):
23315 
    self.success = success
23316 
    self.ex = ex
23317 
 
23318 
  def read(self, iprot):
23319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23321 
      return
23322 
    iprot.readStructBegin()
23323 
    while True:
23324 
      (fname, ftype, fid) = iprot.readFieldBegin()
23325 
      if ftype == TType.STOP:
23326 
        break
23327 
      if fid == 0:
23328 
        if ftype == TType.STRUCT:
23329 
          self.success = PaymentSettlement()
23330 
          self.success.read(iprot)
23331 
        else:
23332 
          iprot.skip(ftype)
23333 
      elif fid == 1:
23334 
        if ftype == TType.STRUCT:
23335 
          self.ex = TransactionServiceException()
23336 
          self.ex.read(iprot)
23337 
        else:
23338 
          iprot.skip(ftype)
23339 
      else:
23340 
        iprot.skip(ftype)
23341 
      iprot.readFieldEnd()
23342 
    iprot.readStructEnd()
23343 
 
23344 
  def write(self, oprot):
23345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23347 
      return
5386 phani.kuma 23348 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23349 
    if self.success is not None:
23350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23351 
      self.success.write(oprot)
23352 
      oprot.writeFieldEnd()
23353 
    if self.ex is not None:
23354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23355 
      self.ex.write(oprot)
23356 
      oprot.writeFieldEnd()
23357 
    oprot.writeFieldStop()
23358 
    oprot.writeStructEnd()
23359 
 
23360 
  def validate(self):
23361 
    return
23362 
 
23363 
 
23364 
  def __repr__(self):
23365 
    L = ['%s=%r' % (key, value)
23366 
      for key, value in self.__dict__.iteritems()]
23367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23368 
 
23369 
  def __eq__(self, other):
23370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23371 
 
23372 
  def __ne__(self, other):
23373 
    return not (self == other)
23374 
 
23375 
class getEBSSettlementSummaries_args:
23376 
 
23377 
  thrift_spec = (
23378 
  )
23379 
 
23380 
  def read(self, iprot):
23381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23383 
      return
23384 
    iprot.readStructBegin()
23385 
    while True:
23386 
      (fname, ftype, fid) = iprot.readFieldBegin()
23387 
      if ftype == TType.STOP:
23388 
        break
23389 
      else:
23390 
        iprot.skip(ftype)
23391 
      iprot.readFieldEnd()
23392 
    iprot.readStructEnd()
23393 
 
23394 
  def write(self, oprot):
23395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23397 
      return
23398 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23399 
    oprot.writeFieldStop()
23400 
    oprot.writeStructEnd()
23401 
 
23402 
  def validate(self):
23403 
    return
23404 
 
23405 
 
23406 
  def __repr__(self):
23407 
    L = ['%s=%r' % (key, value)
23408 
      for key, value in self.__dict__.iteritems()]
23409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23410 
 
23411 
  def __eq__(self, other):
23412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23413 
 
23414 
  def __ne__(self, other):
23415 
    return not (self == other)
23416 
 
23417 
class getEBSSettlementSummaries_result:
23418 
  """
23419 
  Attributes:
23420 
   - success
23421 
   - ex
23422 
  """
23423 
 
23424 
  thrift_spec = (
23425 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23427 
  )
23428 
 
23429 
  def __init__(self, success=None, ex=None,):
23430 
    self.success = success
23431 
    self.ex = ex
23432 
 
23433 
  def read(self, iprot):
23434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23436 
      return
23437 
    iprot.readStructBegin()
23438 
    while True:
23439 
      (fname, ftype, fid) = iprot.readFieldBegin()
23440 
      if ftype == TType.STOP:
23441 
        break
23442 
      if fid == 0:
23443 
        if ftype == TType.MAP:
23444 
          self.success = {}
6188 rajveer 23445 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23446 
          for _i558 in xrange(_size554):
23447 
            _key559 = iprot.readI64();
23448 
            _val560 = iprot.readString();
23449 
            self.success[_key559] = _val560
4600 varun.gupt 23450 
          iprot.readMapEnd()
23451 
        else:
23452 
          iprot.skip(ftype)
23453 
      elif fid == 1:
23454 
        if ftype == TType.STRUCT:
23455 
          self.ex = TransactionServiceException()
23456 
          self.ex.read(iprot)
23457 
        else:
23458 
          iprot.skip(ftype)
23459 
      else:
23460 
        iprot.skip(ftype)
23461 
      iprot.readFieldEnd()
23462 
    iprot.readStructEnd()
23463 
 
23464 
  def write(self, oprot):
23465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23467 
      return
23468 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23469 
    if self.success is not None:
23470 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23471 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23472 
      for kiter561,viter562 in self.success.items():
23473 
        oprot.writeI64(kiter561)
23474 
        oprot.writeString(viter562)
4600 varun.gupt 23475 
      oprot.writeMapEnd()
23476 
      oprot.writeFieldEnd()
23477 
    if self.ex is not None:
23478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23479 
      self.ex.write(oprot)
23480 
      oprot.writeFieldEnd()
23481 
    oprot.writeFieldStop()
23482 
    oprot.writeStructEnd()
23483 
 
23484 
  def validate(self):
23485 
    return
23486 
 
23487 
 
23488 
  def __repr__(self):
23489 
    L = ['%s=%r' % (key, value)
23490 
      for key, value in self.__dict__.iteritems()]
23491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23492 
 
23493 
  def __eq__(self, other):
23494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23495 
 
23496 
  def __ne__(self, other):
23497 
    return not (self == other)
23498 
 
23499 
class markEBSSettlementUploaded_args:
23500 
  """
23501 
  Attributes:
23502 
   - settlementId
23503 
  """
23504 
 
23505 
  thrift_spec = (
23506 
    None, # 0
23507 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23508 
  )
23509 
 
23510 
  def __init__(self, settlementId=None,):
23511 
    self.settlementId = settlementId
23512 
 
23513 
  def read(self, iprot):
23514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23516 
      return
23517 
    iprot.readStructBegin()
23518 
    while True:
23519 
      (fname, ftype, fid) = iprot.readFieldBegin()
23520 
      if ftype == TType.STOP:
23521 
        break
23522 
      if fid == 1:
23523 
        if ftype == TType.I64:
23524 
          self.settlementId = iprot.readI64();
23525 
        else:
23526 
          iprot.skip(ftype)
23527 
      else:
23528 
        iprot.skip(ftype)
23529 
      iprot.readFieldEnd()
23530 
    iprot.readStructEnd()
23531 
 
23532 
  def write(self, oprot):
23533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23535 
      return
23536 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23537 
    if self.settlementId is not None:
23538 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23539 
      oprot.writeI64(self.settlementId)
23540 
      oprot.writeFieldEnd()
23541 
    oprot.writeFieldStop()
23542 
    oprot.writeStructEnd()
23543 
 
23544 
  def validate(self):
23545 
    return
23546 
 
23547 
 
23548 
  def __repr__(self):
23549 
    L = ['%s=%r' % (key, value)
23550 
      for key, value in self.__dict__.iteritems()]
23551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23552 
 
23553 
  def __eq__(self, other):
23554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23555 
 
23556 
  def __ne__(self, other):
23557 
    return not (self == other)
23558 
 
23559 
class markEBSSettlementUploaded_result:
23560 
  """
23561 
  Attributes:
23562 
   - ex
23563 
  """
23564 
 
23565 
  thrift_spec = (
23566 
    None, # 0
23567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23568 
  )
23569 
 
23570 
  def __init__(self, ex=None,):
23571 
    self.ex = ex
23572 
 
23573 
  def read(self, iprot):
23574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23576 
      return
23577 
    iprot.readStructBegin()
23578 
    while True:
23579 
      (fname, ftype, fid) = iprot.readFieldBegin()
23580 
      if ftype == TType.STOP:
23581 
        break
23582 
      if fid == 1:
23583 
        if ftype == TType.STRUCT:
23584 
          self.ex = TransactionServiceException()
23585 
          self.ex.read(iprot)
23586 
        else:
23587 
          iprot.skip(ftype)
23588 
      else:
23589 
        iprot.skip(ftype)
23590 
      iprot.readFieldEnd()
23591 
    iprot.readStructEnd()
23592 
 
23593 
  def write(self, oprot):
23594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23596 
      return
23597 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23598 
    if self.ex is not None:
23599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23600 
      self.ex.write(oprot)
23601 
      oprot.writeFieldEnd()
23602 
    oprot.writeFieldStop()
23603 
    oprot.writeStructEnd()
23604 
 
23605 
  def validate(self):
23606 
    return
23607 
 
23608 
 
23609 
  def __repr__(self):
23610 
    L = ['%s=%r' % (key, value)
23611 
      for key, value in self.__dict__.iteritems()]
23612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23613 
 
23614 
  def __eq__(self, other):
23615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23616 
 
23617 
  def __ne__(self, other):
23618 
    return not (self == other)
23619 
 
23620 
class getEBSSettlementDate_args:
23621 
  """
23622 
  Attributes:
23623 
   - settlementId
23624 
  """
23625 
 
23626 
  thrift_spec = (
23627 
    None, # 0
23628 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23629 
  )
23630 
 
23631 
  def __init__(self, settlementId=None,):
23632 
    self.settlementId = settlementId
23633 
 
23634 
  def read(self, iprot):
23635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23637 
      return
23638 
    iprot.readStructBegin()
23639 
    while True:
23640 
      (fname, ftype, fid) = iprot.readFieldBegin()
23641 
      if ftype == TType.STOP:
23642 
        break
23643 
      if fid == 1:
23644 
        if ftype == TType.I64:
23645 
          self.settlementId = iprot.readI64();
23646 
        else:
23647 
          iprot.skip(ftype)
23648 
      else:
23649 
        iprot.skip(ftype)
23650 
      iprot.readFieldEnd()
23651 
    iprot.readStructEnd()
23652 
 
23653 
  def write(self, oprot):
23654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23656 
      return
23657 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23658 
    if self.settlementId is not None:
23659 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23660 
      oprot.writeI64(self.settlementId)
23661 
      oprot.writeFieldEnd()
23662 
    oprot.writeFieldStop()
23663 
    oprot.writeStructEnd()
23664 
 
23665 
  def validate(self):
23666 
    return
23667 
 
23668 
 
23669 
  def __repr__(self):
23670 
    L = ['%s=%r' % (key, value)
23671 
      for key, value in self.__dict__.iteritems()]
23672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23673 
 
23674 
  def __eq__(self, other):
23675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23676 
 
23677 
  def __ne__(self, other):
23678 
    return not (self == other)
23679 
 
23680 
class getEBSSettlementDate_result:
23681 
  """
23682 
  Attributes:
23683 
   - success
23684 
   - ex
23685 
  """
23686 
 
23687 
  thrift_spec = (
23688 
    (0, TType.I64, 'success', None, None, ), # 0
23689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23690 
  )
23691 
 
23692 
  def __init__(self, success=None, ex=None,):
23693 
    self.success = success
23694 
    self.ex = ex
23695 
 
23696 
  def read(self, iprot):
23697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23699 
      return
23700 
    iprot.readStructBegin()
23701 
    while True:
23702 
      (fname, ftype, fid) = iprot.readFieldBegin()
23703 
      if ftype == TType.STOP:
23704 
        break
23705 
      if fid == 0:
23706 
        if ftype == TType.I64:
23707 
          self.success = iprot.readI64();
23708 
        else:
23709 
          iprot.skip(ftype)
23710 
      elif fid == 1:
23711 
        if ftype == TType.STRUCT:
23712 
          self.ex = TransactionServiceException()
23713 
          self.ex.read(iprot)
23714 
        else:
23715 
          iprot.skip(ftype)
23716 
      else:
23717 
        iprot.skip(ftype)
23718 
      iprot.readFieldEnd()
23719 
    iprot.readStructEnd()
23720 
 
23721 
  def write(self, oprot):
23722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23724 
      return
23725 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23726 
    if self.success is not None:
23727 
      oprot.writeFieldBegin('success', TType.I64, 0)
23728 
      oprot.writeI64(self.success)
23729 
      oprot.writeFieldEnd()
23730 
    if self.ex is not None:
23731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23732 
      self.ex.write(oprot)
23733 
      oprot.writeFieldEnd()
23734 
    oprot.writeFieldStop()
23735 
    oprot.writeStructEnd()
23736 
 
23737 
  def validate(self):
23738 
    return
23739 
 
23740 
 
23741 
  def __repr__(self):
23742 
    L = ['%s=%r' % (key, value)
23743 
      for key, value in self.__dict__.iteritems()]
23744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23745 
 
23746 
  def __eq__(self, other):
23747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23748 
 
23749 
  def __ne__(self, other):
23750 
    return not (self == other)
4715 varun.gupt 23751 
 
23752 
class getSettlementsByDate_args:
23753 
  """
23754 
  Attributes:
23755 
   - settlementDateFrom
23756 
   - settlementDateTo
23757 
   - isRefund
23758 
  """
23759 
 
23760 
  thrift_spec = (
23761 
    None, # 0
23762 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23763 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23764 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23765 
  )
23766 
 
23767 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23768 
    self.settlementDateFrom = settlementDateFrom
23769 
    self.settlementDateTo = settlementDateTo
23770 
    self.isRefund = isRefund
23771 
 
23772 
  def read(self, iprot):
23773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23775 
      return
23776 
    iprot.readStructBegin()
23777 
    while True:
23778 
      (fname, ftype, fid) = iprot.readFieldBegin()
23779 
      if ftype == TType.STOP:
23780 
        break
23781 
      if fid == 1:
23782 
        if ftype == TType.I64:
23783 
          self.settlementDateFrom = iprot.readI64();
23784 
        else:
23785 
          iprot.skip(ftype)
23786 
      elif fid == 2:
23787 
        if ftype == TType.I64:
23788 
          self.settlementDateTo = iprot.readI64();
23789 
        else:
23790 
          iprot.skip(ftype)
23791 
      elif fid == 3:
23792 
        if ftype == TType.BOOL:
23793 
          self.isRefund = iprot.readBool();
23794 
        else:
23795 
          iprot.skip(ftype)
23796 
      else:
23797 
        iprot.skip(ftype)
23798 
      iprot.readFieldEnd()
23799 
    iprot.readStructEnd()
23800 
 
23801 
  def write(self, oprot):
23802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23804 
      return
23805 
    oprot.writeStructBegin('getSettlementsByDate_args')
23806 
    if self.settlementDateFrom is not None:
23807 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23808 
      oprot.writeI64(self.settlementDateFrom)
23809 
      oprot.writeFieldEnd()
23810 
    if self.settlementDateTo is not None:
23811 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23812 
      oprot.writeI64(self.settlementDateTo)
23813 
      oprot.writeFieldEnd()
23814 
    if self.isRefund is not None:
23815 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23816 
      oprot.writeBool(self.isRefund)
23817 
      oprot.writeFieldEnd()
23818 
    oprot.writeFieldStop()
23819 
    oprot.writeStructEnd()
23820 
 
23821 
  def validate(self):
23822 
    return
23823 
 
23824 
 
23825 
  def __repr__(self):
23826 
    L = ['%s=%r' % (key, value)
23827 
      for key, value in self.__dict__.iteritems()]
23828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23829 
 
23830 
  def __eq__(self, other):
23831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23832 
 
23833 
  def __ne__(self, other):
23834 
    return not (self == other)
23835 
 
23836 
class getSettlementsByDate_result:
23837 
  """
23838 
  Attributes:
23839 
   - success
23840 
   - ex
23841 
  """
23842 
 
23843 
  thrift_spec = (
23844 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23846 
  )
23847 
 
23848 
  def __init__(self, success=None, ex=None,):
23849 
    self.success = success
23850 
    self.ex = ex
23851 
 
23852 
  def read(self, iprot):
23853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23855 
      return
23856 
    iprot.readStructBegin()
23857 
    while True:
23858 
      (fname, ftype, fid) = iprot.readFieldBegin()
23859 
      if ftype == TType.STOP:
23860 
        break
23861 
      if fid == 0:
23862 
        if ftype == TType.LIST:
23863 
          self.success = []
6188 rajveer 23864 
          (_etype566, _size563) = iprot.readListBegin()
23865 
          for _i567 in xrange(_size563):
23866 
            _elem568 = PaymentSettlement()
23867 
            _elem568.read(iprot)
23868 
            self.success.append(_elem568)
4715 varun.gupt 23869 
          iprot.readListEnd()
23870 
        else:
23871 
          iprot.skip(ftype)
23872 
      elif fid == 1:
23873 
        if ftype == TType.STRUCT:
23874 
          self.ex = TransactionServiceException()
23875 
          self.ex.read(iprot)
23876 
        else:
23877 
          iprot.skip(ftype)
23878 
      else:
23879 
        iprot.skip(ftype)
23880 
      iprot.readFieldEnd()
23881 
    iprot.readStructEnd()
23882 
 
23883 
  def write(self, oprot):
23884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23886 
      return
23887 
    oprot.writeStructBegin('getSettlementsByDate_result')
23888 
    if self.success is not None:
23889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23891 
      for iter569 in self.success:
23892 
        iter569.write(oprot)
4715 varun.gupt 23893 
      oprot.writeListEnd()
23894 
      oprot.writeFieldEnd()
23895 
    if self.ex is not None:
23896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23897 
      self.ex.write(oprot)
23898 
      oprot.writeFieldEnd()
23899 
    oprot.writeFieldStop()
23900 
    oprot.writeStructEnd()
23901 
 
23902 
  def validate(self):
23903 
    return
23904 
 
23905 
 
23906 
  def __repr__(self):
23907 
    L = ['%s=%r' % (key, value)
23908 
      for key, value in self.__dict__.iteritems()]
23909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23910 
 
23911 
  def __eq__(self, other):
23912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23913 
 
23914 
  def __ne__(self, other):
23915 
    return not (self == other)
23916 
 
23917 
class getReshippedOrderIds_args:
23918 
  """
23919 
  Attributes:
23920 
   - orderIds
23921 
  """
23922 
 
23923 
  thrift_spec = (
23924 
    None, # 0
23925 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23926 
  )
23927 
 
23928 
  def __init__(self, orderIds=None,):
23929 
    self.orderIds = orderIds
23930 
 
23931 
  def read(self, iprot):
23932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23934 
      return
23935 
    iprot.readStructBegin()
23936 
    while True:
23937 
      (fname, ftype, fid) = iprot.readFieldBegin()
23938 
      if ftype == TType.STOP:
23939 
        break
23940 
      if fid == 1:
23941 
        if ftype == TType.LIST:
23942 
          self.orderIds = []
6188 rajveer 23943 
          (_etype573, _size570) = iprot.readListBegin()
23944 
          for _i574 in xrange(_size570):
23945 
            _elem575 = iprot.readI64();
23946 
            self.orderIds.append(_elem575)
4715 varun.gupt 23947 
          iprot.readListEnd()
23948 
        else:
23949 
          iprot.skip(ftype)
23950 
      else:
23951 
        iprot.skip(ftype)
23952 
      iprot.readFieldEnd()
23953 
    iprot.readStructEnd()
23954 
 
23955 
  def write(self, oprot):
23956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23958 
      return
23959 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23960 
    if self.orderIds is not None:
23961 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23962 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23963 
      for iter576 in self.orderIds:
23964 
        oprot.writeI64(iter576)
4715 varun.gupt 23965 
      oprot.writeListEnd()
23966 
      oprot.writeFieldEnd()
23967 
    oprot.writeFieldStop()
23968 
    oprot.writeStructEnd()
23969 
 
23970 
  def validate(self):
23971 
    return
23972 
 
23973 
 
23974 
  def __repr__(self):
23975 
    L = ['%s=%r' % (key, value)
23976 
      for key, value in self.__dict__.iteritems()]
23977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23978 
 
23979 
  def __eq__(self, other):
23980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23981 
 
23982 
  def __ne__(self, other):
23983 
    return not (self == other)
23984 
 
23985 
class getReshippedOrderIds_result:
23986 
  """
23987 
  Attributes:
23988 
   - success
23989 
   - ex
23990 
  """
23991 
 
23992 
  thrift_spec = (
23993 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23995 
  )
23996 
 
23997 
  def __init__(self, success=None, ex=None,):
23998 
    self.success = success
23999 
    self.ex = ex
24000 
 
24001 
  def read(self, iprot):
24002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24004 
      return
24005 
    iprot.readStructBegin()
24006 
    while True:
24007 
      (fname, ftype, fid) = iprot.readFieldBegin()
24008 
      if ftype == TType.STOP:
24009 
        break
24010 
      if fid == 0:
24011 
        if ftype == TType.LIST:
24012 
          self.success = []
6188 rajveer 24013 
          (_etype580, _size577) = iprot.readListBegin()
24014 
          for _i581 in xrange(_size577):
24015 
            _elem582 = iprot.readI64();
24016 
            self.success.append(_elem582)
4715 varun.gupt 24017 
          iprot.readListEnd()
24018 
        else:
24019 
          iprot.skip(ftype)
24020 
      elif fid == 1:
24021 
        if ftype == TType.STRUCT:
24022 
          self.ex = TransactionServiceException()
24023 
          self.ex.read(iprot)
24024 
        else:
24025 
          iprot.skip(ftype)
24026 
      else:
24027 
        iprot.skip(ftype)
24028 
      iprot.readFieldEnd()
24029 
    iprot.readStructEnd()
24030 
 
24031 
  def write(self, oprot):
24032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24034 
      return
24035 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24036 
    if self.success is not None:
24037 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24038 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24039 
      for iter583 in self.success:
24040 
        oprot.writeI64(iter583)
4715 varun.gupt 24041 
      oprot.writeListEnd()
24042 
      oprot.writeFieldEnd()
24043 
    if self.ex is not None:
24044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24045 
      self.ex.write(oprot)
24046 
      oprot.writeFieldEnd()
24047 
    oprot.writeFieldStop()
24048 
    oprot.writeStructEnd()
24049 
 
24050 
  def validate(self):
24051 
    return
24052 
 
24053 
 
24054 
  def __repr__(self):
24055 
    L = ['%s=%r' % (key, value)
24056 
      for key, value in self.__dict__.iteritems()]
24057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24058 
 
24059 
  def __eq__(self, other):
24060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24061 
 
24062 
  def __ne__(self, other):
24063 
    return not (self == other)
4757 mandeep.dh 24064 
 
5481 phani.kuma 24065 
class getBilledOrders_args:
4875 varun.gupt 24066 
  """
24067 
  Attributes:
24068 
   - vendorId
5481 phani.kuma 24069 
   - onlyVendorNotPaid
24070 
   - billingDateFrom
24071 
   - billingDateTo
4875 varun.gupt 24072 
  """
24073 
 
24074 
  thrift_spec = (
24075 
    None, # 0
24076 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24077 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24078 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24079 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24080 
  )
24081 
 
5481 phani.kuma 24082 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24083 
    self.vendorId = vendorId
5481 phani.kuma 24084 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24085 
    self.billingDateFrom = billingDateFrom
24086 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24087 
 
24088 
  def read(self, iprot):
24089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24091 
      return
24092 
    iprot.readStructBegin()
24093 
    while True:
24094 
      (fname, ftype, fid) = iprot.readFieldBegin()
24095 
      if ftype == TType.STOP:
24096 
        break
24097 
      if fid == 1:
24098 
        if ftype == TType.I64:
24099 
          self.vendorId = iprot.readI64();
24100 
        else:
24101 
          iprot.skip(ftype)
5481 phani.kuma 24102 
      elif fid == 2:
24103 
        if ftype == TType.BOOL:
24104 
          self.onlyVendorNotPaid = iprot.readBool();
24105 
        else:
24106 
          iprot.skip(ftype)
24107 
      elif fid == 3:
24108 
        if ftype == TType.I64:
24109 
          self.billingDateFrom = iprot.readI64();
24110 
        else:
24111 
          iprot.skip(ftype)
24112 
      elif fid == 4:
24113 
        if ftype == TType.I64:
24114 
          self.billingDateTo = iprot.readI64();
24115 
        else:
24116 
          iprot.skip(ftype)
4875 varun.gupt 24117 
      else:
24118 
        iprot.skip(ftype)
24119 
      iprot.readFieldEnd()
24120 
    iprot.readStructEnd()
24121 
 
24122 
  def write(self, oprot):
24123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24125 
      return
5481 phani.kuma 24126 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24127 
    if self.vendorId is not None:
24128 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24129 
      oprot.writeI64(self.vendorId)
24130 
      oprot.writeFieldEnd()
5481 phani.kuma 24131 
    if self.onlyVendorNotPaid is not None:
24132 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24133 
      oprot.writeBool(self.onlyVendorNotPaid)
24134 
      oprot.writeFieldEnd()
24135 
    if self.billingDateFrom is not None:
24136 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24137 
      oprot.writeI64(self.billingDateFrom)
24138 
      oprot.writeFieldEnd()
24139 
    if self.billingDateTo is not None:
24140 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24141 
      oprot.writeI64(self.billingDateTo)
24142 
      oprot.writeFieldEnd()
4875 varun.gupt 24143 
    oprot.writeFieldStop()
24144 
    oprot.writeStructEnd()
24145 
 
24146 
  def validate(self):
24147 
    return
24148 
 
24149 
 
24150 
  def __repr__(self):
24151 
    L = ['%s=%r' % (key, value)
24152 
      for key, value in self.__dict__.iteritems()]
24153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24154 
 
24155 
  def __eq__(self, other):
24156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24157 
 
24158 
  def __ne__(self, other):
24159 
    return not (self == other)
24160 
 
5481 phani.kuma 24161 
class getBilledOrders_result:
4875 varun.gupt 24162 
  """
24163 
  Attributes:
24164 
   - success
24165 
   - ex
24166 
  """
24167 
 
24168 
  thrift_spec = (
24169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24171 
  )
24172 
 
24173 
  def __init__(self, success=None, ex=None,):
24174 
    self.success = success
24175 
    self.ex = ex
24176 
 
24177 
  def read(self, iprot):
24178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24180 
      return
24181 
    iprot.readStructBegin()
24182 
    while True:
24183 
      (fname, ftype, fid) = iprot.readFieldBegin()
24184 
      if ftype == TType.STOP:
24185 
        break
24186 
      if fid == 0:
24187 
        if ftype == TType.LIST:
24188 
          self.success = []
6188 rajveer 24189 
          (_etype587, _size584) = iprot.readListBegin()
24190 
          for _i588 in xrange(_size584):
24191 
            _elem589 = Order()
24192 
            _elem589.read(iprot)
24193 
            self.success.append(_elem589)
4875 varun.gupt 24194 
          iprot.readListEnd()
24195 
        else:
24196 
          iprot.skip(ftype)
24197 
      elif fid == 1:
24198 
        if ftype == TType.STRUCT:
24199 
          self.ex = TransactionServiceException()
24200 
          self.ex.read(iprot)
24201 
        else:
24202 
          iprot.skip(ftype)
24203 
      else:
24204 
        iprot.skip(ftype)
24205 
      iprot.readFieldEnd()
24206 
    iprot.readStructEnd()
24207 
 
24208 
  def write(self, oprot):
24209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24211 
      return
5481 phani.kuma 24212 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24213 
    if self.success is not None:
24214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24216 
      for iter590 in self.success:
24217 
        iter590.write(oprot)
4875 varun.gupt 24218 
      oprot.writeListEnd()
24219 
      oprot.writeFieldEnd()
24220 
    if self.ex is not None:
24221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24222 
      self.ex.write(oprot)
24223 
      oprot.writeFieldEnd()
24224 
    oprot.writeFieldStop()
24225 
    oprot.writeStructEnd()
24226 
 
24227 
  def validate(self):
24228 
    return
24229 
 
24230 
 
24231 
  def __repr__(self):
24232 
    L = ['%s=%r' % (key, value)
24233 
      for key, value in self.__dict__.iteritems()]
24234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24235 
 
24236 
  def __eq__(self, other):
24237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24238 
 
24239 
  def __ne__(self, other):
24240 
    return not (self == other)
5031 varun.gupt 24241 
 
24242 
class getStatusDistributionOfOrders_args:
24243 
  """
24244 
  Attributes:
24245 
   - startDate
24246 
   - endDate
24247 
  """
24248 
 
24249 
  thrift_spec = (
24250 
    None, # 0
24251 
    (1, TType.I64, 'startDate', None, None, ), # 1
24252 
    (2, TType.I64, 'endDate', None, None, ), # 2
24253 
  )
24254 
 
24255 
  def __init__(self, startDate=None, endDate=None,):
24256 
    self.startDate = startDate
24257 
    self.endDate = endDate
24258 
 
24259 
  def read(self, iprot):
24260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24262 
      return
24263 
    iprot.readStructBegin()
24264 
    while True:
24265 
      (fname, ftype, fid) = iprot.readFieldBegin()
24266 
      if ftype == TType.STOP:
24267 
        break
24268 
      if fid == 1:
24269 
        if ftype == TType.I64:
24270 
          self.startDate = iprot.readI64();
24271 
        else:
24272 
          iprot.skip(ftype)
24273 
      elif fid == 2:
24274 
        if ftype == TType.I64:
24275 
          self.endDate = iprot.readI64();
24276 
        else:
24277 
          iprot.skip(ftype)
24278 
      else:
24279 
        iprot.skip(ftype)
24280 
      iprot.readFieldEnd()
24281 
    iprot.readStructEnd()
24282 
 
24283 
  def write(self, oprot):
24284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24286 
      return
24287 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24288 
    if self.startDate is not None:
24289 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24290 
      oprot.writeI64(self.startDate)
24291 
      oprot.writeFieldEnd()
24292 
    if self.endDate is not None:
24293 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24294 
      oprot.writeI64(self.endDate)
24295 
      oprot.writeFieldEnd()
24296 
    oprot.writeFieldStop()
24297 
    oprot.writeStructEnd()
24298 
 
24299 
  def validate(self):
24300 
    return
24301 
 
24302 
 
24303 
  def __repr__(self):
24304 
    L = ['%s=%r' % (key, value)
24305 
      for key, value in self.__dict__.iteritems()]
24306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24307 
 
24308 
  def __eq__(self, other):
24309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24310 
 
24311 
  def __ne__(self, other):
24312 
    return not (self == other)
24313 
 
24314 
class getStatusDistributionOfOrders_result:
24315 
  """
24316 
  Attributes:
24317 
   - success
24318 
   - ex
24319 
  """
24320 
 
24321 
  thrift_spec = (
24322 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24324 
  )
24325 
 
24326 
  def __init__(self, success=None, ex=None,):
24327 
    self.success = success
24328 
    self.ex = ex
24329 
 
24330 
  def read(self, iprot):
24331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24333 
      return
24334 
    iprot.readStructBegin()
24335 
    while True:
24336 
      (fname, ftype, fid) = iprot.readFieldBegin()
24337 
      if ftype == TType.STOP:
24338 
        break
24339 
      if fid == 0:
24340 
        if ftype == TType.MAP:
24341 
          self.success = {}
6188 rajveer 24342 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24343 
          for _i595 in xrange(_size591):
24344 
            _key596 = iprot.readI64();
24345 
            _val597 = iprot.readI64();
24346 
            self.success[_key596] = _val597
5031 varun.gupt 24347 
          iprot.readMapEnd()
24348 
        else:
24349 
          iprot.skip(ftype)
24350 
      elif fid == 1:
24351 
        if ftype == TType.STRUCT:
24352 
          self.ex = TransactionServiceException()
24353 
          self.ex.read(iprot)
24354 
        else:
24355 
          iprot.skip(ftype)
24356 
      else:
24357 
        iprot.skip(ftype)
24358 
      iprot.readFieldEnd()
24359 
    iprot.readStructEnd()
24360 
 
24361 
  def write(self, oprot):
24362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24364 
      return
24365 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24366 
    if self.success is not None:
24367 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24368 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24369 
      for kiter598,viter599 in self.success.items():
24370 
        oprot.writeI64(kiter598)
24371 
        oprot.writeI64(viter599)
5031 varun.gupt 24372 
      oprot.writeMapEnd()
24373 
      oprot.writeFieldEnd()
24374 
    if self.ex is not None:
24375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24376 
      self.ex.write(oprot)
24377 
      oprot.writeFieldEnd()
24378 
    oprot.writeFieldStop()
24379 
    oprot.writeStructEnd()
24380 
 
24381 
  def validate(self):
24382 
    return
24383 
 
24384 
 
24385 
  def __repr__(self):
24386 
    L = ['%s=%r' % (key, value)
24387 
      for key, value in self.__dict__.iteritems()]
24388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24389 
 
24390 
  def __eq__(self, other):
24391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24392 
 
24393 
  def __ne__(self, other):
24394 
    return not (self == other)
5067 varun.gupt 24395 
 
24396 
class getOrderIdsForStatus_args:
24397 
  """
24398 
  Attributes:
24399 
   - status
24400 
   - startDatetime
24401 
   - endDatetime
24402 
  """
24403 
 
24404 
  thrift_spec = (
24405 
    None, # 0
24406 
    (1, TType.I64, 'status', None, None, ), # 1
24407 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24408 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24409 
  )
24410 
 
24411 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24412 
    self.status = status
24413 
    self.startDatetime = startDatetime
24414 
    self.endDatetime = endDatetime
24415 
 
24416 
  def read(self, iprot):
24417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24419 
      return
24420 
    iprot.readStructBegin()
24421 
    while True:
24422 
      (fname, ftype, fid) = iprot.readFieldBegin()
24423 
      if ftype == TType.STOP:
24424 
        break
24425 
      if fid == 1:
24426 
        if ftype == TType.I64:
24427 
          self.status = iprot.readI64();
24428 
        else:
24429 
          iprot.skip(ftype)
24430 
      elif fid == 2:
24431 
        if ftype == TType.I64:
24432 
          self.startDatetime = iprot.readI64();
24433 
        else:
24434 
          iprot.skip(ftype)
24435 
      elif fid == 3:
24436 
        if ftype == TType.I64:
24437 
          self.endDatetime = iprot.readI64();
24438 
        else:
24439 
          iprot.skip(ftype)
24440 
      else:
24441 
        iprot.skip(ftype)
24442 
      iprot.readFieldEnd()
24443 
    iprot.readStructEnd()
24444 
 
24445 
  def write(self, oprot):
24446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24448 
      return
24449 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24450 
    if self.status is not None:
24451 
      oprot.writeFieldBegin('status', TType.I64, 1)
24452 
      oprot.writeI64(self.status)
24453 
      oprot.writeFieldEnd()
24454 
    if self.startDatetime is not None:
24455 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24456 
      oprot.writeI64(self.startDatetime)
24457 
      oprot.writeFieldEnd()
24458 
    if self.endDatetime is not None:
24459 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24460 
      oprot.writeI64(self.endDatetime)
24461 
      oprot.writeFieldEnd()
24462 
    oprot.writeFieldStop()
24463 
    oprot.writeStructEnd()
24464 
 
24465 
  def validate(self):
24466 
    return
24467 
 
24468 
 
24469 
  def __repr__(self):
24470 
    L = ['%s=%r' % (key, value)
24471 
      for key, value in self.__dict__.iteritems()]
24472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24473 
 
24474 
  def __eq__(self, other):
24475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24476 
 
24477 
  def __ne__(self, other):
24478 
    return not (self == other)
24479 
 
24480 
class getOrderIdsForStatus_result:
24481 
  """
24482 
  Attributes:
24483 
   - success
24484 
   - ex
24485 
  """
24486 
 
24487 
  thrift_spec = (
24488 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24490 
  )
24491 
 
24492 
  def __init__(self, success=None, ex=None,):
24493 
    self.success = success
24494 
    self.ex = ex
24495 
 
24496 
  def read(self, iprot):
24497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24499 
      return
24500 
    iprot.readStructBegin()
24501 
    while True:
24502 
      (fname, ftype, fid) = iprot.readFieldBegin()
24503 
      if ftype == TType.STOP:
24504 
        break
24505 
      if fid == 0:
24506 
        if ftype == TType.LIST:
24507 
          self.success = []
6188 rajveer 24508 
          (_etype603, _size600) = iprot.readListBegin()
24509 
          for _i604 in xrange(_size600):
24510 
            _elem605 = iprot.readI64();
24511 
            self.success.append(_elem605)
5067 varun.gupt 24512 
          iprot.readListEnd()
24513 
        else:
24514 
          iprot.skip(ftype)
24515 
      elif fid == 1:
24516 
        if ftype == TType.STRUCT:
24517 
          self.ex = TransactionServiceException()
24518 
          self.ex.read(iprot)
24519 
        else:
24520 
          iprot.skip(ftype)
24521 
      else:
24522 
        iprot.skip(ftype)
24523 
      iprot.readFieldEnd()
24524 
    iprot.readStructEnd()
24525 
 
24526 
  def write(self, oprot):
24527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24529 
      return
24530 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24531 
    if self.success is not None:
24532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24533 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24534 
      for iter606 in self.success:
24535 
        oprot.writeI64(iter606)
5067 varun.gupt 24536 
      oprot.writeListEnd()
24537 
      oprot.writeFieldEnd()
24538 
    if self.ex is not None:
24539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24540 
      self.ex.write(oprot)
24541 
      oprot.writeFieldEnd()
24542 
    oprot.writeFieldStop()
24543 
    oprot.writeStructEnd()
24544 
 
24545 
  def validate(self):
24546 
    return
24547 
 
24548 
 
24549 
  def __repr__(self):
24550 
    L = ['%s=%r' % (key, value)
24551 
      for key, value in self.__dict__.iteritems()]
24552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24553 
 
24554 
  def __eq__(self, other):
24555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24556 
 
24557 
  def __ne__(self, other):
24558 
    return not (self == other)
5099 varun.gupt 24559 
 
5348 anupam.sin 24560 
class updateCODAgent_args:
24561 
  """
24562 
  Attributes:
24563 
   - agent
24564 
   - orderId
24565 
  """
24566 
 
24567 
  thrift_spec = (
24568 
    None, # 0
24569 
    (1, TType.STRING, 'agent', None, None, ), # 1
24570 
    (2, TType.I64, 'orderId', None, None, ), # 2
24571 
  )
24572 
 
24573 
  def __init__(self, agent=None, orderId=None,):
24574 
    self.agent = agent
24575 
    self.orderId = orderId
24576 
 
24577 
  def read(self, iprot):
24578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24580 
      return
24581 
    iprot.readStructBegin()
24582 
    while True:
24583 
      (fname, ftype, fid) = iprot.readFieldBegin()
24584 
      if ftype == TType.STOP:
24585 
        break
24586 
      if fid == 1:
24587 
        if ftype == TType.STRING:
24588 
          self.agent = iprot.readString();
24589 
        else:
24590 
          iprot.skip(ftype)
24591 
      elif fid == 2:
24592 
        if ftype == TType.I64:
24593 
          self.orderId = iprot.readI64();
24594 
        else:
24595 
          iprot.skip(ftype)
24596 
      else:
24597 
        iprot.skip(ftype)
24598 
      iprot.readFieldEnd()
24599 
    iprot.readStructEnd()
24600 
 
24601 
  def write(self, oprot):
24602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24604 
      return
24605 
    oprot.writeStructBegin('updateCODAgent_args')
24606 
    if self.agent is not None:
24607 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24608 
      oprot.writeString(self.agent)
24609 
      oprot.writeFieldEnd()
24610 
    if self.orderId is not None:
24611 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24612 
      oprot.writeI64(self.orderId)
24613 
      oprot.writeFieldEnd()
24614 
    oprot.writeFieldStop()
24615 
    oprot.writeStructEnd()
24616 
 
24617 
  def validate(self):
24618 
    return
24619 
 
24620 
 
24621 
  def __repr__(self):
24622 
    L = ['%s=%r' % (key, value)
24623 
      for key, value in self.__dict__.iteritems()]
24624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24625 
 
24626 
  def __eq__(self, other):
24627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24628 
 
24629 
  def __ne__(self, other):
24630 
    return not (self == other)
24631 
 
24632 
class updateCODAgent_result:
24633 
  """
24634 
  Attributes:
24635 
   - ex
24636 
  """
24637 
 
24638 
  thrift_spec = (
24639 
    None, # 0
24640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24641 
  )
24642 
 
24643 
  def __init__(self, ex=None,):
24644 
    self.ex = ex
24645 
 
24646 
  def read(self, iprot):
24647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24649 
      return
24650 
    iprot.readStructBegin()
24651 
    while True:
24652 
      (fname, ftype, fid) = iprot.readFieldBegin()
24653 
      if ftype == TType.STOP:
24654 
        break
24655 
      if fid == 1:
24656 
        if ftype == TType.STRUCT:
24657 
          self.ex = TransactionServiceException()
24658 
          self.ex.read(iprot)
24659 
        else:
24660 
          iprot.skip(ftype)
24661 
      else:
24662 
        iprot.skip(ftype)
24663 
      iprot.readFieldEnd()
24664 
    iprot.readStructEnd()
24665 
 
24666 
  def write(self, oprot):
24667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24669 
      return
24670 
    oprot.writeStructBegin('updateCODAgent_result')
24671 
    if self.ex is not None:
24672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24673 
      self.ex.write(oprot)
24674 
      oprot.writeFieldEnd()
24675 
    oprot.writeFieldStop()
24676 
    oprot.writeStructEnd()
24677 
 
24678 
  def validate(self):
24679 
    return
24680 
 
24681 
 
24682 
  def __repr__(self):
24683 
    L = ['%s=%r' % (key, value)
24684 
      for key, value in self.__dict__.iteritems()]
24685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24686 
 
24687 
  def __eq__(self, other):
24688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24689 
 
24690 
  def __ne__(self, other):
24691 
    return not (self == other)
24692 
 
5099 varun.gupt 24693 
class updateOrderAsPaidToVendor_args:
24694 
  """
24695 
  Attributes:
24696 
   - orderId
24697 
  """
24698 
 
24699 
  thrift_spec = (
24700 
    None, # 0
24701 
    (1, TType.I64, 'orderId', None, None, ), # 1
24702 
  )
24703 
 
24704 
  def __init__(self, orderId=None,):
24705 
    self.orderId = orderId
24706 
 
24707 
  def read(self, iprot):
24708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24710 
      return
24711 
    iprot.readStructBegin()
24712 
    while True:
24713 
      (fname, ftype, fid) = iprot.readFieldBegin()
24714 
      if ftype == TType.STOP:
24715 
        break
24716 
      if fid == 1:
24717 
        if ftype == TType.I64:
24718 
          self.orderId = iprot.readI64();
24719 
        else:
24720 
          iprot.skip(ftype)
24721 
      else:
24722 
        iprot.skip(ftype)
24723 
      iprot.readFieldEnd()
24724 
    iprot.readStructEnd()
24725 
 
24726 
  def write(self, oprot):
24727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24729 
      return
24730 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24731 
    if self.orderId is not None:
24732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24733 
      oprot.writeI64(self.orderId)
24734 
      oprot.writeFieldEnd()
24735 
    oprot.writeFieldStop()
24736 
    oprot.writeStructEnd()
24737 
 
24738 
  def validate(self):
24739 
    return
24740 
 
24741 
 
24742 
  def __repr__(self):
24743 
    L = ['%s=%r' % (key, value)
24744 
      for key, value in self.__dict__.iteritems()]
24745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24746 
 
24747 
  def __eq__(self, other):
24748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24749 
 
24750 
  def __ne__(self, other):
24751 
    return not (self == other)
24752 
 
24753 
class updateOrderAsPaidToVendor_result:
24754 
  """
24755 
  Attributes:
24756 
   - ex
24757 
  """
24758 
 
24759 
  thrift_spec = (
24760 
    None, # 0
24761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24762 
  )
24763 
 
24764 
  def __init__(self, ex=None,):
24765 
    self.ex = ex
24766 
 
24767 
  def read(self, iprot):
24768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24770 
      return
24771 
    iprot.readStructBegin()
24772 
    while True:
24773 
      (fname, ftype, fid) = iprot.readFieldBegin()
24774 
      if ftype == TType.STOP:
24775 
        break
24776 
      if fid == 1:
24777 
        if ftype == TType.STRUCT:
24778 
          self.ex = TransactionServiceException()
24779 
          self.ex.read(iprot)
24780 
        else:
24781 
          iprot.skip(ftype)
24782 
      else:
24783 
        iprot.skip(ftype)
24784 
      iprot.readFieldEnd()
24785 
    iprot.readStructEnd()
24786 
 
24787 
  def write(self, oprot):
24788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24790 
      return
24791 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24792 
    if self.ex is not None:
24793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24794 
      self.ex.write(oprot)
24795 
      oprot.writeFieldEnd()
24796 
    oprot.writeFieldStop()
24797 
    oprot.writeStructEnd()
24798 
 
24799 
  def validate(self):
24800 
    return
24801 
 
24802 
 
24803 
  def __repr__(self):
24804 
    L = ['%s=%r' % (key, value)
24805 
      for key, value in self.__dict__.iteritems()]
24806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24807 
 
24808 
  def __eq__(self, other):
24809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24810 
 
24811 
  def __ne__(self, other):
24812 
    return not (self == other)
5208 varun.gupt 24813 
 
5386 phani.kuma 24814 
class updateOrderOnlyAsPaidToVendor_args:
24815 
  """
24816 
  Attributes:
24817 
   - orderId
24818 
  """
24819 
 
24820 
  thrift_spec = (
24821 
    None, # 0
24822 
    (1, TType.I64, 'orderId', None, None, ), # 1
24823 
  )
24824 
 
24825 
  def __init__(self, orderId=None,):
24826 
    self.orderId = orderId
24827 
 
24828 
  def read(self, iprot):
24829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24831 
      return
24832 
    iprot.readStructBegin()
24833 
    while True:
24834 
      (fname, ftype, fid) = iprot.readFieldBegin()
24835 
      if ftype == TType.STOP:
24836 
        break
24837 
      if fid == 1:
24838 
        if ftype == TType.I64:
24839 
          self.orderId = iprot.readI64();
24840 
        else:
24841 
          iprot.skip(ftype)
24842 
      else:
24843 
        iprot.skip(ftype)
24844 
      iprot.readFieldEnd()
24845 
    iprot.readStructEnd()
24846 
 
24847 
  def write(self, oprot):
24848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24850 
      return
24851 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24852 
    if self.orderId is not None:
24853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24854 
      oprot.writeI64(self.orderId)
24855 
      oprot.writeFieldEnd()
24856 
    oprot.writeFieldStop()
24857 
    oprot.writeStructEnd()
24858 
 
24859 
  def validate(self):
24860 
    return
24861 
 
24862 
 
24863 
  def __repr__(self):
24864 
    L = ['%s=%r' % (key, value)
24865 
      for key, value in self.__dict__.iteritems()]
24866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24867 
 
24868 
  def __eq__(self, other):
24869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24870 
 
24871 
  def __ne__(self, other):
24872 
    return not (self == other)
24873 
 
24874 
class updateOrderOnlyAsPaidToVendor_result:
24875 
  """
24876 
  Attributes:
24877 
   - ex
24878 
  """
24879 
 
24880 
  thrift_spec = (
24881 
    None, # 0
24882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24883 
  )
24884 
 
24885 
  def __init__(self, ex=None,):
24886 
    self.ex = ex
24887 
 
24888 
  def read(self, iprot):
24889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24891 
      return
24892 
    iprot.readStructBegin()
24893 
    while True:
24894 
      (fname, ftype, fid) = iprot.readFieldBegin()
24895 
      if ftype == TType.STOP:
24896 
        break
24897 
      if fid == 1:
24898 
        if ftype == TType.STRUCT:
24899 
          self.ex = TransactionServiceException()
24900 
          self.ex.read(iprot)
24901 
        else:
24902 
          iprot.skip(ftype)
24903 
      else:
24904 
        iprot.skip(ftype)
24905 
      iprot.readFieldEnd()
24906 
    iprot.readStructEnd()
24907 
 
24908 
  def write(self, oprot):
24909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24911 
      return
24912 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24913 
    if self.ex is not None:
24914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24915 
      self.ex.write(oprot)
24916 
      oprot.writeFieldEnd()
24917 
    oprot.writeFieldStop()
24918 
    oprot.writeStructEnd()
24919 
 
24920 
  def validate(self):
24921 
    return
24922 
 
24923 
 
24924 
  def __repr__(self):
24925 
    L = ['%s=%r' % (key, value)
24926 
      for key, value in self.__dict__.iteritems()]
24927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24928 
 
24929 
  def __eq__(self, other):
24930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24931 
 
24932 
  def __ne__(self, other):
24933 
    return not (self == other)
24934 
 
5208 varun.gupt 24935 
class getRefundedOrdersMarkedPaid_args:
24936 
 
24937 
  thrift_spec = (
24938 
  )
24939 
 
24940 
  def read(self, iprot):
24941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24943 
      return
24944 
    iprot.readStructBegin()
24945 
    while True:
24946 
      (fname, ftype, fid) = iprot.readFieldBegin()
24947 
      if ftype == TType.STOP:
24948 
        break
24949 
      else:
24950 
        iprot.skip(ftype)
24951 
      iprot.readFieldEnd()
24952 
    iprot.readStructEnd()
24953 
 
24954 
  def write(self, oprot):
24955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24957 
      return
24958 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24959 
    oprot.writeFieldStop()
24960 
    oprot.writeStructEnd()
24961 
 
24962 
  def validate(self):
24963 
    return
24964 
 
24965 
 
24966 
  def __repr__(self):
24967 
    L = ['%s=%r' % (key, value)
24968 
      for key, value in self.__dict__.iteritems()]
24969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24970 
 
24971 
  def __eq__(self, other):
24972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24973 
 
24974 
  def __ne__(self, other):
24975 
    return not (self == other)
24976 
 
24977 
class getRefundedOrdersMarkedPaid_result:
24978 
  """
24979 
  Attributes:
24980 
   - success
24981 
   - ex
24982 
  """
24983 
 
24984 
  thrift_spec = (
24985 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24987 
  )
24988 
 
24989 
  def __init__(self, success=None, ex=None,):
24990 
    self.success = success
24991 
    self.ex = ex
24992 
 
24993 
  def read(self, iprot):
24994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24996 
      return
24997 
    iprot.readStructBegin()
24998 
    while True:
24999 
      (fname, ftype, fid) = iprot.readFieldBegin()
25000 
      if ftype == TType.STOP:
25001 
        break
25002 
      if fid == 0:
25003 
        if ftype == TType.LIST:
25004 
          self.success = []
6188 rajveer 25005 
          (_etype610, _size607) = iprot.readListBegin()
25006 
          for _i611 in xrange(_size607):
25007 
            _elem612 = Order()
25008 
            _elem612.read(iprot)
25009 
            self.success.append(_elem612)
5208 varun.gupt 25010 
          iprot.readListEnd()
25011 
        else:
25012 
          iprot.skip(ftype)
25013 
      elif fid == 1:
25014 
        if ftype == TType.STRUCT:
25015 
          self.ex = TransactionServiceException()
25016 
          self.ex.read(iprot)
25017 
        else:
25018 
          iprot.skip(ftype)
25019 
      else:
25020 
        iprot.skip(ftype)
25021 
      iprot.readFieldEnd()
25022 
    iprot.readStructEnd()
25023 
 
25024 
  def write(self, oprot):
25025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25027 
      return
25028 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25029 
    if self.success is not None:
25030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25032 
      for iter613 in self.success:
25033 
        iter613.write(oprot)
5208 varun.gupt 25034 
      oprot.writeListEnd()
25035 
      oprot.writeFieldEnd()
25036 
    if self.ex is not None:
25037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25038 
      self.ex.write(oprot)
25039 
      oprot.writeFieldEnd()
25040 
    oprot.writeFieldStop()
25041 
    oprot.writeStructEnd()
25042 
 
25043 
  def validate(self):
25044 
    return
25045 
 
25046 
 
25047 
  def __repr__(self):
25048 
    L = ['%s=%r' % (key, value)
25049 
      for key, value in self.__dict__.iteritems()]
25050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25051 
 
25052 
  def __eq__(self, other):
25053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25054 
 
25055 
  def __ne__(self, other):
25056 
    return not (self == other)
5447 anupam.sin 25057 
 
25058 
class getAllVerificationAgents_args:
25059 
  """
25060 
  Attributes:
25061 
   - minOrderId
25062 
   - maxOrderId
25063 
  """
25064 
 
25065 
  thrift_spec = (
25066 
    None, # 0
25067 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25068 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25069 
  )
25070 
 
25071 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25072 
    self.minOrderId = minOrderId
25073 
    self.maxOrderId = maxOrderId
25074 
 
25075 
  def read(self, iprot):
25076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25078 
      return
25079 
    iprot.readStructBegin()
25080 
    while True:
25081 
      (fname, ftype, fid) = iprot.readFieldBegin()
25082 
      if ftype == TType.STOP:
25083 
        break
25084 
      if fid == 1:
25085 
        if ftype == TType.I64:
25086 
          self.minOrderId = iprot.readI64();
25087 
        else:
25088 
          iprot.skip(ftype)
25089 
      elif fid == 2:
25090 
        if ftype == TType.I64:
25091 
          self.maxOrderId = iprot.readI64();
25092 
        else:
25093 
          iprot.skip(ftype)
25094 
      else:
25095 
        iprot.skip(ftype)
25096 
      iprot.readFieldEnd()
25097 
    iprot.readStructEnd()
25098 
 
25099 
  def write(self, oprot):
25100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25102 
      return
25103 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25104 
    if self.minOrderId is not None:
25105 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25106 
      oprot.writeI64(self.minOrderId)
25107 
      oprot.writeFieldEnd()
25108 
    if self.maxOrderId is not None:
25109 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25110 
      oprot.writeI64(self.maxOrderId)
25111 
      oprot.writeFieldEnd()
25112 
    oprot.writeFieldStop()
25113 
    oprot.writeStructEnd()
25114 
 
25115 
  def validate(self):
25116 
    return
25117 
 
25118 
 
25119 
  def __repr__(self):
25120 
    L = ['%s=%r' % (key, value)
25121 
      for key, value in self.__dict__.iteritems()]
25122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25123 
 
25124 
  def __eq__(self, other):
25125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25126 
 
25127 
  def __ne__(self, other):
25128 
    return not (self == other)
25129 
 
25130 
class getAllVerificationAgents_result:
25131 
  """
25132 
  Attributes:
25133 
   - success
25134 
  """
25135 
 
25136 
  thrift_spec = (
25137 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25138 
  )
25139 
 
25140 
  def __init__(self, success=None,):
25141 
    self.success = success
25142 
 
25143 
  def read(self, iprot):
25144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25146 
      return
25147 
    iprot.readStructBegin()
25148 
    while True:
25149 
      (fname, ftype, fid) = iprot.readFieldBegin()
25150 
      if ftype == TType.STOP:
25151 
        break
25152 
      if fid == 0:
25153 
        if ftype == TType.LIST:
25154 
          self.success = []
6188 rajveer 25155 
          (_etype617, _size614) = iprot.readListBegin()
25156 
          for _i618 in xrange(_size614):
25157 
            _elem619 = CODVerificationAgent()
25158 
            _elem619.read(iprot)
25159 
            self.success.append(_elem619)
5447 anupam.sin 25160 
          iprot.readListEnd()
25161 
        else:
25162 
          iprot.skip(ftype)
25163 
      else:
25164 
        iprot.skip(ftype)
25165 
      iprot.readFieldEnd()
25166 
    iprot.readStructEnd()
25167 
 
25168 
  def write(self, oprot):
25169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25171 
      return
25172 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25173 
    if self.success is not None:
25174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25176 
      for iter620 in self.success:
25177 
        iter620.write(oprot)
5447 anupam.sin 25178 
      oprot.writeListEnd()
25179 
      oprot.writeFieldEnd()
25180 
    oprot.writeFieldStop()
25181 
    oprot.writeStructEnd()
25182 
 
25183 
  def validate(self):
25184 
    return
25185 
 
25186 
 
25187 
  def __repr__(self):
25188 
    L = ['%s=%r' % (key, value)
25189 
      for key, value in self.__dict__.iteritems()]
25190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25191 
 
25192 
  def __eq__(self, other):
25193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25194 
 
25195 
  def __ne__(self, other):
25196 
    return not (self == other)
5527 anupam.sin 25197 
 
25198 
class getAllAttributesForOrderId_args:
25199 
  """
25200 
  Attributes:
25201 
   - orderId
25202 
  """
25203 
 
25204 
  thrift_spec = (
25205 
    None, # 0
25206 
    (1, TType.I64, 'orderId', None, None, ), # 1
25207 
  )
25208 
 
25209 
  def __init__(self, orderId=None,):
25210 
    self.orderId = orderId
25211 
 
25212 
  def read(self, iprot):
25213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25215 
      return
25216 
    iprot.readStructBegin()
25217 
    while True:
25218 
      (fname, ftype, fid) = iprot.readFieldBegin()
25219 
      if ftype == TType.STOP:
25220 
        break
25221 
      if fid == 1:
25222 
        if ftype == TType.I64:
25223 
          self.orderId = iprot.readI64();
25224 
        else:
25225 
          iprot.skip(ftype)
25226 
      else:
25227 
        iprot.skip(ftype)
25228 
      iprot.readFieldEnd()
25229 
    iprot.readStructEnd()
25230 
 
25231 
  def write(self, oprot):
25232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25234 
      return
25235 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25236 
    if self.orderId is not None:
25237 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25238 
      oprot.writeI64(self.orderId)
25239 
      oprot.writeFieldEnd()
25240 
    oprot.writeFieldStop()
25241 
    oprot.writeStructEnd()
25242 
 
25243 
  def validate(self):
25244 
    return
25245 
 
25246 
 
25247 
  def __repr__(self):
25248 
    L = ['%s=%r' % (key, value)
25249 
      for key, value in self.__dict__.iteritems()]
25250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25251 
 
25252 
  def __eq__(self, other):
25253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25254 
 
25255 
  def __ne__(self, other):
25256 
    return not (self == other)
25257 
 
25258 
class getAllAttributesForOrderId_result:
25259 
  """
25260 
  Attributes:
25261 
   - success
25262 
  """
25263 
 
25264 
  thrift_spec = (
25265 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25266 
  )
25267 
 
25268 
  def __init__(self, success=None,):
25269 
    self.success = success
25270 
 
25271 
  def read(self, iprot):
25272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25274 
      return
25275 
    iprot.readStructBegin()
25276 
    while True:
25277 
      (fname, ftype, fid) = iprot.readFieldBegin()
25278 
      if ftype == TType.STOP:
25279 
        break
25280 
      if fid == 0:
25281 
        if ftype == TType.LIST:
25282 
          self.success = []
6188 rajveer 25283 
          (_etype624, _size621) = iprot.readListBegin()
25284 
          for _i625 in xrange(_size621):
25285 
            _elem626 = Attribute()
25286 
            _elem626.read(iprot)
25287 
            self.success.append(_elem626)
5527 anupam.sin 25288 
          iprot.readListEnd()
25289 
        else:
25290 
          iprot.skip(ftype)
25291 
      else:
25292 
        iprot.skip(ftype)
25293 
      iprot.readFieldEnd()
25294 
    iprot.readStructEnd()
25295 
 
25296 
  def write(self, oprot):
25297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25299 
      return
25300 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25301 
    if self.success is not None:
25302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25304 
      for iter627 in self.success:
25305 
        iter627.write(oprot)
5527 anupam.sin 25306 
      oprot.writeListEnd()
25307 
      oprot.writeFieldEnd()
25308 
    oprot.writeFieldStop()
25309 
    oprot.writeStructEnd()
25310 
 
25311 
  def validate(self):
25312 
    return
25313 
 
25314 
 
25315 
  def __repr__(self):
25316 
    L = ['%s=%r' % (key, value)
25317 
      for key, value in self.__dict__.iteritems()]
25318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25319 
 
25320 
  def __eq__(self, other):
25321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25322 
 
25323 
  def __ne__(self, other):
25324 
    return not (self == other)
25325 
 
5676 rajveer 25326 
class setOrderAttributes_args:
25327 
  """
25328 
  Attributes:
25329 
   - orderId
25330 
   - attributes
25331 
  """
25332 
 
25333 
  thrift_spec = None
25334 
  def __init__(self, orderId=None, attributes=None,):
25335 
    self.orderId = orderId
25336 
    self.attributes = attributes
25337 
 
25338 
  def read(self, iprot):
25339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25341 
      return
25342 
    iprot.readStructBegin()
25343 
    while True:
25344 
      (fname, ftype, fid) = iprot.readFieldBegin()
25345 
      if ftype == TType.STOP:
25346 
        break
25347 
      if fid == 1:
25348 
        if ftype == TType.I64:
25349 
          self.orderId = iprot.readI64();
25350 
        else:
25351 
          iprot.skip(ftype)
25352 
      elif fid == -1:
25353 
        if ftype == TType.LIST:
25354 
          self.attributes = []
6188 rajveer 25355 
          (_etype631, _size628) = iprot.readListBegin()
25356 
          for _i632 in xrange(_size628):
25357 
            _elem633 = Attribute()
25358 
            _elem633.read(iprot)
25359 
            self.attributes.append(_elem633)
5676 rajveer 25360 
          iprot.readListEnd()
25361 
        else:
25362 
          iprot.skip(ftype)
25363 
      else:
25364 
        iprot.skip(ftype)
25365 
      iprot.readFieldEnd()
25366 
    iprot.readStructEnd()
25367 
 
25368 
  def write(self, oprot):
25369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25371 
      return
25372 
    oprot.writeStructBegin('setOrderAttributes_args')
25373 
    if self.attributes is not None:
25374 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25375 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25376 
      for iter634 in self.attributes:
25377 
        iter634.write(oprot)
5676 rajveer 25378 
      oprot.writeListEnd()
25379 
      oprot.writeFieldEnd()
25380 
    if self.orderId is not None:
25381 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25382 
      oprot.writeI64(self.orderId)
25383 
      oprot.writeFieldEnd()
25384 
    oprot.writeFieldStop()
25385 
    oprot.writeStructEnd()
25386 
 
25387 
  def validate(self):
25388 
    return
25389 
 
25390 
 
25391 
  def __repr__(self):
25392 
    L = ['%s=%r' % (key, value)
25393 
      for key, value in self.__dict__.iteritems()]
25394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25395 
 
25396 
  def __eq__(self, other):
25397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25398 
 
25399 
  def __ne__(self, other):
25400 
    return not (self == other)
25401 
 
25402 
class setOrderAttributes_result:
25403 
 
25404 
  thrift_spec = (
25405 
  )
25406 
 
25407 
  def read(self, iprot):
25408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25410 
      return
25411 
    iprot.readStructBegin()
25412 
    while True:
25413 
      (fname, ftype, fid) = iprot.readFieldBegin()
25414 
      if ftype == TType.STOP:
25415 
        break
25416 
      else:
25417 
        iprot.skip(ftype)
25418 
      iprot.readFieldEnd()
25419 
    iprot.readStructEnd()
25420 
 
25421 
  def write(self, oprot):
25422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25424 
      return
25425 
    oprot.writeStructBegin('setOrderAttributes_result')
25426 
    oprot.writeFieldStop()
25427 
    oprot.writeStructEnd()
25428 
 
25429 
  def validate(self):
25430 
    return
25431 
 
25432 
 
25433 
  def __repr__(self):
25434 
    L = ['%s=%r' % (key, value)
25435 
      for key, value in self.__dict__.iteritems()]
25436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25437 
 
25438 
  def __eq__(self, other):
25439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25440 
 
25441 
  def __ne__(self, other):
25442 
    return not (self == other)
25443 
 
5527 anupam.sin 25444 
class setOrderAttributeForTransaction_args:
25445 
  """
25446 
  Attributes:
25447 
   - transactionId
25448 
   - attribute
25449 
  """
25450 
 
25451 
  thrift_spec = None
25452 
  def __init__(self, transactionId=None, attribute=None,):
25453 
    self.transactionId = transactionId
25454 
    self.attribute = attribute
25455 
 
25456 
  def read(self, iprot):
25457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25459 
      return
25460 
    iprot.readStructBegin()
25461 
    while True:
25462 
      (fname, ftype, fid) = iprot.readFieldBegin()
25463 
      if ftype == TType.STOP:
25464 
        break
25465 
      if fid == 1:
25466 
        if ftype == TType.I64:
25467 
          self.transactionId = iprot.readI64();
25468 
        else:
25469 
          iprot.skip(ftype)
25470 
      elif fid == -1:
25471 
        if ftype == TType.STRUCT:
25472 
          self.attribute = Attribute()
25473 
          self.attribute.read(iprot)
25474 
        else:
25475 
          iprot.skip(ftype)
25476 
      else:
25477 
        iprot.skip(ftype)
25478 
      iprot.readFieldEnd()
25479 
    iprot.readStructEnd()
25480 
 
25481 
  def write(self, oprot):
25482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25484 
      return
25485 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25486 
    if self.attribute is not None:
25487 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25488 
      self.attribute.write(oprot)
25489 
      oprot.writeFieldEnd()
25490 
    if self.transactionId is not None:
25491 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25492 
      oprot.writeI64(self.transactionId)
25493 
      oprot.writeFieldEnd()
25494 
    oprot.writeFieldStop()
25495 
    oprot.writeStructEnd()
25496 
 
25497 
  def validate(self):
25498 
    return
25499 
 
25500 
 
25501 
  def __repr__(self):
25502 
    L = ['%s=%r' % (key, value)
25503 
      for key, value in self.__dict__.iteritems()]
25504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25505 
 
25506 
  def __eq__(self, other):
25507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25508 
 
25509 
  def __ne__(self, other):
25510 
    return not (self == other)
25511 
 
25512 
class setOrderAttributeForTransaction_result:
25513 
 
25514 
  thrift_spec = (
25515 
  )
25516 
 
25517 
  def read(self, iprot):
25518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25520 
      return
25521 
    iprot.readStructBegin()
25522 
    while True:
25523 
      (fname, ftype, fid) = iprot.readFieldBegin()
25524 
      if ftype == TType.STOP:
25525 
        break
25526 
      else:
25527 
        iprot.skip(ftype)
25528 
      iprot.readFieldEnd()
25529 
    iprot.readStructEnd()
25530 
 
25531 
  def write(self, oprot):
25532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25534 
      return
25535 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25536 
    oprot.writeFieldStop()
25537 
    oprot.writeStructEnd()
25538 
 
25539 
  def validate(self):
25540 
    return
25541 
 
25542 
 
25543 
  def __repr__(self):
25544 
    L = ['%s=%r' % (key, value)
25545 
      for key, value in self.__dict__.iteritems()]
25546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25547 
 
25548 
  def __eq__(self, other):
25549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25550 
 
25551 
  def __ne__(self, other):
25552 
    return not (self == other)
5553 rajveer 25553 
 
25554 
class getReceivePendingOrders_args:
25555 
  """
25556 
  Attributes:
25557 
   - storeId
25558 
  """
25559 
 
25560 
  thrift_spec = (
25561 
    None, # 0
25562 
    (1, TType.I64, 'storeId', None, None, ), # 1
25563 
  )
25564 
 
25565 
  def __init__(self, storeId=None,):
25566 
    self.storeId = storeId
25567 
 
25568 
  def read(self, iprot):
25569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25571 
      return
25572 
    iprot.readStructBegin()
25573 
    while True:
25574 
      (fname, ftype, fid) = iprot.readFieldBegin()
25575 
      if ftype == TType.STOP:
25576 
        break
25577 
      if fid == 1:
25578 
        if ftype == TType.I64:
25579 
          self.storeId = iprot.readI64();
25580 
        else:
25581 
          iprot.skip(ftype)
25582 
      else:
25583 
        iprot.skip(ftype)
25584 
      iprot.readFieldEnd()
25585 
    iprot.readStructEnd()
25586 
 
25587 
  def write(self, oprot):
25588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25590 
      return
25591 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25592 
    if self.storeId is not None:
25593 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25594 
      oprot.writeI64(self.storeId)
25595 
      oprot.writeFieldEnd()
25596 
    oprot.writeFieldStop()
25597 
    oprot.writeStructEnd()
25598 
 
25599 
  def validate(self):
25600 
    return
25601 
 
25602 
 
25603 
  def __repr__(self):
25604 
    L = ['%s=%r' % (key, value)
25605 
      for key, value in self.__dict__.iteritems()]
25606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25607 
 
25608 
  def __eq__(self, other):
25609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25610 
 
25611 
  def __ne__(self, other):
25612 
    return not (self == other)
25613 
 
25614 
class getReceivePendingOrders_result:
25615 
  """
25616 
  Attributes:
25617 
   - success
25618 
  """
25619 
 
25620 
  thrift_spec = (
25621 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25622 
  )
25623 
 
25624 
  def __init__(self, success=None,):
25625 
    self.success = success
25626 
 
25627 
  def read(self, iprot):
25628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25630 
      return
25631 
    iprot.readStructBegin()
25632 
    while True:
25633 
      (fname, ftype, fid) = iprot.readFieldBegin()
25634 
      if ftype == TType.STOP:
25635 
        break
25636 
      if fid == 0:
25637 
        if ftype == TType.LIST:
25638 
          self.success = []
6188 rajveer 25639 
          (_etype638, _size635) = iprot.readListBegin()
25640 
          for _i639 in xrange(_size635):
25641 
            _elem640 = Order()
25642 
            _elem640.read(iprot)
25643 
            self.success.append(_elem640)
5553 rajveer 25644 
          iprot.readListEnd()
25645 
        else:
25646 
          iprot.skip(ftype)
25647 
      else:
25648 
        iprot.skip(ftype)
25649 
      iprot.readFieldEnd()
25650 
    iprot.readStructEnd()
25651 
 
25652 
  def write(self, oprot):
25653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25655 
      return
25656 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25657 
    if self.success is not None:
25658 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25659 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25660 
      for iter641 in self.success:
25661 
        iter641.write(oprot)
5553 rajveer 25662 
      oprot.writeListEnd()
25663 
      oprot.writeFieldEnd()
25664 
    oprot.writeFieldStop()
25665 
    oprot.writeStructEnd()
25666 
 
25667 
  def validate(self):
25668 
    return
25669 
 
25670 
 
25671 
  def __repr__(self):
25672 
    L = ['%s=%r' % (key, value)
25673 
      for key, value in self.__dict__.iteritems()]
25674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25675 
 
25676 
  def __eq__(self, other):
25677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25678 
 
25679 
  def __ne__(self, other):
25680 
    return not (self == other)
25681 
 
25682 
class getReceivedAtStoreOrders_args:
25683 
  """
25684 
  Attributes:
25685 
   - storeId
25686 
  """
25687 
 
25688 
  thrift_spec = (
25689 
    None, # 0
25690 
    (1, TType.I64, 'storeId', None, None, ), # 1
25691 
  )
25692 
 
25693 
  def __init__(self, storeId=None,):
25694 
    self.storeId = storeId
25695 
 
25696 
  def read(self, iprot):
25697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25699 
      return
25700 
    iprot.readStructBegin()
25701 
    while True:
25702 
      (fname, ftype, fid) = iprot.readFieldBegin()
25703 
      if ftype == TType.STOP:
25704 
        break
25705 
      if fid == 1:
25706 
        if ftype == TType.I64:
25707 
          self.storeId = iprot.readI64();
25708 
        else:
25709 
          iprot.skip(ftype)
25710 
      else:
25711 
        iprot.skip(ftype)
25712 
      iprot.readFieldEnd()
25713 
    iprot.readStructEnd()
25714 
 
25715 
  def write(self, oprot):
25716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25718 
      return
25719 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25720 
    if self.storeId is not None:
25721 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25722 
      oprot.writeI64(self.storeId)
25723 
      oprot.writeFieldEnd()
25724 
    oprot.writeFieldStop()
25725 
    oprot.writeStructEnd()
25726 
 
25727 
  def validate(self):
25728 
    return
25729 
 
25730 
 
25731 
  def __repr__(self):
25732 
    L = ['%s=%r' % (key, value)
25733 
      for key, value in self.__dict__.iteritems()]
25734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25735 
 
25736 
  def __eq__(self, other):
25737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25738 
 
25739 
  def __ne__(self, other):
25740 
    return not (self == other)
25741 
 
25742 
class getReceivedAtStoreOrders_result:
25743 
  """
25744 
  Attributes:
25745 
   - success
25746 
  """
25747 
 
25748 
  thrift_spec = (
25749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25750 
  )
25751 
 
25752 
  def __init__(self, success=None,):
25753 
    self.success = success
25754 
 
25755 
  def read(self, iprot):
25756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25758 
      return
25759 
    iprot.readStructBegin()
25760 
    while True:
25761 
      (fname, ftype, fid) = iprot.readFieldBegin()
25762 
      if ftype == TType.STOP:
25763 
        break
25764 
      if fid == 0:
25765 
        if ftype == TType.LIST:
25766 
          self.success = []
6188 rajveer 25767 
          (_etype645, _size642) = iprot.readListBegin()
25768 
          for _i646 in xrange(_size642):
25769 
            _elem647 = Order()
25770 
            _elem647.read(iprot)
25771 
            self.success.append(_elem647)
5553 rajveer 25772 
          iprot.readListEnd()
25773 
        else:
25774 
          iprot.skip(ftype)
25775 
      else:
25776 
        iprot.skip(ftype)
25777 
      iprot.readFieldEnd()
25778 
    iprot.readStructEnd()
25779 
 
25780 
  def write(self, oprot):
25781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25783 
      return
25784 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25785 
    if self.success is not None:
25786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25788 
      for iter648 in self.success:
25789 
        iter648.write(oprot)
5553 rajveer 25790 
      oprot.writeListEnd()
25791 
      oprot.writeFieldEnd()
25792 
    oprot.writeFieldStop()
25793 
    oprot.writeStructEnd()
25794 
 
25795 
  def validate(self):
25796 
    return
25797 
 
25798 
 
25799 
  def __repr__(self):
25800 
    L = ['%s=%r' % (key, value)
25801 
      for key, value in self.__dict__.iteritems()]
25802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25803 
 
25804 
  def __eq__(self, other):
25805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25806 
 
25807 
  def __ne__(self, other):
25808 
    return not (self == other)
5593 mandeep.dh 25809 
 
5713 rajveer 25810 
class getOrdersCollectionAtStore_args:
25811 
  """
25812 
  Attributes:
25813 
   - storeId
25814 
   - fromDate
25815 
   - toDate
25816 
   - onlyCod
25817 
  """
25818 
 
25819 
  thrift_spec = (
25820 
    None, # 0
25821 
    (1, TType.I64, 'storeId', None, None, ), # 1
25822 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25823 
    (3, TType.I64, 'toDate', None, None, ), # 3
25824 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25825 
  )
25826 
 
25827 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25828 
    self.storeId = storeId
25829 
    self.fromDate = fromDate
25830 
    self.toDate = toDate
25831 
    self.onlyCod = onlyCod
25832 
 
25833 
  def read(self, iprot):
25834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25836 
      return
25837 
    iprot.readStructBegin()
25838 
    while True:
25839 
      (fname, ftype, fid) = iprot.readFieldBegin()
25840 
      if ftype == TType.STOP:
25841 
        break
25842 
      if fid == 1:
25843 
        if ftype == TType.I64:
25844 
          self.storeId = iprot.readI64();
25845 
        else:
25846 
          iprot.skip(ftype)
25847 
      elif fid == 2:
25848 
        if ftype == TType.I64:
25849 
          self.fromDate = iprot.readI64();
25850 
        else:
25851 
          iprot.skip(ftype)
25852 
      elif fid == 3:
25853 
        if ftype == TType.I64:
25854 
          self.toDate = iprot.readI64();
25855 
        else:
25856 
          iprot.skip(ftype)
25857 
      elif fid == 4:
25858 
        if ftype == TType.BOOL:
25859 
          self.onlyCod = iprot.readBool();
25860 
        else:
25861 
          iprot.skip(ftype)
25862 
      else:
25863 
        iprot.skip(ftype)
25864 
      iprot.readFieldEnd()
25865 
    iprot.readStructEnd()
25866 
 
25867 
  def write(self, oprot):
25868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25870 
      return
25871 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25872 
    if self.storeId is not None:
25873 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25874 
      oprot.writeI64(self.storeId)
25875 
      oprot.writeFieldEnd()
25876 
    if self.fromDate is not None:
25877 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25878 
      oprot.writeI64(self.fromDate)
25879 
      oprot.writeFieldEnd()
25880 
    if self.toDate is not None:
25881 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25882 
      oprot.writeI64(self.toDate)
25883 
      oprot.writeFieldEnd()
25884 
    if self.onlyCod is not None:
25885 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25886 
      oprot.writeBool(self.onlyCod)
25887 
      oprot.writeFieldEnd()
25888 
    oprot.writeFieldStop()
25889 
    oprot.writeStructEnd()
25890 
 
25891 
  def validate(self):
25892 
    return
25893 
 
25894 
 
25895 
  def __repr__(self):
25896 
    L = ['%s=%r' % (key, value)
25897 
      for key, value in self.__dict__.iteritems()]
25898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25899 
 
25900 
  def __eq__(self, other):
25901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25902 
 
25903 
  def __ne__(self, other):
25904 
    return not (self == other)
25905 
 
25906 
class getOrdersCollectionAtStore_result:
25907 
  """
25908 
  Attributes:
25909 
   - success
25910 
  """
25911 
 
25912 
  thrift_spec = (
25913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25914 
  )
25915 
 
25916 
  def __init__(self, success=None,):
25917 
    self.success = success
25918 
 
25919 
  def read(self, iprot):
25920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25922 
      return
25923 
    iprot.readStructBegin()
25924 
    while True:
25925 
      (fname, ftype, fid) = iprot.readFieldBegin()
25926 
      if ftype == TType.STOP:
25927 
        break
25928 
      if fid == 0:
25929 
        if ftype == TType.LIST:
25930 
          self.success = []
6188 rajveer 25931 
          (_etype652, _size649) = iprot.readListBegin()
25932 
          for _i653 in xrange(_size649):
25933 
            _elem654 = Order()
25934 
            _elem654.read(iprot)
25935 
            self.success.append(_elem654)
5713 rajveer 25936 
          iprot.readListEnd()
25937 
        else:
25938 
          iprot.skip(ftype)
25939 
      else:
25940 
        iprot.skip(ftype)
25941 
      iprot.readFieldEnd()
25942 
    iprot.readStructEnd()
25943 
 
25944 
  def write(self, oprot):
25945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25947 
      return
25948 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25949 
    if self.success is not None:
25950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25952 
      for iter655 in self.success:
25953 
        iter655.write(oprot)
5713 rajveer 25954 
      oprot.writeListEnd()
25955 
      oprot.writeFieldEnd()
25956 
    oprot.writeFieldStop()
25957 
    oprot.writeStructEnd()
25958 
 
25959 
  def validate(self):
25960 
    return
25961 
 
25962 
 
25963 
  def __repr__(self):
25964 
    L = ['%s=%r' % (key, value)
25965 
      for key, value in self.__dict__.iteritems()]
25966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25967 
 
25968 
  def __eq__(self, other):
25969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25970 
 
25971 
  def __ne__(self, other):
25972 
    return not (self == other)
25973 
 
5833 rajveer 25974 
class getOrderAttributeValue_args:
25975 
  """
25976 
  Attributes:
25977 
   - orderId
25978 
   - attributeName
25979 
  """
25980 
 
25981 
  thrift_spec = None
25982 
  def __init__(self, orderId=None, attributeName=None,):
25983 
    self.orderId = orderId
25984 
    self.attributeName = attributeName
25985 
 
25986 
  def read(self, iprot):
25987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25989 
      return
25990 
    iprot.readStructBegin()
25991 
    while True:
25992 
      (fname, ftype, fid) = iprot.readFieldBegin()
25993 
      if ftype == TType.STOP:
25994 
        break
25995 
      if fid == 1:
25996 
        if ftype == TType.I64:
25997 
          self.orderId = iprot.readI64();
25998 
        else:
25999 
          iprot.skip(ftype)
26000 
      elif fid == -1:
26001 
        if ftype == TType.STRING:
26002 
          self.attributeName = iprot.readString();
26003 
        else:
26004 
          iprot.skip(ftype)
26005 
      else:
26006 
        iprot.skip(ftype)
26007 
      iprot.readFieldEnd()
26008 
    iprot.readStructEnd()
26009 
 
26010 
  def write(self, oprot):
26011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26013 
      return
26014 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26015 
    if self.attributeName is not None:
26016 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26017 
      oprot.writeString(self.attributeName)
26018 
      oprot.writeFieldEnd()
26019 
    if self.orderId is not None:
26020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26021 
      oprot.writeI64(self.orderId)
26022 
      oprot.writeFieldEnd()
26023 
    oprot.writeFieldStop()
26024 
    oprot.writeStructEnd()
26025 
 
26026 
  def validate(self):
26027 
    return
26028 
 
26029 
 
26030 
  def __repr__(self):
26031 
    L = ['%s=%r' % (key, value)
26032 
      for key, value in self.__dict__.iteritems()]
26033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26034 
 
26035 
  def __eq__(self, other):
26036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26037 
 
26038 
  def __ne__(self, other):
26039 
    return not (self == other)
26040 
 
26041 
class getOrderAttributeValue_result:
26042 
  """
26043 
  Attributes:
26044 
   - success
26045 
  """
26046 
 
26047 
  thrift_spec = (
26048 
    (0, TType.STRING, 'success', None, None, ), # 0
26049 
  )
26050 
 
26051 
  def __init__(self, success=None,):
26052 
    self.success = success
26053 
 
26054 
  def read(self, iprot):
26055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26057 
      return
26058 
    iprot.readStructBegin()
26059 
    while True:
26060 
      (fname, ftype, fid) = iprot.readFieldBegin()
26061 
      if ftype == TType.STOP:
26062 
        break
26063 
      if fid == 0:
26064 
        if ftype == TType.STRING:
26065 
          self.success = iprot.readString();
26066 
        else:
26067 
          iprot.skip(ftype)
26068 
      else:
26069 
        iprot.skip(ftype)
26070 
      iprot.readFieldEnd()
26071 
    iprot.readStructEnd()
26072 
 
26073 
  def write(self, oprot):
26074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26076 
      return
26077 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26078 
    if self.success is not None:
26079 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26080 
      oprot.writeString(self.success)
26081 
      oprot.writeFieldEnd()
26082 
    oprot.writeFieldStop()
26083 
    oprot.writeStructEnd()
26084 
 
26085 
  def validate(self):
26086 
    return
26087 
 
26088 
 
26089 
  def __repr__(self):
26090 
    L = ['%s=%r' % (key, value)
26091 
      for key, value in self.__dict__.iteritems()]
26092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26093 
 
26094 
  def __eq__(self, other):
26095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26096 
 
26097 
  def __ne__(self, other):
26098 
    return not (self == other)
26099 
 
6019 rajveer 26100 
class changeJacketNumber_args:
26101 
  """
26102 
  Attributes:
26103 
   - orderId
26104 
   - jacketNumber
26105 
  """
26106 
 
26107 
  thrift_spec = (
26108 
    None, # 0
26109 
    (1, TType.I64, 'orderId', None, None, ), # 1
26110 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26111 
  )
26112 
 
26113 
  def __init__(self, orderId=None, jacketNumber=None,):
26114 
    self.orderId = orderId
26115 
    self.jacketNumber = jacketNumber
26116 
 
26117 
  def read(self, iprot):
26118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26120 
      return
26121 
    iprot.readStructBegin()
26122 
    while True:
26123 
      (fname, ftype, fid) = iprot.readFieldBegin()
26124 
      if ftype == TType.STOP:
26125 
        break
26126 
      if fid == 1:
26127 
        if ftype == TType.I64:
26128 
          self.orderId = iprot.readI64();
26129 
        else:
26130 
          iprot.skip(ftype)
26131 
      elif fid == 2:
26132 
        if ftype == TType.I64:
26133 
          self.jacketNumber = iprot.readI64();
26134 
        else:
26135 
          iprot.skip(ftype)
26136 
      else:
26137 
        iprot.skip(ftype)
26138 
      iprot.readFieldEnd()
26139 
    iprot.readStructEnd()
26140 
 
26141 
  def write(self, oprot):
26142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26144 
      return
26145 
    oprot.writeStructBegin('changeJacketNumber_args')
26146 
    if self.orderId is not None:
26147 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26148 
      oprot.writeI64(self.orderId)
26149 
      oprot.writeFieldEnd()
26150 
    if self.jacketNumber is not None:
26151 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26152 
      oprot.writeI64(self.jacketNumber)
26153 
      oprot.writeFieldEnd()
26154 
    oprot.writeFieldStop()
26155 
    oprot.writeStructEnd()
26156 
 
26157 
  def validate(self):
26158 
    return
26159 
 
26160 
 
26161 
  def __repr__(self):
26162 
    L = ['%s=%r' % (key, value)
26163 
      for key, value in self.__dict__.iteritems()]
26164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26165 
 
26166 
  def __eq__(self, other):
26167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26168 
 
26169 
  def __ne__(self, other):
26170 
    return not (self == other)
26171 
 
26172 
class changeJacketNumber_result:
26173 
  """
26174 
  Attributes:
26175 
   - success
26176 
  """
26177 
 
26178 
  thrift_spec = (
26179 
    (0, TType.BOOL, 'success', None, None, ), # 0
26180 
  )
26181 
 
26182 
  def __init__(self, success=None,):
26183 
    self.success = success
26184 
 
26185 
  def read(self, iprot):
26186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26188 
      return
26189 
    iprot.readStructBegin()
26190 
    while True:
26191 
      (fname, ftype, fid) = iprot.readFieldBegin()
26192 
      if ftype == TType.STOP:
26193 
        break
26194 
      if fid == 0:
26195 
        if ftype == TType.BOOL:
26196 
          self.success = iprot.readBool();
26197 
        else:
26198 
          iprot.skip(ftype)
26199 
      else:
26200 
        iprot.skip(ftype)
26201 
      iprot.readFieldEnd()
26202 
    iprot.readStructEnd()
26203 
 
26204 
  def write(self, oprot):
26205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26207 
      return
26208 
    oprot.writeStructBegin('changeJacketNumber_result')
26209 
    if self.success is not None:
26210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26211 
      oprot.writeBool(self.success)
26212 
      oprot.writeFieldEnd()
26213 
    oprot.writeFieldStop()
26214 
    oprot.writeStructEnd()
26215 
 
26216 
  def validate(self):
26217 
    return
26218 
 
26219 
 
26220 
  def __repr__(self):
26221 
    L = ['%s=%r' % (key, value)
26222 
      for key, value in self.__dict__.iteritems()]
26223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26224 
 
26225 
  def __eq__(self, other):
26226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26227 
 
26228 
  def __ne__(self, other):
26229 
    return not (self == other)
26230 
 
26231 
class markOrderAsRtoInTransit_args:
26232 
  """
26233 
  Attributes:
26234 
   - orderId
26235 
  """
26236 
 
26237 
  thrift_spec = (
26238 
    None, # 0
26239 
    (1, TType.I64, 'orderId', None, None, ), # 1
26240 
  )
26241 
 
26242 
  def __init__(self, orderId=None,):
26243 
    self.orderId = orderId
26244 
 
26245 
  def read(self, iprot):
26246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26248 
      return
26249 
    iprot.readStructBegin()
26250 
    while True:
26251 
      (fname, ftype, fid) = iprot.readFieldBegin()
26252 
      if ftype == TType.STOP:
26253 
        break
26254 
      if fid == 1:
26255 
        if ftype == TType.I64:
26256 
          self.orderId = iprot.readI64();
26257 
        else:
26258 
          iprot.skip(ftype)
26259 
      else:
26260 
        iprot.skip(ftype)
26261 
      iprot.readFieldEnd()
26262 
    iprot.readStructEnd()
26263 
 
26264 
  def write(self, oprot):
26265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26267 
      return
26268 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26269 
    if self.orderId is not None:
26270 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26271 
      oprot.writeI64(self.orderId)
26272 
      oprot.writeFieldEnd()
26273 
    oprot.writeFieldStop()
26274 
    oprot.writeStructEnd()
26275 
 
26276 
  def validate(self):
26277 
    return
26278 
 
26279 
 
26280 
  def __repr__(self):
26281 
    L = ['%s=%r' % (key, value)
26282 
      for key, value in self.__dict__.iteritems()]
26283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26284 
 
26285 
  def __eq__(self, other):
26286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26287 
 
26288 
  def __ne__(self, other):
26289 
    return not (self == other)
26290 
 
26291 
class markOrderAsRtoInTransit_result:
26292 
  """
26293 
  Attributes:
26294 
   - success
26295 
  """
26296 
 
26297 
  thrift_spec = (
26298 
    (0, TType.BOOL, 'success', None, None, ), # 0
26299 
  )
26300 
 
26301 
  def __init__(self, success=None,):
26302 
    self.success = success
26303 
 
26304 
  def read(self, iprot):
26305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26307 
      return
26308 
    iprot.readStructBegin()
26309 
    while True:
26310 
      (fname, ftype, fid) = iprot.readFieldBegin()
26311 
      if ftype == TType.STOP:
26312 
        break
26313 
      if fid == 0:
26314 
        if ftype == TType.BOOL:
26315 
          self.success = iprot.readBool();
26316 
        else:
26317 
          iprot.skip(ftype)
26318 
      else:
26319 
        iprot.skip(ftype)
26320 
      iprot.readFieldEnd()
26321 
    iprot.readStructEnd()
26322 
 
26323 
  def write(self, oprot):
26324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26326 
      return
26327 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26328 
    if self.success is not None:
26329 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26330 
      oprot.writeBool(self.success)
26331 
      oprot.writeFieldEnd()
26332 
    oprot.writeFieldStop()
26333 
    oprot.writeStructEnd()
26334 
 
26335 
  def validate(self):
26336 
    return
26337 
 
26338 
 
26339 
  def __repr__(self):
26340 
    L = ['%s=%r' % (key, value)
26341 
      for key, value in self.__dict__.iteritems()]
26342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26343 
 
26344 
  def __eq__(self, other):
26345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26346 
 
26347 
  def __ne__(self, other):
26348 
    return not (self == other)
26349 
 
5593 mandeep.dh 26350 
class acceptOrderForItem_args:
26351 
  """
26352 
  Attributes:
26353 
   - itemId
26354 
   - quantity
26355 
   - fulfilmentWarehouseId
26356 
   - billingWarehouseId
26357 
  """
26358 
 
26359 
  thrift_spec = (
26360 
    None, # 0
26361 
    (1, TType.I64, 'itemId', None, None, ), # 1
26362 
    (2, TType.I64, 'quantity', None, None, ), # 2
26363 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26364 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26365 
  )
26366 
 
26367 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26368 
    self.itemId = itemId
26369 
    self.quantity = quantity
26370 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26371 
    self.billingWarehouseId = billingWarehouseId
26372 
 
26373 
  def read(self, iprot):
26374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26376 
      return
26377 
    iprot.readStructBegin()
26378 
    while True:
26379 
      (fname, ftype, fid) = iprot.readFieldBegin()
26380 
      if ftype == TType.STOP:
26381 
        break
26382 
      if fid == 1:
26383 
        if ftype == TType.I64:
26384 
          self.itemId = iprot.readI64();
26385 
        else:
26386 
          iprot.skip(ftype)
26387 
      elif fid == 2:
26388 
        if ftype == TType.I64:
26389 
          self.quantity = iprot.readI64();
26390 
        else:
26391 
          iprot.skip(ftype)
26392 
      elif fid == 3:
26393 
        if ftype == TType.I64:
26394 
          self.fulfilmentWarehouseId = iprot.readI64();
26395 
        else:
26396 
          iprot.skip(ftype)
26397 
      elif fid == 4:
26398 
        if ftype == TType.I64:
26399 
          self.billingWarehouseId = iprot.readI64();
26400 
        else:
26401 
          iprot.skip(ftype)
26402 
      else:
26403 
        iprot.skip(ftype)
26404 
      iprot.readFieldEnd()
26405 
    iprot.readStructEnd()
26406 
 
26407 
  def write(self, oprot):
26408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26410 
      return
26411 
    oprot.writeStructBegin('acceptOrderForItem_args')
26412 
    if self.itemId is not None:
26413 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26414 
      oprot.writeI64(self.itemId)
26415 
      oprot.writeFieldEnd()
26416 
    if self.quantity is not None:
26417 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26418 
      oprot.writeI64(self.quantity)
26419 
      oprot.writeFieldEnd()
26420 
    if self.fulfilmentWarehouseId is not None:
26421 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26422 
      oprot.writeI64(self.fulfilmentWarehouseId)
26423 
      oprot.writeFieldEnd()
26424 
    if self.billingWarehouseId is not None:
26425 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26426 
      oprot.writeI64(self.billingWarehouseId)
26427 
      oprot.writeFieldEnd()
26428 
    oprot.writeFieldStop()
26429 
    oprot.writeStructEnd()
26430 
 
26431 
  def validate(self):
26432 
    return
26433 
 
26434 
 
26435 
  def __repr__(self):
26436 
    L = ['%s=%r' % (key, value)
26437 
      for key, value in self.__dict__.iteritems()]
26438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26439 
 
26440 
  def __eq__(self, other):
26441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26442 
 
26443 
  def __ne__(self, other):
26444 
    return not (self == other)
26445 
 
26446 
class acceptOrderForItem_result:
26447 
 
26448 
  thrift_spec = (
26449 
  )
26450 
 
26451 
  def read(self, iprot):
26452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26454 
      return
26455 
    iprot.readStructBegin()
26456 
    while True:
26457 
      (fname, ftype, fid) = iprot.readFieldBegin()
26458 
      if ftype == TType.STOP:
26459 
        break
26460 
      else:
26461 
        iprot.skip(ftype)
26462 
      iprot.readFieldEnd()
26463 
    iprot.readStructEnd()
26464 
 
26465 
  def write(self, oprot):
26466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26468 
      return
26469 
    oprot.writeStructBegin('acceptOrderForItem_result')
26470 
    oprot.writeFieldStop()
26471 
    oprot.writeStructEnd()
26472 
 
26473 
  def validate(self):
26474 
    return
26475 
 
26476 
 
26477 
  def __repr__(self):
26478 
    L = ['%s=%r' % (key, value)
26479 
      for key, value in self.__dict__.iteritems()]
26480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26481 
 
26482 
  def __eq__(self, other):
26483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26484 
 
26485 
  def __ne__(self, other):
26486 
    return not (self == other)
6000 mandeep.dh 26487 
 
26488 
class createRechargeOrder_args:
26489 
  """
26490 
  Attributes:
26491 
   - rechargeOrder
26492 
  """
26493 
 
26494 
  thrift_spec = (
26495 
    None, # 0
26496 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26497 
  )
26498 
 
26499 
  def __init__(self, rechargeOrder=None,):
26500 
    self.rechargeOrder = rechargeOrder
26501 
 
26502 
  def read(self, iprot):
26503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26505 
      return
26506 
    iprot.readStructBegin()
26507 
    while True:
26508 
      (fname, ftype, fid) = iprot.readFieldBegin()
26509 
      if ftype == TType.STOP:
26510 
        break
26511 
      if fid == 1:
26512 
        if ftype == TType.STRUCT:
26513 
          self.rechargeOrder = RechargeOrder()
26514 
          self.rechargeOrder.read(iprot)
26515 
        else:
26516 
          iprot.skip(ftype)
26517 
      else:
26518 
        iprot.skip(ftype)
26519 
      iprot.readFieldEnd()
26520 
    iprot.readStructEnd()
26521 
 
26522 
  def write(self, oprot):
26523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26525 
      return
26526 
    oprot.writeStructBegin('createRechargeOrder_args')
26527 
    if self.rechargeOrder is not None:
26528 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26529 
      self.rechargeOrder.write(oprot)
26530 
      oprot.writeFieldEnd()
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
26548 
 
26549 
class createRechargeOrder_result:
26550 
  """
26551 
  Attributes:
26552 
   - success
26553 
   - ex
26554 
  """
26555 
 
26556 
  thrift_spec = (
26557 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26559 
  )
26560 
 
26561 
  def __init__(self, success=None, ex=None,):
26562 
    self.success = success
26563 
    self.ex = ex
26564 
 
26565 
  def read(self, iprot):
26566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26568 
      return
26569 
    iprot.readStructBegin()
26570 
    while True:
26571 
      (fname, ftype, fid) = iprot.readFieldBegin()
26572 
      if ftype == TType.STOP:
26573 
        break
26574 
      if fid == 0:
26575 
        if ftype == TType.STRUCT:
26576 
          self.success = RechargeOrder()
26577 
          self.success.read(iprot)
26578 
        else:
26579 
          iprot.skip(ftype)
26580 
      elif fid == 1:
26581 
        if ftype == TType.STRUCT:
26582 
          self.ex = TransactionServiceException()
26583 
          self.ex.read(iprot)
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('createRechargeOrder_result')
26596 
    if self.success is not None:
26597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26598 
      self.success.write(oprot)
26599 
      oprot.writeFieldEnd()
26600 
    if self.ex is not None:
26601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26602 
      self.ex.write(oprot)
26603 
      oprot.writeFieldEnd()
26604 
    oprot.writeFieldStop()
26605 
    oprot.writeStructEnd()
26606 
 
26607 
  def validate(self):
26608 
    return
26609 
 
26610 
 
26611 
  def __repr__(self):
26612 
    L = ['%s=%r' % (key, value)
26613 
      for key, value in self.__dict__.iteritems()]
26614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26615 
 
26616 
  def __eq__(self, other):
26617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26618 
 
26619 
  def __ne__(self, other):
26620 
    return not (self == other)
26621 
 
6031 rajveer 26622 
class getRechargeOrder_args:
26623 
  """
26624 
  Attributes:
26625 
   - rechargeRrderId
26626 
  """
26627 
 
26628 
  thrift_spec = (
26629 
    None, # 0
26630 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26631 
  )
26632 
 
26633 
  def __init__(self, rechargeRrderId=None,):
26634 
    self.rechargeRrderId = rechargeRrderId
26635 
 
26636 
  def read(self, iprot):
26637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26639 
      return
26640 
    iprot.readStructBegin()
26641 
    while True:
26642 
      (fname, ftype, fid) = iprot.readFieldBegin()
26643 
      if ftype == TType.STOP:
26644 
        break
26645 
      if fid == 1:
26646 
        if ftype == TType.I64:
26647 
          self.rechargeRrderId = iprot.readI64();
26648 
        else:
26649 
          iprot.skip(ftype)
26650 
      else:
26651 
        iprot.skip(ftype)
26652 
      iprot.readFieldEnd()
26653 
    iprot.readStructEnd()
26654 
 
26655 
  def write(self, oprot):
26656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26658 
      return
26659 
    oprot.writeStructBegin('getRechargeOrder_args')
26660 
    if self.rechargeRrderId is not None:
26661 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26662 
      oprot.writeI64(self.rechargeRrderId)
26663 
      oprot.writeFieldEnd()
26664 
    oprot.writeFieldStop()
26665 
    oprot.writeStructEnd()
26666 
 
26667 
  def validate(self):
26668 
    return
26669 
 
26670 
 
26671 
  def __repr__(self):
26672 
    L = ['%s=%r' % (key, value)
26673 
      for key, value in self.__dict__.iteritems()]
26674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26675 
 
26676 
  def __eq__(self, other):
26677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26678 
 
26679 
  def __ne__(self, other):
26680 
    return not (self == other)
26681 
 
26682 
class getRechargeOrder_result:
26683 
  """
26684 
  Attributes:
26685 
   - success
26686 
   - ex
26687 
  """
26688 
 
26689 
  thrift_spec = (
26690 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26692 
  )
26693 
 
26694 
  def __init__(self, success=None, ex=None,):
26695 
    self.success = success
26696 
    self.ex = ex
26697 
 
26698 
  def read(self, iprot):
26699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26701 
      return
26702 
    iprot.readStructBegin()
26703 
    while True:
26704 
      (fname, ftype, fid) = iprot.readFieldBegin()
26705 
      if ftype == TType.STOP:
26706 
        break
26707 
      if fid == 0:
26708 
        if ftype == TType.STRUCT:
26709 
          self.success = RechargeOrder()
26710 
          self.success.read(iprot)
26711 
        else:
26712 
          iprot.skip(ftype)
26713 
      elif fid == 1:
26714 
        if ftype == TType.STRUCT:
26715 
          self.ex = TransactionServiceException()
26716 
          self.ex.read(iprot)
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('getRechargeOrder_result')
26729 
    if self.success is not None:
26730 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26731 
      self.success.write(oprot)
26732 
      oprot.writeFieldEnd()
26733 
    if self.ex is not None:
26734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26735 
      self.ex.write(oprot)
26736 
      oprot.writeFieldEnd()
26737 
    oprot.writeFieldStop()
26738 
    oprot.writeStructEnd()
26739 
 
26740 
  def validate(self):
26741 
    return
26742 
 
26743 
 
26744 
  def __repr__(self):
26745 
    L = ['%s=%r' % (key, value)
26746 
      for key, value in self.__dict__.iteritems()]
26747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26748 
 
26749 
  def __eq__(self, other):
26750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26751 
 
26752 
  def __ne__(self, other):
26753 
    return not (self == other)
26754 
 
26755 
class getRechargeOrders_args:
26756 
  """
26757 
  Attributes:
26758 
   - userId
26759 
  """
26760 
 
26761 
  thrift_spec = (
26762 
    None, # 0
26763 
    (1, TType.I64, 'userId', None, None, ), # 1
26764 
  )
26765 
 
26766 
  def __init__(self, userId=None,):
26767 
    self.userId = userId
26768 
 
26769 
  def read(self, iprot):
26770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26772 
      return
26773 
    iprot.readStructBegin()
26774 
    while True:
26775 
      (fname, ftype, fid) = iprot.readFieldBegin()
26776 
      if ftype == TType.STOP:
26777 
        break
26778 
      if fid == 1:
26779 
        if ftype == TType.I64:
26780 
          self.userId = iprot.readI64();
26781 
        else:
26782 
          iprot.skip(ftype)
26783 
      else:
26784 
        iprot.skip(ftype)
26785 
      iprot.readFieldEnd()
26786 
    iprot.readStructEnd()
26787 
 
26788 
  def write(self, oprot):
26789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26791 
      return
26792 
    oprot.writeStructBegin('getRechargeOrders_args')
26793 
    if self.userId is not None:
26794 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26795 
      oprot.writeI64(self.userId)
26796 
      oprot.writeFieldEnd()
26797 
    oprot.writeFieldStop()
26798 
    oprot.writeStructEnd()
26799 
 
26800 
  def validate(self):
26801 
    return
26802 
 
26803 
 
26804 
  def __repr__(self):
26805 
    L = ['%s=%r' % (key, value)
26806 
      for key, value in self.__dict__.iteritems()]
26807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26808 
 
26809 
  def __eq__(self, other):
26810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26811 
 
26812 
  def __ne__(self, other):
26813 
    return not (self == other)
26814 
 
26815 
class getRechargeOrders_result:
26816 
  """
26817 
  Attributes:
26818 
   - success
26819 
  """
26820 
 
26821 
  thrift_spec = (
26822 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26823 
  )
26824 
 
26825 
  def __init__(self, success=None,):
26826 
    self.success = success
26827 
 
26828 
  def read(self, iprot):
26829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26831 
      return
26832 
    iprot.readStructBegin()
26833 
    while True:
26834 
      (fname, ftype, fid) = iprot.readFieldBegin()
26835 
      if ftype == TType.STOP:
26836 
        break
26837 
      if fid == 0:
26838 
        if ftype == TType.LIST:
26839 
          self.success = []
6188 rajveer 26840 
          (_etype659, _size656) = iprot.readListBegin()
26841 
          for _i660 in xrange(_size656):
26842 
            _elem661 = RechargeOrder()
26843 
            _elem661.read(iprot)
26844 
            self.success.append(_elem661)
6031 rajveer 26845 
          iprot.readListEnd()
26846 
        else:
26847 
          iprot.skip(ftype)
26848 
      else:
26849 
        iprot.skip(ftype)
26850 
      iprot.readFieldEnd()
26851 
    iprot.readStructEnd()
26852 
 
26853 
  def write(self, oprot):
26854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26856 
      return
26857 
    oprot.writeStructBegin('getRechargeOrders_result')
26858 
    if self.success is not None:
26859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26861 
      for iter662 in self.success:
26862 
        iter662.write(oprot)
6031 rajveer 26863 
      oprot.writeListEnd()
26864 
      oprot.writeFieldEnd()
26865 
    oprot.writeFieldStop()
26866 
    oprot.writeStructEnd()
26867 
 
26868 
  def validate(self):
26869 
    return
26870 
 
26871 
 
26872 
  def __repr__(self):
26873 
    L = ['%s=%r' % (key, value)
26874 
      for key, value in self.__dict__.iteritems()]
26875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26876 
 
26877 
  def __eq__(self, other):
26878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26879 
 
26880 
  def __ne__(self, other):
26881 
    return not (self == other)
26882 
 
6000 mandeep.dh 26883 
class updateRechargeOrderStatus_args:
26884 
  """
26885 
  Attributes:
26886 
   - rechargeOrderId
26887 
   - rechargeOrderStatus
26888 
  """
26889 
 
26890 
  thrift_spec = (
26891 
    None, # 0
26892 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26893 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26894 
  )
26895 
 
26896 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26897 
    self.rechargeOrderId = rechargeOrderId
26898 
    self.rechargeOrderStatus = rechargeOrderStatus
26899 
 
26900 
  def read(self, iprot):
26901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26903 
      return
26904 
    iprot.readStructBegin()
26905 
    while True:
26906 
      (fname, ftype, fid) = iprot.readFieldBegin()
26907 
      if ftype == TType.STOP:
26908 
        break
26909 
      if fid == 1:
26910 
        if ftype == TType.I64:
26911 
          self.rechargeOrderId = iprot.readI64();
26912 
        else:
26913 
          iprot.skip(ftype)
26914 
      elif fid == 2:
26915 
        if ftype == TType.I32:
26916 
          self.rechargeOrderStatus = iprot.readI32();
26917 
        else:
26918 
          iprot.skip(ftype)
26919 
      else:
26920 
        iprot.skip(ftype)
26921 
      iprot.readFieldEnd()
26922 
    iprot.readStructEnd()
26923 
 
26924 
  def write(self, oprot):
26925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26927 
      return
26928 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26929 
    if self.rechargeOrderId is not None:
26930 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26931 
      oprot.writeI64(self.rechargeOrderId)
26932 
      oprot.writeFieldEnd()
26933 
    if self.rechargeOrderStatus is not None:
26934 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26935 
      oprot.writeI32(self.rechargeOrderStatus)
26936 
      oprot.writeFieldEnd()
26937 
    oprot.writeFieldStop()
26938 
    oprot.writeStructEnd()
26939 
 
26940 
  def validate(self):
26941 
    return
26942 
 
26943 
 
26944 
  def __repr__(self):
26945 
    L = ['%s=%r' % (key, value)
26946 
      for key, value in self.__dict__.iteritems()]
26947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26948 
 
26949 
  def __eq__(self, other):
26950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26951 
 
26952 
  def __ne__(self, other):
26953 
    return not (self == other)
26954 
 
26955 
class updateRechargeOrderStatus_result:
26956 
  """
26957 
  Attributes:
6031 rajveer 26958 
   - success
6000 mandeep.dh 26959 
   - ex
26960 
  """
26961 
 
26962 
  thrift_spec = (
6031 rajveer 26963 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26965 
  )
26966 
 
6031 rajveer 26967 
  def __init__(self, success=None, ex=None,):
26968 
    self.success = success
6000 mandeep.dh 26969 
    self.ex = ex
26970 
 
26971 
  def read(self, iprot):
26972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26974 
      return
26975 
    iprot.readStructBegin()
26976 
    while True:
26977 
      (fname, ftype, fid) = iprot.readFieldBegin()
26978 
      if ftype == TType.STOP:
26979 
        break
6031 rajveer 26980 
      if fid == 0:
26981 
        if ftype == TType.BOOL:
26982 
          self.success = iprot.readBool();
26983 
        else:
26984 
          iprot.skip(ftype)
26985 
      elif fid == 1:
6000 mandeep.dh 26986 
        if ftype == TType.STRUCT:
26987 
          self.ex = TransactionServiceException()
26988 
          self.ex.read(iprot)
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('updateRechargeOrderStatus_result')
6031 rajveer 27001 
    if self.success is not None:
27002 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27003 
      oprot.writeBool(self.success)
27004 
      oprot.writeFieldEnd()
6000 mandeep.dh 27005 
    if self.ex is not None:
27006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27007 
      self.ex.write(oprot)
27008 
      oprot.writeFieldEnd()
27009 
    oprot.writeFieldStop()
27010 
    oprot.writeStructEnd()
27011 
 
27012 
  def validate(self):
27013 
    return
27014 
 
27015 
 
27016 
  def __repr__(self):
27017 
    L = ['%s=%r' % (key, value)
27018 
      for key, value in self.__dict__.iteritems()]
27019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27020 
 
27021 
  def __eq__(self, other):
27022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27023 
 
27024 
  def __ne__(self, other):
27025 
    return not (self == other)
27026 
 
27027 
class activateRechargeTxn_args:
27028 
  """
27029 
  Attributes:
6031 rajveer 27030 
   - rechargeOrderId
6000 mandeep.dh 27031 
  """
27032 
 
27033 
  thrift_spec = (
27034 
    None, # 0
6031 rajveer 27035 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27036 
  )
27037 
 
6031 rajveer 27038 
  def __init__(self, rechargeOrderId=None,):
27039 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27040 
 
27041 
  def read(self, iprot):
27042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27044 
      return
27045 
    iprot.readStructBegin()
27046 
    while True:
27047 
      (fname, ftype, fid) = iprot.readFieldBegin()
27048 
      if ftype == TType.STOP:
27049 
        break
27050 
      if fid == 1:
6031 rajveer 27051 
        if ftype == TType.I64:
27052 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27053 
        else:
27054 
          iprot.skip(ftype)
27055 
      else:
27056 
        iprot.skip(ftype)
27057 
      iprot.readFieldEnd()
27058 
    iprot.readStructEnd()
27059 
 
27060 
  def write(self, oprot):
27061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27063 
      return
27064 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27065 
    if self.rechargeOrderId is not None:
27066 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27067 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27068 
      oprot.writeFieldEnd()
27069 
    oprot.writeFieldStop()
27070 
    oprot.writeStructEnd()
27071 
 
27072 
  def validate(self):
27073 
    return
27074 
 
27075 
 
27076 
  def __repr__(self):
27077 
    L = ['%s=%r' % (key, value)
27078 
      for key, value in self.__dict__.iteritems()]
27079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27080 
 
27081 
  def __eq__(self, other):
27082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27083 
 
27084 
  def __ne__(self, other):
27085 
    return not (self == other)
27086 
 
27087 
class activateRechargeTxn_result:
27088 
  """
27089 
  Attributes:
27090 
   - success
27091 
   - ex
27092 
  """
27093 
 
27094 
  thrift_spec = (
6031 rajveer 27095 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27097 
  )
27098 
 
27099 
  def __init__(self, success=None, ex=None,):
27100 
    self.success = success
27101 
    self.ex = ex
27102 
 
27103 
  def read(self, iprot):
27104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27106 
      return
27107 
    iprot.readStructBegin()
27108 
    while True:
27109 
      (fname, ftype, fid) = iprot.readFieldBegin()
27110 
      if ftype == TType.STOP:
27111 
        break
27112 
      if fid == 0:
6031 rajveer 27113 
        if ftype == TType.BOOL:
27114 
          self.success = iprot.readBool();
6000 mandeep.dh 27115 
        else:
27116 
          iprot.skip(ftype)
27117 
      elif fid == 1:
27118 
        if ftype == TType.STRUCT:
27119 
          self.ex = TransactionServiceException()
27120 
          self.ex.read(iprot)
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
27132 
    oprot.writeStructBegin('activateRechargeTxn_result')
27133 
    if self.success is not None:
6031 rajveer 27134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27135 
      oprot.writeBool(self.success)
6000 mandeep.dh 27136 
      oprot.writeFieldEnd()
27137 
    if self.ex is not None:
27138 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27139 
      self.ex.write(oprot)
27140 
      oprot.writeFieldEnd()
27141 
    oprot.writeFieldStop()
27142 
    oprot.writeStructEnd()
27143 
 
27144 
  def validate(self):
27145 
    return
27146 
 
27147 
 
27148 
  def __repr__(self):
27149 
    L = ['%s=%r' % (key, value)
27150 
      for key, value in self.__dict__.iteritems()]
27151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27152 
 
27153 
  def __eq__(self, other):
27154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27155 
 
27156 
  def __ne__(self, other):
27157 
    return not (self == other)
27158 
 
6031 rajveer 27159 
class getUserWallet_args:
6000 mandeep.dh 27160 
  """
27161 
  Attributes:
6031 rajveer 27162 
   - userId
6000 mandeep.dh 27163 
  """
27164 
 
27165 
  thrift_spec = (
27166 
    None, # 0
6031 rajveer 27167 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27168 
  )
27169 
 
6031 rajveer 27170 
  def __init__(self, userId=None,):
27171 
    self.userId = userId
6000 mandeep.dh 27172 
 
27173 
  def read(self, iprot):
27174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27176 
      return
27177 
    iprot.readStructBegin()
27178 
    while True:
27179 
      (fname, ftype, fid) = iprot.readFieldBegin()
27180 
      if ftype == TType.STOP:
27181 
        break
27182 
      if fid == 1:
27183 
        if ftype == TType.I64:
6031 rajveer 27184 
          self.userId = iprot.readI64();
6000 mandeep.dh 27185 
        else:
27186 
          iprot.skip(ftype)
27187 
      else:
27188 
        iprot.skip(ftype)
27189 
      iprot.readFieldEnd()
27190 
    iprot.readStructEnd()
27191 
 
27192 
  def write(self, oprot):
27193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27195 
      return
6031 rajveer 27196 
    oprot.writeStructBegin('getUserWallet_args')
27197 
    if self.userId is not None:
27198 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27199 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27200 
      oprot.writeFieldEnd()
27201 
    oprot.writeFieldStop()
27202 
    oprot.writeStructEnd()
27203 
 
27204 
  def validate(self):
27205 
    return
27206 
 
27207 
 
27208 
  def __repr__(self):
27209 
    L = ['%s=%r' % (key, value)
27210 
      for key, value in self.__dict__.iteritems()]
27211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27212 
 
27213 
  def __eq__(self, other):
27214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27215 
 
27216 
  def __ne__(self, other):
27217 
    return not (self == other)
27218 
 
6031 rajveer 27219 
class getUserWallet_result:
6000 mandeep.dh 27220 
  """
27221 
  Attributes:
27222 
   - success
27223 
  """
27224 
 
27225 
  thrift_spec = (
6031 rajveer 27226 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27227 
  )
27228 
 
27229 
  def __init__(self, success=None,):
27230 
    self.success = success
27231 
 
27232 
  def read(self, iprot):
27233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27235 
      return
27236 
    iprot.readStructBegin()
27237 
    while True:
27238 
      (fname, ftype, fid) = iprot.readFieldBegin()
27239 
      if ftype == TType.STOP:
27240 
        break
27241 
      if fid == 0:
6031 rajveer 27242 
        if ftype == TType.STRUCT:
27243 
          self.success = UserWallet()
27244 
          self.success.read(iprot)
6000 mandeep.dh 27245 
        else:
27246 
          iprot.skip(ftype)
27247 
      else:
27248 
        iprot.skip(ftype)
27249 
      iprot.readFieldEnd()
27250 
    iprot.readStructEnd()
27251 
 
27252 
  def write(self, oprot):
27253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27255 
      return
6031 rajveer 27256 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27257 
    if self.success is not None:
6031 rajveer 27258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27259 
      self.success.write(oprot)
6000 mandeep.dh 27260 
      oprot.writeFieldEnd()
27261 
    oprot.writeFieldStop()
27262 
    oprot.writeStructEnd()
27263 
 
27264 
  def validate(self):
27265 
    return
27266 
 
27267 
 
27268 
  def __repr__(self):
27269 
    L = ['%s=%r' % (key, value)
27270 
      for key, value in self.__dict__.iteritems()]
27271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27272 
 
27273 
  def __eq__(self, other):
27274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27275 
 
27276 
  def __ne__(self, other):
27277 
    return not (self == other)
27278 
 
6031 rajveer 27279 
class getUserWalletHistory_args:
6000 mandeep.dh 27280 
  """
27281 
  Attributes:
6031 rajveer 27282 
   - userId
6000 mandeep.dh 27283 
  """
27284 
 
27285 
  thrift_spec = (
27286 
    None, # 0
6031 rajveer 27287 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27288 
  )
27289 
 
6031 rajveer 27290 
  def __init__(self, userId=None,):
27291 
    self.userId = userId
6000 mandeep.dh 27292 
 
27293 
  def read(self, iprot):
27294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27296 
      return
27297 
    iprot.readStructBegin()
27298 
    while True:
27299 
      (fname, ftype, fid) = iprot.readFieldBegin()
27300 
      if ftype == TType.STOP:
27301 
        break
27302 
      if fid == 1:
27303 
        if ftype == TType.I64:
6031 rajveer 27304 
          self.userId = iprot.readI64();
6000 mandeep.dh 27305 
        else:
27306 
          iprot.skip(ftype)
27307 
      else:
27308 
        iprot.skip(ftype)
27309 
      iprot.readFieldEnd()
27310 
    iprot.readStructEnd()
27311 
 
27312 
  def write(self, oprot):
27313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27315 
      return
6031 rajveer 27316 
    oprot.writeStructBegin('getUserWalletHistory_args')
27317 
    if self.userId is not None:
27318 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27319 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27320 
      oprot.writeFieldEnd()
27321 
    oprot.writeFieldStop()
27322 
    oprot.writeStructEnd()
27323 
 
27324 
  def validate(self):
27325 
    return
27326 
 
27327 
 
27328 
  def __repr__(self):
27329 
    L = ['%s=%r' % (key, value)
27330 
      for key, value in self.__dict__.iteritems()]
27331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27332 
 
27333 
  def __eq__(self, other):
27334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27335 
 
27336 
  def __ne__(self, other):
27337 
    return not (self == other)
27338 
 
6031 rajveer 27339 
class getUserWalletHistory_result:
6000 mandeep.dh 27340 
  """
27341 
  Attributes:
27342 
   - success
27343 
  """
27344 
 
27345 
  thrift_spec = (
6031 rajveer 27346 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27347 
  )
27348 
 
27349 
  def __init__(self, success=None,):
27350 
    self.success = success
27351 
 
27352 
  def read(self, iprot):
27353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27355 
      return
27356 
    iprot.readStructBegin()
27357 
    while True:
27358 
      (fname, ftype, fid) = iprot.readFieldBegin()
27359 
      if ftype == TType.STOP:
27360 
        break
27361 
      if fid == 0:
27362 
        if ftype == TType.LIST:
27363 
          self.success = []
6188 rajveer 27364 
          (_etype666, _size663) = iprot.readListBegin()
27365 
          for _i667 in xrange(_size663):
27366 
            _elem668 = UserWalletHistory()
27367 
            _elem668.read(iprot)
27368 
            self.success.append(_elem668)
6000 mandeep.dh 27369 
          iprot.readListEnd()
27370 
        else:
27371 
          iprot.skip(ftype)
27372 
      else:
27373 
        iprot.skip(ftype)
27374 
      iprot.readFieldEnd()
27375 
    iprot.readStructEnd()
27376 
 
27377 
  def write(self, oprot):
27378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27380 
      return
6031 rajveer 27381 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27382 
    if self.success is not None:
27383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27385 
      for iter669 in self.success:
27386 
        iter669.write(oprot)
6000 mandeep.dh 27387 
      oprot.writeListEnd()
27388 
      oprot.writeFieldEnd()
27389 
    oprot.writeFieldStop()
27390 
    oprot.writeStructEnd()
27391 
 
27392 
  def validate(self):
27393 
    return
27394 
 
27395 
 
27396 
  def __repr__(self):
27397 
    L = ['%s=%r' % (key, value)
27398 
      for key, value in self.__dict__.iteritems()]
27399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27400 
 
27401 
  def __eq__(self, other):
27402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27403 
 
27404 
  def __ne__(self, other):
27405 
    return not (self == other)
6048 rajveer 27406 
 
6050 anupam.sin 27407 
class getRechargeOrdersForTransaction_args:
27408 
  """
27409 
  Attributes:
27410 
   - txnId
27411 
  """
27412 
 
27413 
  thrift_spec = (
27414 
    None, # 0
27415 
    (1, TType.I64, 'txnId', None, None, ), # 1
27416 
  )
27417 
 
27418 
  def __init__(self, txnId=None,):
27419 
    self.txnId = txnId
27420 
 
27421 
  def read(self, iprot):
27422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27424 
      return
27425 
    iprot.readStructBegin()
27426 
    while True:
27427 
      (fname, ftype, fid) = iprot.readFieldBegin()
27428 
      if ftype == TType.STOP:
27429 
        break
27430 
      if fid == 1:
27431 
        if ftype == TType.I64:
27432 
          self.txnId = iprot.readI64();
27433 
        else:
27434 
          iprot.skip(ftype)
27435 
      else:
27436 
        iprot.skip(ftype)
27437 
      iprot.readFieldEnd()
27438 
    iprot.readStructEnd()
27439 
 
27440 
  def write(self, oprot):
27441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27443 
      return
27444 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27445 
    if self.txnId is not None:
27446 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27447 
      oprot.writeI64(self.txnId)
27448 
      oprot.writeFieldEnd()
27449 
    oprot.writeFieldStop()
27450 
    oprot.writeStructEnd()
27451 
 
27452 
  def validate(self):
27453 
    return
27454 
 
27455 
 
27456 
  def __repr__(self):
27457 
    L = ['%s=%r' % (key, value)
27458 
      for key, value in self.__dict__.iteritems()]
27459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27460 
 
27461 
  def __eq__(self, other):
27462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27463 
 
27464 
  def __ne__(self, other):
27465 
    return not (self == other)
27466 
 
27467 
class getRechargeOrdersForTransaction_result:
27468 
  """
27469 
  Attributes:
27470 
   - success
27471 
   - ex
27472 
  """
27473 
 
27474 
  thrift_spec = (
27475 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27477 
  )
27478 
 
27479 
  def __init__(self, success=None, ex=None,):
27480 
    self.success = success
27481 
    self.ex = ex
27482 
 
27483 
  def read(self, iprot):
27484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27486 
      return
27487 
    iprot.readStructBegin()
27488 
    while True:
27489 
      (fname, ftype, fid) = iprot.readFieldBegin()
27490 
      if ftype == TType.STOP:
27491 
        break
27492 
      if fid == 0:
27493 
        if ftype == TType.STRUCT:
27494 
          self.success = RechargeOrder()
27495 
          self.success.read(iprot)
27496 
        else:
27497 
          iprot.skip(ftype)
27498 
      elif fid == 1:
27499 
        if ftype == TType.STRUCT:
27500 
          self.ex = TransactionServiceException()
27501 
          self.ex.read(iprot)
27502 
        else:
27503 
          iprot.skip(ftype)
27504 
      else:
27505 
        iprot.skip(ftype)
27506 
      iprot.readFieldEnd()
27507 
    iprot.readStructEnd()
27508 
 
27509 
  def write(self, oprot):
27510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27512 
      return
27513 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27514 
    if self.success is not None:
27515 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27516 
      self.success.write(oprot)
27517 
      oprot.writeFieldEnd()
27518 
    if self.ex is not None:
27519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27520 
      self.ex.write(oprot)
27521 
      oprot.writeFieldEnd()
27522 
    oprot.writeFieldStop()
27523 
    oprot.writeStructEnd()
27524 
 
27525 
  def validate(self):
27526 
    return
27527 
 
27528 
 
27529 
  def __repr__(self):
27530 
    L = ['%s=%r' % (key, value)
27531 
      for key, value in self.__dict__.iteritems()]
27532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27533 
 
27534 
  def __eq__(self, other):
27535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27536 
 
27537 
  def __ne__(self, other):
27538 
    return not (self == other)
27539 
 
6048 rajveer 27540 
class getServiceProviders_args:
27541 
  """
27542 
  Attributes:
27543 
   - rechargeType
6206 rajveer 27544 
   - onlyActive
6048 rajveer 27545 
  """
27546 
 
27547 
  thrift_spec = (
27548 
    None, # 0
27549 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27550 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27551 
  )
27552 
 
6206 rajveer 27553 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27554 
    self.rechargeType = rechargeType
6206 rajveer 27555 
    self.onlyActive = onlyActive
6048 rajveer 27556 
 
27557 
  def read(self, iprot):
27558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27560 
      return
27561 
    iprot.readStructBegin()
27562 
    while True:
27563 
      (fname, ftype, fid) = iprot.readFieldBegin()
27564 
      if ftype == TType.STOP:
27565 
        break
27566 
      if fid == 1:
27567 
        if ftype == TType.I32:
27568 
          self.rechargeType = iprot.readI32();
27569 
        else:
27570 
          iprot.skip(ftype)
6206 rajveer 27571 
      elif fid == 2:
27572 
        if ftype == TType.BOOL:
27573 
          self.onlyActive = iprot.readBool();
27574 
        else:
27575 
          iprot.skip(ftype)
6048 rajveer 27576 
      else:
27577 
        iprot.skip(ftype)
27578 
      iprot.readFieldEnd()
27579 
    iprot.readStructEnd()
27580 
 
27581 
  def write(self, oprot):
27582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27584 
      return
27585 
    oprot.writeStructBegin('getServiceProviders_args')
27586 
    if self.rechargeType is not None:
27587 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27588 
      oprot.writeI32(self.rechargeType)
27589 
      oprot.writeFieldEnd()
6206 rajveer 27590 
    if self.onlyActive is not None:
27591 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27592 
      oprot.writeBool(self.onlyActive)
27593 
      oprot.writeFieldEnd()
6048 rajveer 27594 
    oprot.writeFieldStop()
27595 
    oprot.writeStructEnd()
27596 
 
27597 
  def validate(self):
27598 
    return
27599 
 
27600 
 
27601 
  def __repr__(self):
27602 
    L = ['%s=%r' % (key, value)
27603 
      for key, value in self.__dict__.iteritems()]
27604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27605 
 
27606 
  def __eq__(self, other):
27607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27608 
 
27609 
  def __ne__(self, other):
27610 
    return not (self == other)
27611 
 
27612 
class getServiceProviders_result:
27613 
  """
27614 
  Attributes:
27615 
   - success
27616 
  """
27617 
 
27618 
  thrift_spec = (
27619 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27620 
  )
27621 
 
27622 
  def __init__(self, success=None,):
27623 
    self.success = success
27624 
 
27625 
  def read(self, iprot):
27626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27628 
      return
27629 
    iprot.readStructBegin()
27630 
    while True:
27631 
      (fname, ftype, fid) = iprot.readFieldBegin()
27632 
      if ftype == TType.STOP:
27633 
        break
27634 
      if fid == 0:
27635 
        if ftype == TType.MAP:
27636 
          self.success = {}
6188 rajveer 27637 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27638 
          for _i674 in xrange(_size670):
27639 
            _key675 = iprot.readI64();
27640 
            _val676 = iprot.readString();
27641 
            self.success[_key675] = _val676
6048 rajveer 27642 
          iprot.readMapEnd()
27643 
        else:
27644 
          iprot.skip(ftype)
27645 
      else:
27646 
        iprot.skip(ftype)
27647 
      iprot.readFieldEnd()
27648 
    iprot.readStructEnd()
27649 
 
27650 
  def write(self, oprot):
27651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27653 
      return
27654 
    oprot.writeStructBegin('getServiceProviders_result')
27655 
    if self.success is not None:
27656 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27657 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27658 
      for kiter677,viter678 in self.success.items():
27659 
        oprot.writeI64(kiter677)
27660 
        oprot.writeString(viter678)
6048 rajveer 27661 
      oprot.writeMapEnd()
27662 
      oprot.writeFieldEnd()
27663 
    oprot.writeFieldStop()
27664 
    oprot.writeStructEnd()
27665 
 
27666 
  def validate(self):
27667 
    return
27668 
 
27669 
 
27670 
  def __repr__(self):
27671 
    L = ['%s=%r' % (key, value)
27672 
      for key, value in self.__dict__.iteritems()]
27673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27674 
 
27675 
  def __eq__(self, other):
27676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27677 
 
27678 
  def __ne__(self, other):
27679 
    return not (self == other)
27680 
 
27681 
class getServiceProviderForDevice_args:
27682 
  """
27683 
  Attributes:
6049 rajveer 27684 
   - rechargeType
6048 rajveer 27685 
   - deviceNumber
27686 
  """
27687 
 
27688 
  thrift_spec = (
27689 
    None, # 0
6049 rajveer 27690 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27691 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27692 
  )
27693 
 
6049 rajveer 27694 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27695 
    self.rechargeType = rechargeType
6048 rajveer 27696 
    self.deviceNumber = deviceNumber
27697 
 
27698 
  def read(self, iprot):
27699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27701 
      return
27702 
    iprot.readStructBegin()
27703 
    while True:
27704 
      (fname, ftype, fid) = iprot.readFieldBegin()
27705 
      if ftype == TType.STOP:
27706 
        break
27707 
      if fid == 1:
6049 rajveer 27708 
        if ftype == TType.I32:
27709 
          self.rechargeType = iprot.readI32();
27710 
        else:
27711 
          iprot.skip(ftype)
27712 
      elif fid == 2:
6048 rajveer 27713 
        if ftype == TType.STRING:
27714 
          self.deviceNumber = iprot.readString();
27715 
        else:
27716 
          iprot.skip(ftype)
27717 
      else:
27718 
        iprot.skip(ftype)
27719 
      iprot.readFieldEnd()
27720 
    iprot.readStructEnd()
27721 
 
27722 
  def write(self, oprot):
27723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27725 
      return
27726 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27727 
    if self.rechargeType is not None:
27728 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27729 
      oprot.writeI32(self.rechargeType)
27730 
      oprot.writeFieldEnd()
6048 rajveer 27731 
    if self.deviceNumber is not None:
6049 rajveer 27732 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27733 
      oprot.writeString(self.deviceNumber)
27734 
      oprot.writeFieldEnd()
27735 
    oprot.writeFieldStop()
27736 
    oprot.writeStructEnd()
27737 
 
27738 
  def validate(self):
27739 
    return
27740 
 
27741 
 
27742 
  def __repr__(self):
27743 
    L = ['%s=%r' % (key, value)
27744 
      for key, value in self.__dict__.iteritems()]
27745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27746 
 
27747 
  def __eq__(self, other):
27748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27749 
 
27750 
  def __ne__(self, other):
27751 
    return not (self == other)
27752 
 
27753 
class getServiceProviderForDevice_result:
27754 
  """
27755 
  Attributes:
27756 
   - success
27757 
  """
27758 
 
27759 
  thrift_spec = (
6289 anupam.sin 27760 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27761 
  )
27762 
 
27763 
  def __init__(self, success=None,):
27764 
    self.success = success
27765 
 
27766 
  def read(self, iprot):
27767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27769 
      return
27770 
    iprot.readStructBegin()
27771 
    while True:
27772 
      (fname, ftype, fid) = iprot.readFieldBegin()
27773 
      if ftype == TType.STOP:
27774 
        break
27775 
      if fid == 0:
6289 anupam.sin 27776 
        if ftype == TType.STRUCT:
27777 
          self.success = DeviceNumberInfo()
27778 
          self.success.read(iprot)
6048 rajveer 27779 
        else:
27780 
          iprot.skip(ftype)
27781 
      else:
27782 
        iprot.skip(ftype)
27783 
      iprot.readFieldEnd()
27784 
    iprot.readStructEnd()
27785 
 
27786 
  def write(self, oprot):
27787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27789 
      return
27790 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27791 
    if self.success is not None:
6289 anupam.sin 27792 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27793 
      self.success.write(oprot)
6048 rajveer 27794 
      oprot.writeFieldEnd()
27795 
    oprot.writeFieldStop()
27796 
    oprot.writeStructEnd()
27797 
 
27798 
  def validate(self):
27799 
    return
27800 
 
27801 
 
27802 
  def __repr__(self):
27803 
    L = ['%s=%r' % (key, value)
27804 
      for key, value in self.__dict__.iteritems()]
27805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27806 
 
27807 
  def __eq__(self, other):
27808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27809 
 
27810 
  def __ne__(self, other):
27811 
    return not (self == other)
6094 rajveer 27812 
 
6269 rajveer 27813 
class validateRecharge_args:
27814 
  """
27815 
  Attributes:
27816 
   - rechargeType
27817 
   - deviceNumber
27818 
  """
27819 
 
27820 
  thrift_spec = (
27821 
    None, # 0
27822 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27823 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
27824 
  )
27825 
 
27826 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27827 
    self.rechargeType = rechargeType
27828 
    self.deviceNumber = deviceNumber
27829 
 
27830 
  def read(self, iprot):
27831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27833 
      return
27834 
    iprot.readStructBegin()
27835 
    while True:
27836 
      (fname, ftype, fid) = iprot.readFieldBegin()
27837 
      if ftype == TType.STOP:
27838 
        break
27839 
      if fid == 1:
27840 
        if ftype == TType.I32:
27841 
          self.rechargeType = iprot.readI32();
27842 
        else:
27843 
          iprot.skip(ftype)
27844 
      elif fid == 2:
27845 
        if ftype == TType.STRING:
27846 
          self.deviceNumber = iprot.readString();
27847 
        else:
27848 
          iprot.skip(ftype)
27849 
      else:
27850 
        iprot.skip(ftype)
27851 
      iprot.readFieldEnd()
27852 
    iprot.readStructEnd()
27853 
 
27854 
  def write(self, oprot):
27855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27857 
      return
27858 
    oprot.writeStructBegin('validateRecharge_args')
27859 
    if self.rechargeType is not None:
27860 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27861 
      oprot.writeI32(self.rechargeType)
27862 
      oprot.writeFieldEnd()
27863 
    if self.deviceNumber is not None:
27864 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
27865 
      oprot.writeString(self.deviceNumber)
27866 
      oprot.writeFieldEnd()
27867 
    oprot.writeFieldStop()
27868 
    oprot.writeStructEnd()
27869 
 
27870 
  def validate(self):
27871 
    return
27872 
 
27873 
 
27874 
  def __repr__(self):
27875 
    L = ['%s=%r' % (key, value)
27876 
      for key, value in self.__dict__.iteritems()]
27877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27878 
 
27879 
  def __eq__(self, other):
27880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27881 
 
27882 
  def __ne__(self, other):
27883 
    return not (self == other)
27884 
 
27885 
class validateRecharge_result:
27886 
  """
27887 
  Attributes:
27888 
   - success
27889 
  """
27890 
 
27891 
  thrift_spec = (
27892 
    (0, TType.STRING, 'success', None, None, ), # 0
27893 
  )
27894 
 
27895 
  def __init__(self, success=None,):
27896 
    self.success = success
27897 
 
27898 
  def read(self, iprot):
27899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27901 
      return
27902 
    iprot.readStructBegin()
27903 
    while True:
27904 
      (fname, ftype, fid) = iprot.readFieldBegin()
27905 
      if ftype == TType.STOP:
27906 
        break
27907 
      if fid == 0:
27908 
        if ftype == TType.STRING:
27909 
          self.success = iprot.readString();
27910 
        else:
27911 
          iprot.skip(ftype)
27912 
      else:
27913 
        iprot.skip(ftype)
27914 
      iprot.readFieldEnd()
27915 
    iprot.readStructEnd()
27916 
 
27917 
  def write(self, oprot):
27918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27920 
      return
27921 
    oprot.writeStructBegin('validateRecharge_result')
27922 
    if self.success is not None:
27923 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27924 
      oprot.writeString(self.success)
27925 
      oprot.writeFieldEnd()
27926 
    oprot.writeFieldStop()
27927 
    oprot.writeStructEnd()
27928 
 
27929 
  def validate(self):
27930 
    return
27931 
 
27932 
 
27933 
  def __repr__(self):
27934 
    L = ['%s=%r' % (key, value)
27935 
      for key, value in self.__dict__.iteritems()]
27936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27937 
 
27938 
  def __eq__(self, other):
27939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27940 
 
27941 
  def __ne__(self, other):
27942 
    return not (self == other)
27943 
 
6094 rajveer 27944 
class getRechargeOrdersForDevice_args:
27945 
  """
27946 
  Attributes:
27947 
   - deviceNumber
27948 
  """
27949 
 
27950 
  thrift_spec = (
27951 
    None, # 0
27952 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27953 
  )
27954 
 
27955 
  def __init__(self, deviceNumber=None,):
27956 
    self.deviceNumber = deviceNumber
27957 
 
27958 
  def read(self, iprot):
27959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27961 
      return
27962 
    iprot.readStructBegin()
27963 
    while True:
27964 
      (fname, ftype, fid) = iprot.readFieldBegin()
27965 
      if ftype == TType.STOP:
27966 
        break
27967 
      if fid == 1:
27968 
        if ftype == TType.STRING:
27969 
          self.deviceNumber = iprot.readString();
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_args')
27982 
    if self.deviceNumber is not None:
27983 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27984 
      oprot.writeString(self.deviceNumber)
27985 
      oprot.writeFieldEnd()
27986 
    oprot.writeFieldStop()
27987 
    oprot.writeStructEnd()
27988 
 
27989 
  def validate(self):
27990 
    return
27991 
 
27992 
 
27993 
  def __repr__(self):
27994 
    L = ['%s=%r' % (key, value)
27995 
      for key, value in self.__dict__.iteritems()]
27996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27997 
 
27998 
  def __eq__(self, other):
27999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28000 
 
28001 
  def __ne__(self, other):
28002 
    return not (self == other)
28003 
 
28004 
class getRechargeOrdersForDevice_result:
28005 
  """
28006 
  Attributes:
28007 
   - success
28008 
  """
28009 
 
28010 
  thrift_spec = (
28011 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28012 
  )
28013 
 
28014 
  def __init__(self, success=None,):
28015 
    self.success = success
28016 
 
28017 
  def read(self, iprot):
28018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28020 
      return
28021 
    iprot.readStructBegin()
28022 
    while True:
28023 
      (fname, ftype, fid) = iprot.readFieldBegin()
28024 
      if ftype == TType.STOP:
28025 
        break
28026 
      if fid == 0:
28027 
        if ftype == TType.LIST:
28028 
          self.success = []
6188 rajveer 28029 
          (_etype682, _size679) = iprot.readListBegin()
28030 
          for _i683 in xrange(_size679):
28031 
            _elem684 = RechargeOrder()
28032 
            _elem684.read(iprot)
28033 
            self.success.append(_elem684)
6094 rajveer 28034 
          iprot.readListEnd()
28035 
        else:
28036 
          iprot.skip(ftype)
28037 
      else:
28038 
        iprot.skip(ftype)
28039 
      iprot.readFieldEnd()
28040 
    iprot.readStructEnd()
28041 
 
28042 
  def write(self, oprot):
28043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28045 
      return
28046 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28047 
    if self.success is not None:
28048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28050 
      for iter685 in self.success:
28051 
        iter685.write(oprot)
6094 rajveer 28052 
      oprot.writeListEnd()
28053 
      oprot.writeFieldEnd()
28054 
    oprot.writeFieldStop()
28055 
    oprot.writeStructEnd()
28056 
 
28057 
  def validate(self):
28058 
    return
28059 
 
28060 
 
28061 
  def __repr__(self):
28062 
    L = ['%s=%r' % (key, value)
28063 
      for key, value in self.__dict__.iteritems()]
28064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28065 
 
28066 
  def __eq__(self, other):
28067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28068 
 
28069 
  def __ne__(self, other):
28070 
    return not (self == other)
28071 
 
28072 
class addAmountToWallet_args:
28073 
  """
28074 
  Attributes:
28075 
   - userId
28076 
   - orderId
28077 
   - amount
28078 
  """
28079 
 
28080 
  thrift_spec = (
28081 
    None, # 0
28082 
    (1, TType.I64, 'userId', None, None, ), # 1
28083 
    (2, TType.I64, 'orderId', None, None, ), # 2
28084 
    (3, TType.I64, 'amount', None, None, ), # 3
28085 
  )
28086 
 
28087 
  def __init__(self, userId=None, orderId=None, amount=None,):
28088 
    self.userId = userId
28089 
    self.orderId = orderId
28090 
    self.amount = amount
28091 
 
28092 
  def read(self, iprot):
28093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28095 
      return
28096 
    iprot.readStructBegin()
28097 
    while True:
28098 
      (fname, ftype, fid) = iprot.readFieldBegin()
28099 
      if ftype == TType.STOP:
28100 
        break
28101 
      if fid == 1:
28102 
        if ftype == TType.I64:
28103 
          self.userId = iprot.readI64();
28104 
        else:
28105 
          iprot.skip(ftype)
28106 
      elif fid == 2:
28107 
        if ftype == TType.I64:
28108 
          self.orderId = iprot.readI64();
28109 
        else:
28110 
          iprot.skip(ftype)
28111 
      elif fid == 3:
28112 
        if ftype == TType.I64:
28113 
          self.amount = iprot.readI64();
28114 
        else:
28115 
          iprot.skip(ftype)
28116 
      else:
28117 
        iprot.skip(ftype)
28118 
      iprot.readFieldEnd()
28119 
    iprot.readStructEnd()
28120 
 
28121 
  def write(self, oprot):
28122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28124 
      return
28125 
    oprot.writeStructBegin('addAmountToWallet_args')
28126 
    if self.userId is not None:
28127 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28128 
      oprot.writeI64(self.userId)
28129 
      oprot.writeFieldEnd()
28130 
    if self.orderId is not None:
28131 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28132 
      oprot.writeI64(self.orderId)
28133 
      oprot.writeFieldEnd()
28134 
    if self.amount is not None:
28135 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28136 
      oprot.writeI64(self.amount)
28137 
      oprot.writeFieldEnd()
28138 
    oprot.writeFieldStop()
28139 
    oprot.writeStructEnd()
28140 
 
28141 
  def validate(self):
28142 
    return
28143 
 
28144 
 
28145 
  def __repr__(self):
28146 
    L = ['%s=%r' % (key, value)
28147 
      for key, value in self.__dict__.iteritems()]
28148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28149 
 
28150 
  def __eq__(self, other):
28151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28152 
 
28153 
  def __ne__(self, other):
28154 
    return not (self == other)
28155 
 
28156 
class addAmountToWallet_result:
28157 
 
28158 
  thrift_spec = (
28159 
  )
28160 
 
28161 
  def read(self, iprot):
28162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28164 
      return
28165 
    iprot.readStructBegin()
28166 
    while True:
28167 
      (fname, ftype, fid) = iprot.readFieldBegin()
28168 
      if ftype == TType.STOP:
28169 
        break
28170 
      else:
28171 
        iprot.skip(ftype)
28172 
      iprot.readFieldEnd()
28173 
    iprot.readStructEnd()
28174 
 
28175 
  def write(self, oprot):
28176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28178 
      return
28179 
    oprot.writeStructBegin('addAmountToWallet_result')
28180 
    oprot.writeFieldStop()
28181 
    oprot.writeStructEnd()
28182 
 
28183 
  def validate(self):
28184 
    return
28185 
 
28186 
 
28187 
  def __repr__(self):
28188 
    L = ['%s=%r' % (key, value)
28189 
      for key, value in self.__dict__.iteritems()]
28190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28191 
 
28192 
  def __eq__(self, other):
28193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28194 
 
28195 
  def __ne__(self, other):
28196 
    return not (self == other)
6154 rajveer 28197 
 
6188 rajveer 28198 
class getRechargeStatistics_args:
28199 
 
28200 
  thrift_spec = (
28201 
  )
28202 
 
28203 
  def read(self, iprot):
28204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28206 
      return
28207 
    iprot.readStructBegin()
28208 
    while True:
28209 
      (fname, ftype, fid) = iprot.readFieldBegin()
28210 
      if ftype == TType.STOP:
28211 
        break
28212 
      else:
28213 
        iprot.skip(ftype)
28214 
      iprot.readFieldEnd()
28215 
    iprot.readStructEnd()
28216 
 
28217 
  def write(self, oprot):
28218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28220 
      return
28221 
    oprot.writeStructBegin('getRechargeStatistics_args')
28222 
    oprot.writeFieldStop()
28223 
    oprot.writeStructEnd()
28224 
 
28225 
  def validate(self):
28226 
    return
28227 
 
28228 
 
28229 
  def __repr__(self):
28230 
    L = ['%s=%r' % (key, value)
28231 
      for key, value in self.__dict__.iteritems()]
28232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28233 
 
28234 
  def __eq__(self, other):
28235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28236 
 
28237 
  def __ne__(self, other):
28238 
    return not (self == other)
28239 
 
28240 
class getRechargeStatistics_result:
28241 
  """
28242 
  Attributes:
28243 
   - success
28244 
  """
28245 
 
28246 
  thrift_spec = (
28247 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28248 
  )
28249 
 
28250 
  def __init__(self, success=None,):
28251 
    self.success = success
28252 
 
28253 
  def read(self, iprot):
28254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28256 
      return
28257 
    iprot.readStructBegin()
28258 
    while True:
28259 
      (fname, ftype, fid) = iprot.readFieldBegin()
28260 
      if ftype == TType.STOP:
28261 
        break
28262 
      if fid == 0:
28263 
        if ftype == TType.STRUCT:
28264 
          self.success = RechargeStatistics()
28265 
          self.success.read(iprot)
28266 
        else:
28267 
          iprot.skip(ftype)
28268 
      else:
28269 
        iprot.skip(ftype)
28270 
      iprot.readFieldEnd()
28271 
    iprot.readStructEnd()
28272 
 
28273 
  def write(self, oprot):
28274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28276 
      return
28277 
    oprot.writeStructBegin('getRechargeStatistics_result')
28278 
    if self.success is not None:
28279 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28280 
      self.success.write(oprot)
28281 
      oprot.writeFieldEnd()
28282 
    oprot.writeFieldStop()
28283 
    oprot.writeStructEnd()
28284 
 
28285 
  def validate(self):
28286 
    return
28287 
 
28288 
 
28289 
  def __repr__(self):
28290 
    L = ['%s=%r' % (key, value)
28291 
      for key, value in self.__dict__.iteritems()]
28292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28293 
 
28294 
  def __eq__(self, other):
28295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28296 
 
28297 
  def __ne__(self, other):
28298 
    return not (self == other)
28299 
 
6154 rajveer 28300 
class getRechargeOrdersForStatus_args:
28301 
  """
28302 
  Attributes:
28303 
   - status
28304 
  """
28305 
 
28306 
  thrift_spec = (
28307 
    None, # 0
28308 
    (1, TType.I64, 'status', None, None, ), # 1
28309 
  )
28310 
 
28311 
  def __init__(self, status=None,):
28312 
    self.status = status
28313 
 
28314 
  def read(self, iprot):
28315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28317 
      return
28318 
    iprot.readStructBegin()
28319 
    while True:
28320 
      (fname, ftype, fid) = iprot.readFieldBegin()
28321 
      if ftype == TType.STOP:
28322 
        break
28323 
      if fid == 1:
28324 
        if ftype == TType.I64:
28325 
          self.status = iprot.readI64();
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_args')
28338 
    if self.status is not None:
28339 
      oprot.writeFieldBegin('status', TType.I64, 1)
28340 
      oprot.writeI64(self.status)
28341 
      oprot.writeFieldEnd()
28342 
    oprot.writeFieldStop()
28343 
    oprot.writeStructEnd()
28344 
 
28345 
  def validate(self):
28346 
    return
28347 
 
28348 
 
28349 
  def __repr__(self):
28350 
    L = ['%s=%r' % (key, value)
28351 
      for key, value in self.__dict__.iteritems()]
28352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28353 
 
28354 
  def __eq__(self, other):
28355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28356 
 
28357 
  def __ne__(self, other):
28358 
    return not (self == other)
28359 
 
28360 
class getRechargeOrdersForStatus_result:
28361 
  """
28362 
  Attributes:
28363 
   - success
28364 
  """
28365 
 
28366 
  thrift_spec = (
28367 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28368 
  )
28369 
 
28370 
  def __init__(self, success=None,):
28371 
    self.success = success
28372 
 
28373 
  def read(self, iprot):
28374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28376 
      return
28377 
    iprot.readStructBegin()
28378 
    while True:
28379 
      (fname, ftype, fid) = iprot.readFieldBegin()
28380 
      if ftype == TType.STOP:
28381 
        break
28382 
      if fid == 0:
28383 
        if ftype == TType.LIST:
28384 
          self.success = []
6188 rajveer 28385 
          (_etype689, _size686) = iprot.readListBegin()
28386 
          for _i690 in xrange(_size686):
28387 
            _elem691 = RechargeOrder()
28388 
            _elem691.read(iprot)
28389 
            self.success.append(_elem691)
6154 rajveer 28390 
          iprot.readListEnd()
28391 
        else:
28392 
          iprot.skip(ftype)
28393 
      else:
28394 
        iprot.skip(ftype)
28395 
      iprot.readFieldEnd()
28396 
    iprot.readStructEnd()
28397 
 
28398 
  def write(self, oprot):
28399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28401 
      return
28402 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28403 
    if self.success is not None:
28404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28406 
      for iter692 in self.success:
28407 
        iter692.write(oprot)
6154 rajveer 28408 
      oprot.writeListEnd()
28409 
      oprot.writeFieldEnd()
28410 
    oprot.writeFieldStop()
28411 
    oprot.writeStructEnd()
28412 
 
28413 
  def validate(self):
28414 
    return
28415 
 
28416 
 
28417 
  def __repr__(self):
28418 
    L = ['%s=%r' % (key, value)
28419 
      for key, value in self.__dict__.iteritems()]
28420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28421 
 
28422 
  def __eq__(self, other):
28423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28424 
 
28425 
  def __ne__(self, other):
28426 
    return not (self == other)
6159 rajveer 28427 
 
28428 
class getPlansForOperator_args:
28429 
  """
28430 
  Attributes:
28431 
   - operatorId
28432 
  """
28433 
 
28434 
  thrift_spec = (
28435 
    None, # 0
28436 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28437 
  )
28438 
 
28439 
  def __init__(self, operatorId=None,):
28440 
    self.operatorId = operatorId
28441 
 
28442 
  def read(self, iprot):
28443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28445 
      return
28446 
    iprot.readStructBegin()
28447 
    while True:
28448 
      (fname, ftype, fid) = iprot.readFieldBegin()
28449 
      if ftype == TType.STOP:
28450 
        break
28451 
      if fid == 1:
28452 
        if ftype == TType.I64:
28453 
          self.operatorId = iprot.readI64();
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_args')
28466 
    if self.operatorId is not None:
28467 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28468 
      oprot.writeI64(self.operatorId)
28469 
      oprot.writeFieldEnd()
28470 
    oprot.writeFieldStop()
28471 
    oprot.writeStructEnd()
28472 
 
28473 
  def validate(self):
28474 
    return
28475 
 
28476 
 
28477 
  def __repr__(self):
28478 
    L = ['%s=%r' % (key, value)
28479 
      for key, value in self.__dict__.iteritems()]
28480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28481 
 
28482 
  def __eq__(self, other):
28483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28484 
 
28485 
  def __ne__(self, other):
28486 
    return not (self == other)
28487 
 
28488 
class getPlansForOperator_result:
28489 
  """
28490 
  Attributes:
28491 
   - success
28492 
  """
28493 
 
28494 
  thrift_spec = (
28495 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28496 
  )
28497 
 
28498 
  def __init__(self, success=None,):
28499 
    self.success = success
28500 
 
28501 
  def read(self, iprot):
28502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28504 
      return
28505 
    iprot.readStructBegin()
28506 
    while True:
28507 
      (fname, ftype, fid) = iprot.readFieldBegin()
28508 
      if ftype == TType.STOP:
28509 
        break
28510 
      if fid == 0:
28511 
        if ftype == TType.LIST:
28512 
          self.success = []
6188 rajveer 28513 
          (_etype696, _size693) = iprot.readListBegin()
28514 
          for _i697 in xrange(_size693):
28515 
            _elem698 = RechargePlan()
28516 
            _elem698.read(iprot)
28517 
            self.success.append(_elem698)
6159 rajveer 28518 
          iprot.readListEnd()
28519 
        else:
28520 
          iprot.skip(ftype)
28521 
      else:
28522 
        iprot.skip(ftype)
28523 
      iprot.readFieldEnd()
28524 
    iprot.readStructEnd()
28525 
 
28526 
  def write(self, oprot):
28527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28529 
      return
28530 
    oprot.writeStructBegin('getPlansForOperator_result')
28531 
    if self.success is not None:
28532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28534 
      for iter699 in self.success:
28535 
        iter699.write(oprot)
6159 rajveer 28536 
      oprot.writeListEnd()
28537 
      oprot.writeFieldEnd()
28538 
    oprot.writeFieldStop()
28539 
    oprot.writeStructEnd()
28540 
 
28541 
  def validate(self):
28542 
    return
28543 
 
28544 
 
28545 
  def __repr__(self):
28546 
    L = ['%s=%r' % (key, value)
28547 
      for key, value in self.__dict__.iteritems()]
28548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28549 
 
28550 
  def __eq__(self, other):
28551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28552 
 
28553 
  def __ne__(self, other):
28554 
    return not (self == other)
6289 anupam.sin 28555 
 
28556 
class getRechargeDenominations_args:
28557 
  """
28558 
  Attributes:
28559 
   - operatorId
28560 
   - circleName
28561 
   - denominationType
28562 
  """
28563 
 
28564 
  thrift_spec = (
28565 
    None, # 0
28566 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28567 
    (2, TType.STRING, 'circleName', None, None, ), # 2
28568 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28569 
  )
28570 
 
28571 
  def __init__(self, operatorId=None, circleName=None, denominationType=None,):
28572 
    self.operatorId = operatorId
28573 
    self.circleName = circleName
28574 
    self.denominationType = denominationType
28575 
 
28576 
  def read(self, iprot):
28577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28579 
      return
28580 
    iprot.readStructBegin()
28581 
    while True:
28582 
      (fname, ftype, fid) = iprot.readFieldBegin()
28583 
      if ftype == TType.STOP:
28584 
        break
28585 
      if fid == 1:
28586 
        if ftype == TType.I64:
28587 
          self.operatorId = iprot.readI64();
28588 
        else:
28589 
          iprot.skip(ftype)
28590 
      elif fid == 2:
28591 
        if ftype == TType.STRING:
28592 
          self.circleName = iprot.readString();
28593 
        else:
28594 
          iprot.skip(ftype)
28595 
      elif fid == 3:
28596 
        if ftype == TType.I32:
28597 
          self.denominationType = iprot.readI32();
28598 
        else:
28599 
          iprot.skip(ftype)
28600 
      else:
28601 
        iprot.skip(ftype)
28602 
      iprot.readFieldEnd()
28603 
    iprot.readStructEnd()
28604 
 
28605 
  def write(self, oprot):
28606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28608 
      return
28609 
    oprot.writeStructBegin('getRechargeDenominations_args')
28610 
    if self.operatorId is not None:
28611 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28612 
      oprot.writeI64(self.operatorId)
28613 
      oprot.writeFieldEnd()
28614 
    if self.circleName is not None:
28615 
      oprot.writeFieldBegin('circleName', TType.STRING, 2)
28616 
      oprot.writeString(self.circleName)
28617 
      oprot.writeFieldEnd()
28618 
    if self.denominationType is not None:
28619 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28620 
      oprot.writeI32(self.denominationType)
28621 
      oprot.writeFieldEnd()
28622 
    oprot.writeFieldStop()
28623 
    oprot.writeStructEnd()
28624 
 
28625 
  def validate(self):
28626 
    return
28627 
 
28628 
 
28629 
  def __repr__(self):
28630 
    L = ['%s=%r' % (key, value)
28631 
      for key, value in self.__dict__.iteritems()]
28632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28633 
 
28634 
  def __eq__(self, other):
28635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28636 
 
28637 
  def __ne__(self, other):
28638 
    return not (self == other)
28639 
 
28640 
class getRechargeDenominations_result:
28641 
  """
28642 
  Attributes:
28643 
   - success
28644 
   - ex
28645 
  """
28646 
 
28647 
  thrift_spec = (
28648 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28650 
  )
28651 
 
28652 
  def __init__(self, success=None, ex=None,):
28653 
    self.success = success
28654 
    self.ex = ex
28655 
 
28656 
  def read(self, iprot):
28657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28659 
      return
28660 
    iprot.readStructBegin()
28661 
    while True:
28662 
      (fname, ftype, fid) = iprot.readFieldBegin()
28663 
      if ftype == TType.STOP:
28664 
        break
28665 
      if fid == 0:
28666 
        if ftype == TType.LIST:
28667 
          self.success = []
28668 
          (_etype703, _size700) = iprot.readListBegin()
28669 
          for _i704 in xrange(_size700):
28670 
            _elem705 = RechargeDenomination()
28671 
            _elem705.read(iprot)
28672 
            self.success.append(_elem705)
28673 
          iprot.readListEnd()
28674 
        else:
28675 
          iprot.skip(ftype)
28676 
      elif fid == 1:
28677 
        if ftype == TType.STRUCT:
28678 
          self.ex = TransactionServiceException()
28679 
          self.ex.read(iprot)
28680 
        else:
28681 
          iprot.skip(ftype)
28682 
      else:
28683 
        iprot.skip(ftype)
28684 
      iprot.readFieldEnd()
28685 
    iprot.readStructEnd()
28686 
 
28687 
  def write(self, oprot):
28688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28690 
      return
28691 
    oprot.writeStructBegin('getRechargeDenominations_result')
28692 
    if self.success is not None:
28693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28695 
      for iter706 in self.success:
28696 
        iter706.write(oprot)
28697 
      oprot.writeListEnd()
28698 
      oprot.writeFieldEnd()
28699 
    if self.ex is not None:
28700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28701 
      self.ex.write(oprot)
28702 
      oprot.writeFieldEnd()
28703 
    oprot.writeFieldStop()
28704 
    oprot.writeStructEnd()
28705 
 
28706 
  def validate(self):
28707 
    return
28708 
 
28709 
 
28710 
  def __repr__(self):
28711 
    L = ['%s=%r' % (key, value)
28712 
      for key, value in self.__dict__.iteritems()]
28713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28714 
 
28715 
  def __eq__(self, other):
28716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28717 
 
28718 
  def __ne__(self, other):
28719 
    return not (self == other)