Subversion Repositories SmartDukaan

Rev

Rev 6154 | Rev 6188 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
525 
    Returns the final flag status.
526 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6048 rajveer 1349 
  def getServiceProviders(self, rechargeType):
1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
1353 
    """
1354 
    pass
6000 mandeep.dh 1355 
 
6049 rajveer 1356 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1357 
    """
1358 
    Parameters:
6049 rajveer 1359 
     - rechargeType
6048 rajveer 1360 
     - deviceNumber
1361 
    """
1362 
    pass
1363 
 
6094 rajveer 1364 
  def getRechargeOrdersForDevice(self, deviceNumber):
1365 
    """
1366 
    Parameters:
1367 
     - deviceNumber
1368 
    """
1369 
    pass
6048 rajveer 1370 
 
6094 rajveer 1371 
  def addAmountToWallet(self, userId, orderId, amount):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
     - orderId
1376 
     - amount
1377 
    """
1378 
    pass
1379 
 
6154 rajveer 1380 
  def getRechargeOrdersForStatus(self, status):
1381 
    """
1382 
    Parameters:
1383 
     - status
1384 
    """
1385 
    pass
6094 rajveer 1386 
 
6159 rajveer 1387 
  def getPlansForOperator(self, operatorId):
1388 
    """
1389 
    Parameters:
1390 
     - operatorId
1391 
    """
1392 
    pass
6154 rajveer 1393 
 
6159 rajveer 1394 
 
3376 rajveer 1395 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1396 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1397 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1398 
 
1399 
  def createTransaction(self, transaction):
1400 
    """
1401 
    Parameters:
1402 
     - transaction
1403 
    """
1404 
    self.send_createTransaction(transaction)
132 ashish 1405 
    return self.recv_createTransaction()
94 ashish 1406 
 
1407 
  def send_createTransaction(self, transaction):
1408 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1409 
    args = createTransaction_args()
1410 
    args.transaction = transaction
1411 
    args.write(self._oprot)
1412 
    self._oprot.writeMessageEnd()
1413 
    self._oprot.trans.flush()
1414 
 
1415 
  def recv_createTransaction(self, ):
1416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1417 
    if mtype == TMessageType.EXCEPTION:
1418 
      x = TApplicationException()
1419 
      x.read(self._iprot)
1420 
      self._iprot.readMessageEnd()
1421 
      raise x
1422 
    result = createTransaction_result()
1423 
    result.read(self._iprot)
1424 
    self._iprot.readMessageEnd()
3431 rajveer 1425 
    if result.success is not None:
132 ashish 1426 
      return result.success
3431 rajveer 1427 
    if result.ex is not None:
94 ashish 1428 
      raise result.ex
132 ashish 1429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1430 
 
1431 
  def getTransaction(self, id):
1432 
    """
1433 
    Parameters:
1434 
     - id
1435 
    """
1436 
    self.send_getTransaction(id)
1437 
    return self.recv_getTransaction()
1438 
 
1439 
  def send_getTransaction(self, id):
1440 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1441 
    args = getTransaction_args()
1442 
    args.id = id
1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getTransaction(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getTransaction_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
94 ashish 1458 
      return result.success
3431 rajveer 1459 
    if result.ex is not None:
94 ashish 1460 
      raise result.ex
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1462 
 
1463 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1464 
    """
1465 
    Parameters:
1466 
     - customerId
1467 
     - from_date
1468 
     - to_date
1469 
     - status
1470 
    """
1471 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1472 
    return self.recv_getTransactionsForCustomer()
1473 
 
1474 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1475 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1476 
    args = getTransactionsForCustomer_args()
1477 
    args.customerId = customerId
1478 
    args.from_date = from_date
1479 
    args.to_date = to_date
1480 
    args.status = status
1481 
    args.write(self._oprot)
1482 
    self._oprot.writeMessageEnd()
1483 
    self._oprot.trans.flush()
1484 
 
1485 
  def recv_getTransactionsForCustomer(self, ):
1486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1487 
    if mtype == TMessageType.EXCEPTION:
1488 
      x = TApplicationException()
1489 
      x.read(self._iprot)
1490 
      self._iprot.readMessageEnd()
1491 
      raise x
1492 
    result = getTransactionsForCustomer_result()
1493 
    result.read(self._iprot)
1494 
    self._iprot.readMessageEnd()
3431 rajveer 1495 
    if result.success is not None:
94 ashish 1496 
      return result.success
3431 rajveer 1497 
    if result.ex is not None:
94 ashish 1498 
      raise result.ex
1499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1500 
 
132 ashish 1501 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1502 
    """
1503 
    Parameters:
1504 
     - shoppingCartId
1505 
    """
1506 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1507 
    return self.recv_getTransactionsForShoppingCartId()
1508 
 
1509 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1510 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1511 
    args = getTransactionsForShoppingCartId_args()
1512 
    args.shoppingCartId = shoppingCartId
1513 
    args.write(self._oprot)
1514 
    self._oprot.writeMessageEnd()
1515 
    self._oprot.trans.flush()
1516 
 
1517 
  def recv_getTransactionsForShoppingCartId(self, ):
1518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1519 
    if mtype == TMessageType.EXCEPTION:
1520 
      x = TApplicationException()
1521 
      x.read(self._iprot)
1522 
      self._iprot.readMessageEnd()
1523 
      raise x
1524 
    result = getTransactionsForShoppingCartId_result()
1525 
    result.read(self._iprot)
1526 
    self._iprot.readMessageEnd()
3431 rajveer 1527 
    if result.success is not None:
132 ashish 1528 
      return result.success
3431 rajveer 1529 
    if result.ex is not None:
132 ashish 1530 
      raise result.ex
1531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1532 
 
94 ashish 1533 
  def getTransactionStatus(self, transactionId):
1534 
    """
1535 
    Parameters:
1536 
     - transactionId
1537 
    """
1538 
    self.send_getTransactionStatus(transactionId)
1539 
    return self.recv_getTransactionStatus()
1540 
 
1541 
  def send_getTransactionStatus(self, transactionId):
1542 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1543 
    args = getTransactionStatus_args()
1544 
    args.transactionId = transactionId
1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_getTransactionStatus(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = getTransactionStatus_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
3431 rajveer 1559 
    if result.success is not None:
94 ashish 1560 
      return result.success
3431 rajveer 1561 
    if result.ex is not None:
94 ashish 1562 
      raise result.ex
1563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1564 
 
5527 anupam.sin 1565 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1566 
    """
1567 
    Parameters:
1568 
     - transactionId
1569 
     - status
1570 
     - description
5527 anupam.sin 1571 
     - pickUp
1572 
     - orderType
94 ashish 1573 
    """
5527 anupam.sin 1574 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1575 
    return self.recv_changeTransactionStatus()
1576 
 
5527 anupam.sin 1577 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1578 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1579 
    args = changeTransactionStatus_args()
1580 
    args.transactionId = transactionId
1581 
    args.status = status
1582 
    args.description = description
5527 anupam.sin 1583 
    args.pickUp = pickUp
1584 
    args.orderType = orderType
94 ashish 1585 
    args.write(self._oprot)
1586 
    self._oprot.writeMessageEnd()
1587 
    self._oprot.trans.flush()
1588 
 
1589 
  def recv_changeTransactionStatus(self, ):
1590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1591 
    if mtype == TMessageType.EXCEPTION:
1592 
      x = TApplicationException()
1593 
      x.read(self._iprot)
1594 
      self._iprot.readMessageEnd()
1595 
      raise x
1596 
    result = changeTransactionStatus_result()
1597 
    result.read(self._iprot)
1598 
    self._iprot.readMessageEnd()
3431 rajveer 1599 
    if result.success is not None:
94 ashish 1600 
      return result.success
3431 rajveer 1601 
    if result.ex is not None:
94 ashish 1602 
      raise result.ex
1603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1604 
 
1398 varun.gupt 1605 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1606 
    """
1607 
    Parameters:
1608 
     - transactionId
1609 
    """
1398 varun.gupt 1610 
    self.send_enqueueTransactionInfoEmail(transactionId)
1611 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1612 
 
1398 varun.gupt 1613 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1614 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1615 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1616 
    args.transactionId = transactionId
1617 
    args.write(self._oprot)
1618 
    self._oprot.writeMessageEnd()
1619 
    self._oprot.trans.flush()
1620 
 
1398 varun.gupt 1621 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1623 
    if mtype == TMessageType.EXCEPTION:
1624 
      x = TApplicationException()
1625 
      x.read(self._iprot)
1626 
      self._iprot.readMessageEnd()
1627 
      raise x
1398 varun.gupt 1628 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1629 
    result.read(self._iprot)
1630 
    self._iprot.readMessageEnd()
3431 rajveer 1631 
    if result.success is not None:
1382 varun.gupt 1632 
      return result.success
3431 rajveer 1633 
    if result.ex is not None:
1382 varun.gupt 1634 
      raise result.ex
1398 varun.gupt 1635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1636 
 
4801 anupam.sin 1637 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1638 
    """
1639 
    Parameters:
4801 anupam.sin 1640 
     - statuses
483 rajveer 1641 
     - from_date
1642 
     - to_date
1643 
     - warehouse_id
94 ashish 1644 
    """
4801 anupam.sin 1645 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1646 
    return self.recv_getAllOrders()
94 ashish 1647 
 
4801 anupam.sin 1648 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1649 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1650 
    args = getAllOrders_args()
4801 anupam.sin 1651 
    args.statuses = statuses
483 rajveer 1652 
    args.from_date = from_date
1653 
    args.to_date = to_date
1654 
    args.warehouse_id = warehouse_id
94 ashish 1655 
    args.write(self._oprot)
1656 
    self._oprot.writeMessageEnd()
1657 
    self._oprot.trans.flush()
1658 
 
483 rajveer 1659 
  def recv_getAllOrders(self, ):
94 ashish 1660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1661 
    if mtype == TMessageType.EXCEPTION:
1662 
      x = TApplicationException()
1663 
      x.read(self._iprot)
1664 
      self._iprot.readMessageEnd()
1665 
      raise x
483 rajveer 1666 
    result = getAllOrders_result()
94 ashish 1667 
    result.read(self._iprot)
1668 
    self._iprot.readMessageEnd()
3431 rajveer 1669 
    if result.success is not None:
94 ashish 1670 
      return result.success
3431 rajveer 1671 
    if result.ex is not None:
94 ashish 1672 
      raise result.ex
483 rajveer 1673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1674 
 
4133 chandransh 1675 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1676 
    """
1677 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1678 
    Pass the status as null and the limit as 0 to ignore them.
1679 
 
1680 
    Parameters:
1681 
     - statuses
1682 
     - offset
1683 
     - limit
1684 
     - warehouse_id
1685 
    """
1686 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1687 
    return self.recv_getOrdersInBatch()
1688 
 
1689 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1690 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1691 
    args = getOrdersInBatch_args()
1692 
    args.statuses = statuses
1693 
    args.offset = offset
1694 
    args.limit = limit
1695 
    args.warehouse_id = warehouse_id
1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
1700 
  def recv_getOrdersInBatch(self, ):
1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
1707 
    result = getOrdersInBatch_result()
1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
1710 
    if result.success is not None:
1711 
      return result.success
1712 
    if result.ex is not None:
1713 
      raise result.ex
1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1715 
 
1716 
  def getOrderCount(self, statuses, warehouseId):
1717 
    """
1718 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1719 
 
1720 
    Parameters:
1721 
     - statuses
1722 
     - warehouseId
1723 
    """
1724 
    self.send_getOrderCount(statuses, warehouseId)
1725 
    return self.recv_getOrderCount()
1726 
 
1727 
  def send_getOrderCount(self, statuses, warehouseId):
1728 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1729 
    args = getOrderCount_args()
1730 
    args.statuses = statuses
1731 
    args.warehouseId = warehouseId
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getOrderCount(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getOrderCount_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
1746 
    if result.success is not None:
1747 
      return result.success
1748 
    if result.ex is not None:
1749 
      raise result.ex
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1751 
 
999 varun.gupt 1752 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1753 
    """
1132 chandransh 1754 
    Returns orders within a range of their billing dates
3431 rajveer 1755 
 
999 varun.gupt 1756 
    Parameters:
1757 
     - status
1758 
     - start_billing_date
1759 
     - end_billing_date
1760 
     - warehouse_id
1761 
    """
1762 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1763 
    return self.recv_getOrdersByBillingDate()
1764 
 
1765 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1766 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1767 
    args = getOrdersByBillingDate_args()
1768 
    args.status = status
1769 
    args.start_billing_date = start_billing_date
1770 
    args.end_billing_date = end_billing_date
1771 
    args.warehouse_id = warehouse_id
1772 
    args.write(self._oprot)
1773 
    self._oprot.writeMessageEnd()
1774 
    self._oprot.trans.flush()
1775 
 
1776 
  def recv_getOrdersByBillingDate(self, ):
1777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1778 
    if mtype == TMessageType.EXCEPTION:
1779 
      x = TApplicationException()
1780 
      x.read(self._iprot)
1781 
      self._iprot.readMessageEnd()
1782 
      raise x
1783 
    result = getOrdersByBillingDate_result()
1784 
    result.read(self._iprot)
1785 
    self._iprot.readMessageEnd()
3431 rajveer 1786 
    if result.success is not None:
999 varun.gupt 1787 
      return result.success
3431 rajveer 1788 
    if result.ex is not None:
999 varun.gupt 1789 
      raise result.ex
1790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1791 
 
3451 chandransh 1792 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1793 
    """
1794 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1795 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1796 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1797 
 
3427 chandransh 1798 
    Parameters:
1799 
     - fromShippingDate
1800 
     - toShippingDate
1801 
     - providerId
1802 
     - warehouseId
3451 chandransh 1803 
     - cod
3427 chandransh 1804 
    """
3451 chandransh 1805 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1806 
    return self.recv_getOrdersByShippingDate()
1807 
 
3451 chandransh 1808 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1809 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1810 
    args = getOrdersByShippingDate_args()
1811 
    args.fromShippingDate = fromShippingDate
1812 
    args.toShippingDate = toShippingDate
1813 
    args.providerId = providerId
1814 
    args.warehouseId = warehouseId
3451 chandransh 1815 
    args.cod = cod
3427 chandransh 1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getOrdersByShippingDate(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getOrdersByShippingDate_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
3427 chandransh 1831 
      return result.success
3431 rajveer 1832 
    if result.ex is not None:
3427 chandransh 1833 
      raise result.ex
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1835 
 
1382 varun.gupt 1836 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1837 
    """
1838 
    Returns order ids for orders which can be returned
3431 rajveer 1839 
 
1382 varun.gupt 1840 
    Parameters:
1841 
     - customer_id
1842 
     - limit
1843 
    """
1844 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1845 
    return self.recv_getReturnableOrdersForCustomer()
1846 
 
1847 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1848 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1849 
    args = getReturnableOrdersForCustomer_args()
1850 
    args.customer_id = customer_id
1851 
    args.limit = limit
1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
1856 
  def recv_getReturnableOrdersForCustomer(self, ):
1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
1863 
    result = getReturnableOrdersForCustomer_result()
1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
3431 rajveer 1866 
    if result.success is not None:
1382 varun.gupt 1867 
      return result.success
3431 rajveer 1868 
    if result.ex is not None:
1382 varun.gupt 1869 
      raise result.ex
1870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1871 
 
1872 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1873 
    """
1874 
    Returns order ids for orders which can be cancelled
3431 rajveer 1875 
 
1382 varun.gupt 1876 
    Parameters:
1877 
     - customer_id
1878 
     - limit
1879 
    """
1880 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1881 
    return self.recv_getCancellableOrdersForCustomer()
1882 
 
1883 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1884 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1885 
    args = getCancellableOrdersForCustomer_args()
1886 
    args.customer_id = customer_id
1887 
    args.limit = limit
1888 
    args.write(self._oprot)
1889 
    self._oprot.writeMessageEnd()
1890 
    self._oprot.trans.flush()
1891 
 
1892 
  def recv_getCancellableOrdersForCustomer(self, ):
1893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1894 
    if mtype == TMessageType.EXCEPTION:
1895 
      x = TApplicationException()
1896 
      x.read(self._iprot)
1897 
      self._iprot.readMessageEnd()
1898 
      raise x
1899 
    result = getCancellableOrdersForCustomer_result()
1900 
    result.read(self._iprot)
1901 
    self._iprot.readMessageEnd()
3431 rajveer 1902 
    if result.success is not None:
1382 varun.gupt 1903 
      return result.success
3431 rajveer 1904 
    if result.ex is not None:
1382 varun.gupt 1905 
      raise result.ex
1906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1907 
 
483 rajveer 1908 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1909 
    """
1910 
    Parameters:
483 rajveer 1911 
     - orderId
1912 
     - status
1913 
     - description
94 ashish 1914 
    """
483 rajveer 1915 
    self.send_changeOrderStatus(orderId, status, description)
1916 
    return self.recv_changeOrderStatus()
94 ashish 1917 
 
483 rajveer 1918 
  def send_changeOrderStatus(self, orderId, status, description):
1919 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1920 
    args = changeOrderStatus_args()
1921 
    args.orderId = orderId
1922 
    args.status = status
1923 
    args.description = description
94 ashish 1924 
    args.write(self._oprot)
1925 
    self._oprot.writeMessageEnd()
1926 
    self._oprot.trans.flush()
1927 
 
483 rajveer 1928 
  def recv_changeOrderStatus(self, ):
94 ashish 1929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1930 
    if mtype == TMessageType.EXCEPTION:
1931 
      x = TApplicationException()
1932 
      x.read(self._iprot)
1933 
      self._iprot.readMessageEnd()
1934 
      raise x
483 rajveer 1935 
    result = changeOrderStatus_result()
94 ashish 1936 
    result.read(self._iprot)
1937 
    self._iprot.readMessageEnd()
3431 rajveer 1938 
    if result.success is not None:
94 ashish 1939 
      return result.success
3431 rajveer 1940 
    if result.ex is not None:
94 ashish 1941 
      raise result.ex
483 rajveer 1942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1943 
 
1528 ankur.sing 1944 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1945 
    """
1528 ankur.sing 1946 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1947 
    only user who owns the transaction can view its order details.
3431 rajveer 1948 
 
94 ashish 1949 
    Parameters:
1950 
     - transactionId
1528 ankur.sing 1951 
     - customerId
94 ashish 1952 
    """
1528 ankur.sing 1953 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1954 
    return self.recv_getOrdersForTransaction()
94 ashish 1955 
 
1528 ankur.sing 1956 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1957 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1958 
    args = getOrdersForTransaction_args()
94 ashish 1959 
    args.transactionId = transactionId
1528 ankur.sing 1960 
    args.customerId = customerId
94 ashish 1961 
    args.write(self._oprot)
1962 
    self._oprot.writeMessageEnd()
1963 
    self._oprot.trans.flush()
1964 
 
483 rajveer 1965 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1967 
    if mtype == TMessageType.EXCEPTION:
1968 
      x = TApplicationException()
1969 
      x.read(self._iprot)
1970 
      self._iprot.readMessageEnd()
1971 
      raise x
483 rajveer 1972 
    result = getOrdersForTransaction_result()
94 ashish 1973 
    result.read(self._iprot)
1974 
    self._iprot.readMessageEnd()
3431 rajveer 1975 
    if result.success is not None:
94 ashish 1976 
      return result.success
3431 rajveer 1977 
    if result.ex is not None:
94 ashish 1978 
      raise result.ex
483 rajveer 1979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1980 
 
3014 chandransh 1981 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1982 
    """
3014 chandransh 1983 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1984 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1985 
 
94 ashish 1986 
    Parameters:
483 rajveer 1987 
     - customerId
1988 
     - from_date
1989 
     - to_date
3014 chandransh 1990 
     - statuses
94 ashish 1991 
    """
3014 chandransh 1992 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1993 
    return self.recv_getOrdersForCustomer()
94 ashish 1994 
 
3014 chandransh 1995 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1996 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1997 
    args = getOrdersForCustomer_args()
1998 
    args.customerId = customerId
1999 
    args.from_date = from_date
2000 
    args.to_date = to_date
3014 chandransh 2001 
    args.statuses = statuses
94 ashish 2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
483 rajveer 2006 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
483 rajveer 2013 
    result = getOrdersForCustomer_result()
94 ashish 2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
3431 rajveer 2016 
    if result.success is not None:
94 ashish 2017 
      return result.success
3431 rajveer 2018 
    if result.ex is not None:
94 ashish 2019 
      raise result.ex
483 rajveer 2020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2021 
 
483 rajveer 2022 
  def createOrder(self, order):
94 ashish 2023 
    """
2024 
    Parameters:
483 rajveer 2025 
     - order
94 ashish 2026 
    """
483 rajveer 2027 
    self.send_createOrder(order)
2028 
    return self.recv_createOrder()
94 ashish 2029 
 
483 rajveer 2030 
  def send_createOrder(self, order):
2031 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2032 
    args = createOrder_args()
2033 
    args.order = order
94 ashish 2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
483 rajveer 2038 
  def recv_createOrder(self, ):
94 ashish 2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
483 rajveer 2045 
    result = createOrder_result()
94 ashish 2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
3431 rajveer 2048 
    if result.success is not None:
94 ashish 2049 
      return result.success
3431 rajveer 2050 
    if result.ex is not None:
94 ashish 2051 
      raise result.ex
483 rajveer 2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2053 
 
483 rajveer 2054 
  def getOrder(self, id):
94 ashish 2055 
    """
2056 
    Parameters:
483 rajveer 2057 
     - id
94 ashish 2058 
    """
483 rajveer 2059 
    self.send_getOrder(id)
2060 
    return self.recv_getOrder()
94 ashish 2061 
 
483 rajveer 2062 
  def send_getOrder(self, id):
2063 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2064 
    args = getOrder_args()
2065 
    args.id = id
94 ashish 2066 
    args.write(self._oprot)
2067 
    self._oprot.writeMessageEnd()
2068 
    self._oprot.trans.flush()
2069 
 
483 rajveer 2070 
  def recv_getOrder(self, ):
94 ashish 2071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2072 
    if mtype == TMessageType.EXCEPTION:
2073 
      x = TApplicationException()
2074 
      x.read(self._iprot)
2075 
      self._iprot.readMessageEnd()
2076 
      raise x
483 rajveer 2077 
    result = getOrder_result()
94 ashish 2078 
    result.read(self._iprot)
2079 
    self._iprot.readMessageEnd()
3431 rajveer 2080 
    if result.success is not None:
94 ashish 2081 
      return result.success
3431 rajveer 2082 
    if result.ex is not None:
94 ashish 2083 
      raise result.ex
483 rajveer 2084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2085 
 
483 rajveer 2086 
  def getLineItemsForOrder(self, orderId):
94 ashish 2087 
    """
2088 
    Parameters:
483 rajveer 2089 
     - orderId
94 ashish 2090 
    """
483 rajveer 2091 
    self.send_getLineItemsForOrder(orderId)
2092 
    return self.recv_getLineItemsForOrder()
94 ashish 2093 
 
483 rajveer 2094 
  def send_getLineItemsForOrder(self, orderId):
2095 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2096 
    args = getLineItemsForOrder_args()
2097 
    args.orderId = orderId
94 ashish 2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
483 rajveer 2102 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
483 rajveer 2109 
    result = getLineItemsForOrder_result()
94 ashish 2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
3431 rajveer 2112 
    if result.success is not None:
94 ashish 2113 
      return result.success
3431 rajveer 2114 
    if result.ex is not None:
94 ashish 2115 
      raise result.ex
483 rajveer 2116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2117 
 
4999 phani.kuma 2118 
  def getOrderList(self, order_ids):
2119 
    """
2120 
    Parameters:
2121 
     - order_ids
2122 
    """
2123 
    self.send_getOrderList(order_ids)
2124 
    return self.recv_getOrderList()
2125 
 
2126 
  def send_getOrderList(self, order_ids):
2127 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2128 
    args = getOrderList_args()
2129 
    args.order_ids = order_ids
2130 
    args.write(self._oprot)
2131 
    self._oprot.writeMessageEnd()
2132 
    self._oprot.trans.flush()
2133 
 
2134 
  def recv_getOrderList(self, ):
2135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2136 
    if mtype == TMessageType.EXCEPTION:
2137 
      x = TApplicationException()
2138 
      x.read(self._iprot)
2139 
      self._iprot.readMessageEnd()
2140 
      raise x
2141 
    result = getOrderList_result()
2142 
    result.read(self._iprot)
2143 
    self._iprot.readMessageEnd()
2144 
    if result.success is not None:
2145 
      return result.success
2146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2147 
 
5386 phani.kuma 2148 
  def getOrderListForVendor(self, order_ids, vendorId):
2149 
    """
2150 
    Parameters:
2151 
     - order_ids
2152 
     - vendorId
2153 
    """
2154 
    self.send_getOrderListForVendor(order_ids, vendorId)
2155 
    return self.recv_getOrderListForVendor()
2156 
 
2157 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2158 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2159 
    args = getOrderListForVendor_args()
2160 
    args.order_ids = order_ids
2161 
    args.vendorId = vendorId
2162 
    args.write(self._oprot)
2163 
    self._oprot.writeMessageEnd()
2164 
    self._oprot.trans.flush()
2165 
 
2166 
  def recv_getOrderListForVendor(self, ):
2167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2168 
    if mtype == TMessageType.EXCEPTION:
2169 
      x = TApplicationException()
2170 
      x.read(self._iprot)
2171 
      self._iprot.readMessageEnd()
2172 
      raise x
2173 
    result = getOrderListForVendor_result()
2174 
    result.read(self._iprot)
2175 
    self._iprot.readMessageEnd()
2176 
    if result.success is not None:
2177 
      return result.success
2178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2179 
 
1528 ankur.sing 2180 
  def getOrderForCustomer(self, orderId, customerId):
2181 
    """
2182 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2183 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2184 
 
1528 ankur.sing 2185 
    Parameters:
2186 
     - orderId
2187 
     - customerId
2188 
    """
2189 
    self.send_getOrderForCustomer(orderId, customerId)
2190 
    return self.recv_getOrderForCustomer()
2191 
 
2192 
  def send_getOrderForCustomer(self, orderId, customerId):
2193 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2194 
    args = getOrderForCustomer_args()
2195 
    args.orderId = orderId
2196 
    args.customerId = customerId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_getOrderForCustomer(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = getOrderForCustomer_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
3431 rajveer 2211 
    if result.success is not None:
1528 ankur.sing 2212 
      return result.success
3431 rajveer 2213 
    if result.ex is not None:
1528 ankur.sing 2214 
      raise result.ex
2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2216 
 
4444 rajveer 2217 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2218 
    """
2219 
    Parameters:
4394 rajveer 2220 
     - type
4444 rajveer 2221 
     - warehouseId
4394 rajveer 2222 
     - status
2223 
     - timestamp
3064 chandransh 2224 
    """
4444 rajveer 2225 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2226 
    return self.recv_getAlerts()
2227 
 
4444 rajveer 2228 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2229 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2230 
    args = getAlerts_args()
4394 rajveer 2231 
    args.type = type
4444 rajveer 2232 
    args.warehouseId = warehouseId
4394 rajveer 2233 
    args.status = status
2234 
    args.timestamp = timestamp
3064 chandransh 2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
2239 
  def recv_getAlerts(self, ):
2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
2246 
    result = getAlerts_result()
2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
3431 rajveer 2249 
    if result.success is not None:
3064 chandransh 2250 
      return result.success
2251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2252 
 
4444 rajveer 2253 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2254 
    """
2255 
    Parameters:
2256 
     - type
4444 rajveer 2257 
     - warehouseId
4394 rajveer 2258 
     - description
3064 chandransh 2259 
    """
4444 rajveer 2260 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2261 
    self.recv_addAlert()
3064 chandransh 2262 
 
4444 rajveer 2263 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2264 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2265 
    args = addAlert_args()
3064 chandransh 2266 
    args.type = type
4444 rajveer 2267 
    args.warehouseId = warehouseId
4394 rajveer 2268 
    args.description = description
3064 chandransh 2269 
    args.write(self._oprot)
2270 
    self._oprot.writeMessageEnd()
2271 
    self._oprot.trans.flush()
2272 
 
4394 rajveer 2273 
  def recv_addAlert(self, ):
3064 chandransh 2274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2275 
    if mtype == TMessageType.EXCEPTION:
2276 
      x = TApplicationException()
2277 
      x.read(self._iprot)
2278 
      self._iprot.readMessageEnd()
2279 
      raise x
4394 rajveer 2280 
    result = addAlert_result()
3064 chandransh 2281 
    result.read(self._iprot)
2282 
    self._iprot.readMessageEnd()
2283 
    return
2284 
 
4444 rajveer 2285 
  def markAlertsAsSeen(self, warehouseId):
2286 
    """
2287 
    Parameters:
2288 
     - warehouseId
2289 
    """
2290 
    self.send_markAlertsAsSeen(warehouseId)
2291 
    self.recv_markAlertsAsSeen()
2292 
 
2293 
  def send_markAlertsAsSeen(self, warehouseId):
2294 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2295 
    args = markAlertsAsSeen_args()
2296 
    args.warehouseId = warehouseId
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_markAlertsAsSeen(self, ):
2302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2303 
    if mtype == TMessageType.EXCEPTION:
2304 
      x = TApplicationException()
2305 
      x.read(self._iprot)
2306 
      self._iprot.readMessageEnd()
2307 
      raise x
2308 
    result = markAlertsAsSeen_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
2311 
    return
2312 
 
3064 chandransh 2313 
  def getValidOrderCount(self, ):
2314 
    """
2315 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2316 
    """
2317 
    self.send_getValidOrderCount()
2318 
    return self.recv_getValidOrderCount()
2319 
 
2320 
  def send_getValidOrderCount(self, ):
2321 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2322 
    args = getValidOrderCount_args()
2323 
    args.write(self._oprot)
2324 
    self._oprot.writeMessageEnd()
2325 
    self._oprot.trans.flush()
2326 
 
2327 
  def recv_getValidOrderCount(self, ):
2328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2329 
    if mtype == TMessageType.EXCEPTION:
2330 
      x = TApplicationException()
2331 
      x.read(self._iprot)
2332 
      self._iprot.readMessageEnd()
2333 
      raise x
2334 
    result = getValidOrderCount_result()
2335 
    result.read(self._iprot)
2336 
    self._iprot.readMessageEnd()
3431 rajveer 2337 
    if result.success is not None:
3064 chandransh 2338 
      return result.success
2339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2340 
 
2341 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2342 
    """
2343 
    Returns the number of distinct customers who have done successful transactions
2344 
    """
2345 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2346 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2347 
 
2348 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2349 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2350 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
3431 rajveer 2365 
    if result.success is not None:
3064 chandransh 2366 
      return result.success
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2368 
 
2369 
  def getValidOrdersAmountRange(self, ):
2370 
    """
2371 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2372 
    List contains two values, first minimum amount and second maximum amount.
2373 
    """
2374 
    self.send_getValidOrdersAmountRange()
2375 
    return self.recv_getValidOrdersAmountRange()
2376 
 
2377 
  def send_getValidOrdersAmountRange(self, ):
2378 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2379 
    args = getValidOrdersAmountRange_args()
2380 
    args.write(self._oprot)
2381 
    self._oprot.writeMessageEnd()
2382 
    self._oprot.trans.flush()
2383 
 
2384 
  def recv_getValidOrdersAmountRange(self, ):
2385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2386 
    if mtype == TMessageType.EXCEPTION:
2387 
      x = TApplicationException()
2388 
      x.read(self._iprot)
2389 
      self._iprot.readMessageEnd()
2390 
      raise x
2391 
    result = getValidOrdersAmountRange_result()
2392 
    result.read(self._iprot)
2393 
    self._iprot.readMessageEnd()
3431 rajveer 2394 
    if result.success is not None:
3064 chandransh 2395 
      return result.success
2396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2397 
 
5874 rajveer 2398 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2399 
    """
2400 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2401 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2402 
 
3064 chandransh 2403 
    Parameters:
2404 
     - limit
5874 rajveer 2405 
     - onlyStore
3064 chandransh 2406 
    """
5874 rajveer 2407 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2408 
    return self.recv_getValidOrders()
2409 
 
5874 rajveer 2410 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2411 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2412 
    args = getValidOrders_args()
2413 
    args.limit = limit
5874 rajveer 2414 
    args.onlyStore = onlyStore
3064 chandransh 2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_getValidOrders(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = getValidOrders_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
3431 rajveer 2429 
    if result.success is not None:
3064 chandransh 2430 
      return result.success
2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2432 
 
1220 chandransh 2433 
  def batchOrders(self, warehouseId):
2434 
    """
2435 
    Create a batch of all the pending orders for the given warehouse.
2436 
    The returned list is orderd by created_timestamp.
2437 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2438 
 
1220 chandransh 2439 
    Parameters:
2440 
     - warehouseId
2441 
    """
2442 
    self.send_batchOrders(warehouseId)
2443 
    return self.recv_batchOrders()
2444 
 
2445 
  def send_batchOrders(self, warehouseId):
2446 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2447 
    args = batchOrders_args()
2448 
    args.warehouseId = warehouseId
2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_batchOrders(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = batchOrders_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
3431 rajveer 2463 
    if result.success is not None:
1220 chandransh 2464 
      return result.success
3431 rajveer 2465 
    if result.ex is not None:
1220 chandransh 2466 
      raise result.ex
2467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2468 
 
1208 chandransh 2469 
  def markOrderAsOutOfStock(self, orderId):
2470 
    """
2471 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2472 
 
1208 chandransh 2473 
    Parameters:
2474 
     - orderId
2475 
    """
2476 
    self.send_markOrderAsOutOfStock(orderId)
2477 
    return self.recv_markOrderAsOutOfStock()
2478 
 
2479 
  def send_markOrderAsOutOfStock(self, orderId):
2480 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2481 
    args = markOrderAsOutOfStock_args()
2482 
    args.orderId = orderId
2483 
    args.write(self._oprot)
2484 
    self._oprot.writeMessageEnd()
2485 
    self._oprot.trans.flush()
2486 
 
2487 
  def recv_markOrderAsOutOfStock(self, ):
2488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2489 
    if mtype == TMessageType.EXCEPTION:
2490 
      x = TApplicationException()
2491 
      x.read(self._iprot)
2492 
      self._iprot.readMessageEnd()
2493 
      raise x
2494 
    result = markOrderAsOutOfStock_result()
2495 
    result.read(self._iprot)
2496 
    self._iprot.readMessageEnd()
3431 rajveer 2497 
    if result.success is not None:
1208 chandransh 2498 
      return result.success
3431 rajveer 2499 
    if result.ex is not None:
1208 chandransh 2500 
      raise result.ex
2501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2502 
 
3064 chandransh 2503 
  def verifyOrder(self, orderId):
759 chandransh 2504 
    """
3064 chandransh 2505 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2506 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2507 
    used for all other orders as well.
2508 
    Throws an exception if no such order exists.
3431 rajveer 2509 
 
759 chandransh 2510 
    Parameters:
3064 chandransh 2511 
     - orderId
759 chandransh 2512 
    """
3064 chandransh 2513 
    self.send_verifyOrder(orderId)
2514 
    return self.recv_verifyOrder()
759 chandransh 2515 
 
3064 chandransh 2516 
  def send_verifyOrder(self, orderId):
2517 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2518 
    args = verifyOrder_args()
2519 
    args.orderId = orderId
759 chandransh 2520 
    args.write(self._oprot)
2521 
    self._oprot.writeMessageEnd()
2522 
    self._oprot.trans.flush()
2523 
 
3064 chandransh 2524 
  def recv_verifyOrder(self, ):
759 chandransh 2525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2526 
    if mtype == TMessageType.EXCEPTION:
2527 
      x = TApplicationException()
2528 
      x.read(self._iprot)
2529 
      self._iprot.readMessageEnd()
2530 
      raise x
3064 chandransh 2531 
    result = verifyOrder_result()
759 chandransh 2532 
    result.read(self._iprot)
2533 
    self._iprot.readMessageEnd()
3431 rajveer 2534 
    if result.success is not None:
759 chandransh 2535 
      return result.success
3431 rajveer 2536 
    if result.ex is not None:
759 chandransh 2537 
      raise result.ex
3064 chandransh 2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2539 
 
3064 chandransh 2540 
  def acceptOrder(self, orderId):
1113 chandransh 2541 
    """
3064 chandransh 2542 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2543 
    given order is not a COD order, it also captures the payment if the same has
2544 
    not been captured.
2545 
    Throws an exception if no such order exists.
3431 rajveer 2546 
 
1113 chandransh 2547 
    Parameters:
3064 chandransh 2548 
     - orderId
1113 chandransh 2549 
    """
3064 chandransh 2550 
    self.send_acceptOrder(orderId)
2551 
    return self.recv_acceptOrder()
1113 chandransh 2552 
 
3064 chandransh 2553 
  def send_acceptOrder(self, orderId):
2554 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2555 
    args = acceptOrder_args()
2556 
    args.orderId = orderId
1113 chandransh 2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
3064 chandransh 2561 
  def recv_acceptOrder(self, ):
1113 chandransh 2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
3064 chandransh 2568 
    result = acceptOrder_result()
1113 chandransh 2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
3431 rajveer 2571 
    if result.success is not None:
1113 chandransh 2572 
      return result.success
3431 rajveer 2573 
    if result.ex is not None:
1113 chandransh 2574 
      raise result.ex
3064 chandransh 2575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2576 
 
5110 mandeep.dh 2577 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2578 
    """
3064 chandransh 2579 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2580 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2581 
    the IMEI no. if a -1 is supplied.
2582 
    Also, it generates an invoice number for the order, marks the order as
2583 
    BILLED and sets the billing timestamp.
2584 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2585 
 
1135 chandransh 2586 
    Parameters:
3064 chandransh 2587 
     - orderId
2588 
     - invoice_number
4658 mandeep.dh 2589 
     - serialNumber
4283 anupam.sin 2590 
     - itemNumber
3064 chandransh 2591 
     - billed_by
4264 rajveer 2592 
     - jacketNumber
4283 anupam.sin 2593 
     - billingType
5110 mandeep.dh 2594 
     - fulfilmentWarehouseId
4763 rajveer 2595 
     - authorize
1135 chandransh 2596 
    """
5110 mandeep.dh 2597 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2598 
    return self.recv_addBillingDetails()
1135 chandransh 2599 
 
5110 mandeep.dh 2600 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2601 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2602 
    args = addBillingDetails_args()
2603 
    args.orderId = orderId
2604 
    args.invoice_number = invoice_number
4658 mandeep.dh 2605 
    args.serialNumber = serialNumber
4283 anupam.sin 2606 
    args.itemNumber = itemNumber
3064 chandransh 2607 
    args.billed_by = billed_by
4264 rajveer 2608 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2609 
    args.billingType = billingType
5110 mandeep.dh 2610 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2611 
    args.authorize = authorize
1135 chandransh 2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
3064 chandransh 2616 
  def recv_addBillingDetails(self, ):
1135 chandransh 2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
3064 chandransh 2623 
    result = addBillingDetails_result()
1135 chandransh 2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
3431 rajveer 2626 
    if result.success is not None:
3064 chandransh 2627 
      return result.success
3431 rajveer 2628 
    if result.ex is not None:
1135 chandransh 2629 
      raise result.ex
3064 chandransh 2630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2631 
 
4763 rajveer 2632 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2633 
    """
2634 
    Add the invoice number to the order.
2635 
 
2636 
    Parameters:
2637 
     - orderId
2638 
     - invoiceNumber
4763 rajveer 2639 
     - color
4579 rajveer 2640 
    """
4763 rajveer 2641 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2642 
    self.recv_addInvoiceNumber()
2643 
 
4763 rajveer 2644 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2645 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2646 
    args = addInvoiceNumber_args()
2647 
    args.orderId = orderId
2648 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2649 
    args.color = color
4579 rajveer 2650 
    args.write(self._oprot)
2651 
    self._oprot.writeMessageEnd()
2652 
    self._oprot.trans.flush()
2653 
 
2654 
  def recv_addInvoiceNumber(self, ):
2655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2656 
    if mtype == TMessageType.EXCEPTION:
2657 
      x = TApplicationException()
2658 
      x.read(self._iprot)
2659 
      self._iprot.readMessageEnd()
2660 
      raise x
2661 
    result = addInvoiceNumber_result()
2662 
    result.read(self._iprot)
2663 
    self._iprot.readMessageEnd()
2664 
    if result.ex is not None:
2665 
      raise result.ex
2666 
    return
2667 
 
4910 phani.kuma 2668 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2669 
    """
3064 chandransh 2670 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2671 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2672 
 
1408 ankur.sing 2673 
    Parameters:
3064 chandransh 2674 
     - warehouseId
1408 ankur.sing 2675 
     - providerId
3064 chandransh 2676 
     - cod
4910 phani.kuma 2677 
     - orderIds
1408 ankur.sing 2678 
    """
4910 phani.kuma 2679 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2680 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2681 
 
4910 phani.kuma 2682 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2683 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2684 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2685 
    args.warehouseId = warehouseId
1408 ankur.sing 2686 
    args.providerId = providerId
3064 chandransh 2687 
    args.cod = cod
4910 phani.kuma 2688 
    args.orderIds = orderIds
1408 ankur.sing 2689 
    args.write(self._oprot)
2690 
    self._oprot.writeMessageEnd()
2691 
    self._oprot.trans.flush()
2692 
 
4910 phani.kuma 2693 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2695 
    if mtype == TMessageType.EXCEPTION:
2696 
      x = TApplicationException()
2697 
      x.read(self._iprot)
2698 
      self._iprot.readMessageEnd()
2699 
      raise x
4910 phani.kuma 2700 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2701 
    result.read(self._iprot)
2702 
    self._iprot.readMessageEnd()
3431 rajveer 2703 
    if result.success is not None:
1408 ankur.sing 2704 
      return result.success
3431 rajveer 2705 
    if result.ex is not None:
3064 chandransh 2706 
      raise result.ex
4910 phani.kuma 2707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2708 
 
5713 rajveer 2709 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2710 
    """
2711 
    Parameters:
2712 
     - providerId
2713 
     - orderIds
5713 rajveer 2714 
     - awbs
5676 rajveer 2715 
    """
5713 rajveer 2716 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2717 
    return self.recv_markOrdersAsReturnedFromStore()
2718 
 
5713 rajveer 2719 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2720 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2721 
    args = markOrdersAsReturnedFromStore_args()
2722 
    args.providerId = providerId
2723 
    args.orderIds = orderIds
5713 rajveer 2724 
    args.awbs = awbs
5676 rajveer 2725 
    args.write(self._oprot)
2726 
    self._oprot.writeMessageEnd()
2727 
    self._oprot.trans.flush()
2728 
 
2729 
  def recv_markOrdersAsReturnedFromStore(self, ):
2730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2731 
    if mtype == TMessageType.EXCEPTION:
2732 
      x = TApplicationException()
2733 
      x.read(self._iprot)
2734 
      self._iprot.readMessageEnd()
2735 
      raise x
2736 
    result = markOrdersAsReturnedFromStore_result()
2737 
    result.read(self._iprot)
2738 
    self._iprot.readMessageEnd()
2739 
    if result.success is not None:
2740 
      return result.success
2741 
    if result.ex is not None:
2742 
      raise result.ex
2743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2744 
 
4910 phani.kuma 2745 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2746 
    """
4910 phani.kuma 2747 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2748 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2749 
 
2750 
    Parameters:
2751 
     - providerId
4910 phani.kuma 2752 
     - pickupDetails
4410 rajveer 2753 
    """
4910 phani.kuma 2754 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2755 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2756 
 
4910 phani.kuma 2757 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2758 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2759 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2760 
    args.providerId = providerId
4910 phani.kuma 2761 
    args.pickupDetails = pickupDetails
4410 rajveer 2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
4910 phani.kuma 2766 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
4910 phani.kuma 2773 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
2776 
    if result.ex is not None:
2777 
      raise result.ex
4910 phani.kuma 2778 
    return
4410 rajveer 2779 
 
4910 phani.kuma 2780 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2781 
    """
3064 chandransh 2782 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2783 
 
94 ashish 2784 
    Parameters:
3064 chandransh 2785 
     - providerId
304 ashish 2786 
    """
4910 phani.kuma 2787 
    self.send_getOrdersNotPickedUp(providerId)
2788 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2789 
 
4910 phani.kuma 2790 
  def send_getOrdersNotPickedUp(self, providerId):
2791 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2792 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2793 
    args.providerId = providerId
304 ashish 2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
4910 phani.kuma 2798 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
4910 phani.kuma 2805 
    result = getOrdersNotPickedUp_result()
304 ashish 2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
3431 rajveer 2808 
    if result.success is not None:
304 ashish 2809 
      return result.success
4910 phani.kuma 2810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2811 
 
3064 chandransh 2812 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2813 
    """
3064 chandransh 2814 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2815 
    the name of the receiver.
2816 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2817 
 
304 ashish 2818 
    Parameters:
3064 chandransh 2819 
     - providerId
2820 
     - deliveredOrders
304 ashish 2821 
    """
3064 chandransh 2822 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2823 
    self.recv_markOrdersAsDelivered()
304 ashish 2824 
 
3064 chandransh 2825 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2826 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2827 
    args = markOrdersAsDelivered_args()
2828 
    args.providerId = providerId
2829 
    args.deliveredOrders = deliveredOrders
304 ashish 2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
3064 chandransh 2834 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
3064 chandransh 2841 
    result = markOrdersAsDelivered_result()
304 ashish 2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
3431 rajveer 2844 
    if result.ex is not None:
3064 chandransh 2845 
      raise result.ex
304 ashish 2846 
    return
2847 
 
4910 phani.kuma 2848 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2849 
    """
4910 phani.kuma 2850 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2851 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2852 
 
3064 chandransh 2853 
    Parameters:
2854 
     - providerId
2855 
     - returnedOrders
1596 ankur.sing 2856 
    """
4910 phani.kuma 2857 
    self.send_markAsRTOrders(providerId, returnedOrders)
2858 
    self.recv_markAsRTOrders()
304 ashish 2859 
 
4910 phani.kuma 2860 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2861 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2862 
    args = markAsRTOrders_args()
3064 chandransh 2863 
    args.providerId = providerId
2864 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2865 
    args.write(self._oprot)
2866 
    self._oprot.writeMessageEnd()
2867 
    self._oprot.trans.flush()
2868 
 
4910 phani.kuma 2869 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2871 
    if mtype == TMessageType.EXCEPTION:
2872 
      x = TApplicationException()
2873 
      x.read(self._iprot)
2874 
      self._iprot.readMessageEnd()
2875 
      raise x
4910 phani.kuma 2876 
    result = markAsRTOrders_result()
1596 ankur.sing 2877 
    result.read(self._iprot)
2878 
    self._iprot.readMessageEnd()
3431 rajveer 2879 
    if result.ex is not None:
3064 chandransh 2880 
      raise result.ex
2881 
    return
1596 ankur.sing 2882 
 
4910 phani.kuma 2883 
  def getRTOrders(self, providerId):
2884 
    """
2885 
    Returns a list of orders that were returned by courier.
2886 
 
2887 
    Parameters:
2888 
     - providerId
2889 
    """
2890 
    self.send_getRTOrders(providerId)
2891 
    return self.recv_getRTOrders()
2892 
 
2893 
  def send_getRTOrders(self, providerId):
2894 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2895 
    args = getRTOrders_args()
2896 
    args.providerId = providerId
2897 
    args.write(self._oprot)
2898 
    self._oprot.writeMessageEnd()
2899 
    self._oprot.trans.flush()
2900 
 
2901 
  def recv_getRTOrders(self, ):
2902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2903 
    if mtype == TMessageType.EXCEPTION:
2904 
      x = TApplicationException()
2905 
      x.read(self._iprot)
2906 
      self._iprot.readMessageEnd()
2907 
      raise x
2908 
    result = getRTOrders_result()
2909 
    result.read(self._iprot)
2910 
    self._iprot.readMessageEnd()
2911 
    if result.success is not None:
2912 
      return result.success
2913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2914 
 
3064 chandransh 2915 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2916 
    """
3064 chandransh 2917 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2918 
 
3064 chandransh 2919 
    Parameters:
2920 
     - providerId
2921 
     - undeliveredOrders
1627 ankur.sing 2922 
    """
3064 chandransh 2923 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2924 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2925 
 
3064 chandransh 2926 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2927 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2928 
    args = updateNonDeliveryReason_args()
2929 
    args.providerId = providerId
2930 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2931 
    args.write(self._oprot)
2932 
    self._oprot.writeMessageEnd()
2933 
    self._oprot.trans.flush()
2934 
 
3064 chandransh 2935 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2937 
    if mtype == TMessageType.EXCEPTION:
2938 
      x = TApplicationException()
2939 
      x.read(self._iprot)
2940 
      self._iprot.readMessageEnd()
2941 
      raise x
3064 chandransh 2942 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2943 
    result.read(self._iprot)
2944 
    self._iprot.readMessageEnd()
4910 phani.kuma 2945 
    if result.ex is not None:
2946 
      raise result.ex
2947 
    return
2948 
 
2949 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2950 
    """
2951 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2952 
 
2953 
    Parameters:
2954 
     - providerId
2955 
    """
2956 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2957 
    return self.recv_getNonDeliveredOrdersbyCourier()
2958 
 
2959 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2960 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2961 
    args = getNonDeliveredOrdersbyCourier_args()
2962 
    args.providerId = providerId
2963 
    args.write(self._oprot)
2964 
    self._oprot.writeMessageEnd()
2965 
    self._oprot.trans.flush()
2966 
 
2967 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2969 
    if mtype == TMessageType.EXCEPTION:
2970 
      x = TApplicationException()
2971 
      x.read(self._iprot)
2972 
      self._iprot.readMessageEnd()
2973 
      raise x
2974 
    result = getNonDeliveredOrdersbyCourier_result()
2975 
    result.read(self._iprot)
2976 
    self._iprot.readMessageEnd()
4581 phani.kuma 2977 
    if result.success is not None:
2978 
      return result.success
4910 phani.kuma 2979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2980 
 
2981 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2982 
    """
2983 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2984 
 
2985 
    Parameters:
2986 
     - providerId
2987 
     - local_connected_orders
2988 
    """
2989 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2990 
    self.recv_markOrdersAsLocalConnected()
2991 
 
2992 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2993 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2994 
    args = markOrdersAsLocalConnected_args()
2995 
    args.providerId = providerId
2996 
    args.local_connected_orders = local_connected_orders
2997 
    args.write(self._oprot)
2998 
    self._oprot.writeMessageEnd()
2999 
    self._oprot.trans.flush()
3000 
 
3001 
  def recv_markOrdersAsLocalConnected(self, ):
3002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3003 
    if mtype == TMessageType.EXCEPTION:
3004 
      x = TApplicationException()
3005 
      x.read(self._iprot)
3006 
      self._iprot.readMessageEnd()
3007 
      raise x
3008 
    result = markOrdersAsLocalConnected_result()
3009 
    result.read(self._iprot)
3010 
    self._iprot.readMessageEnd()
3431 rajveer 3011 
    if result.ex is not None:
3064 chandransh 3012 
      raise result.ex
4910 phani.kuma 3013 
    return
1627 ankur.sing 3014 
 
4910 phani.kuma 3015 
  def getOrdersNotLocalConnected(self, providerId):
3016 
    """
3017 
    Returns a list of orders that were picked up or shipped but pending local connection.
3018 
 
3019 
    Parameters:
3020 
     - providerId
3021 
    """
3022 
    self.send_getOrdersNotLocalConnected(providerId)
3023 
    return self.recv_getOrdersNotLocalConnected()
3024 
 
3025 
  def send_getOrdersNotLocalConnected(self, providerId):
3026 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3027 
    args = getOrdersNotLocalConnected_args()
3028 
    args.providerId = providerId
3029 
    args.write(self._oprot)
3030 
    self._oprot.writeMessageEnd()
3031 
    self._oprot.trans.flush()
3032 
 
3033 
  def recv_getOrdersNotLocalConnected(self, ):
3034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3035 
    if mtype == TMessageType.EXCEPTION:
3036 
      x = TApplicationException()
3037 
      x.read(self._iprot)
3038 
      self._iprot.readMessageEnd()
3039 
      raise x
3040 
    result = getOrdersNotLocalConnected_result()
3041 
    result.read(self._iprot)
3042 
    self._iprot.readMessageEnd()
3043 
    if result.success is not None:
3044 
      return result.success
3045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3046 
 
3047 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3048 
    """
3049 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3050 
 
3051 
    Parameters:
3052 
     - providerId
3053 
     - destination_city_reached_orders
3054 
    """
3055 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3056 
    self.recv_markOrdersAsDestinationCityReached()
3057 
 
3058 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3059 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3060 
    args = markOrdersAsDestinationCityReached_args()
3061 
    args.providerId = providerId
3062 
    args.destination_city_reached_orders = destination_city_reached_orders
3063 
    args.write(self._oprot)
3064 
    self._oprot.writeMessageEnd()
3065 
    self._oprot.trans.flush()
3066 
 
3067 
  def recv_markOrdersAsDestinationCityReached(self, ):
3068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3069 
    if mtype == TMessageType.EXCEPTION:
3070 
      x = TApplicationException()
3071 
      x.read(self._iprot)
3072 
      self._iprot.readMessageEnd()
3073 
      raise x
3074 
    result = markOrdersAsDestinationCityReached_result()
3075 
    result.read(self._iprot)
3076 
    self._iprot.readMessageEnd()
3077 
    if result.ex is not None:
3078 
      raise result.ex
3079 
    return
3080 
 
3081 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3082 
    """
3083 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3084 
 
3085 
    Parameters:
3086 
     - providerId
3087 
     - first_atdl_orders
3088 
    """
3089 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3090 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3091 
 
3092 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3093 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3094 
    args = markOrdersAsFirstDeliveryAttempted_args()
3095 
    args.providerId = providerId
3096 
    args.first_atdl_orders = first_atdl_orders
3097 
    args.write(self._oprot)
3098 
    self._oprot.writeMessageEnd()
3099 
    self._oprot.trans.flush()
3100 
 
3101 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3103 
    if mtype == TMessageType.EXCEPTION:
3104 
      x = TApplicationException()
3105 
      x.read(self._iprot)
3106 
      self._iprot.readMessageEnd()
3107 
      raise x
3108 
    result = markOrdersAsFirstDeliveryAttempted_result()
3109 
    result.read(self._iprot)
3110 
    self._iprot.readMessageEnd()
3111 
    if result.ex is not None:
3112 
      raise result.ex
3113 
    return
3114 
 
3064 chandransh 3115 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3116 
    """
3064 chandransh 3117 
    Returns the list of orders whose delivery time has passed but have not been
3118 
    delivered yet for the given provider and warehouse. To get a complete list of
3119 
    undelivered orders, pass them as -1.
3120 
    Returns an empty list if no such orders exist.
3431 rajveer 3121 
 
1886 ankur.sing 3122 
    Parameters:
3064 chandransh 3123 
     - providerId
3124 
     - warehouseId
1886 ankur.sing 3125 
    """
3064 chandransh 3126 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3127 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3128 
 
3064 chandransh 3129 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3130 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3131 
    args = getUndeliveredOrders_args()
3132 
    args.providerId = providerId
3133 
    args.warehouseId = warehouseId
1886 ankur.sing 3134 
    args.write(self._oprot)
3135 
    self._oprot.writeMessageEnd()
3136 
    self._oprot.trans.flush()
3137 
 
3064 chandransh 3138 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3140 
    if mtype == TMessageType.EXCEPTION:
3141 
      x = TApplicationException()
3142 
      x.read(self._iprot)
3143 
      self._iprot.readMessageEnd()
3144 
      raise x
3064 chandransh 3145 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3146 
    result.read(self._iprot)
3147 
    self._iprot.readMessageEnd()
3431 rajveer 3148 
    if result.success is not None:
1886 ankur.sing 3149 
      return result.success
3064 chandransh 3150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3151 
 
4783 phani.kuma 3152 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3153 
    """
3154 
    Returns the list of orders whose expected delivery date has passed but have not been
3155 
    delivered yet.
3156 
    Returns an empty list if no such orders exist.
3157 
    """
3158 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3159 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3160 
 
3161 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3162 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3163 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3164 
    args.write(self._oprot)
3165 
    self._oprot.writeMessageEnd()
3166 
    self._oprot.trans.flush()
3167 
 
3168 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3170 
    if mtype == TMessageType.EXCEPTION:
3171 
      x = TApplicationException()
3172 
      x.read(self._iprot)
3173 
      self._iprot.readMessageEnd()
3174 
      raise x
3175 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3176 
    result.read(self._iprot)
3177 
    self._iprot.readMessageEnd()
3178 
    if result.success is not None:
3179 
      return result.success
3180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3181 
 
2536 chandransh 3182 
  def toggleDOAFlag(self, orderId):
3183 
    """
3184 
    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.
3185 
    Returns the final flag status.
3186 
    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 3187 
 
2536 chandransh 3188 
    Parameters:
3189 
     - orderId
3190 
    """
3191 
    self.send_toggleDOAFlag(orderId)
3192 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3193 
 
2536 chandransh 3194 
  def send_toggleDOAFlag(self, orderId):
3195 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3196 
    args = toggleDOAFlag_args()
3197 
    args.orderId = orderId
3198 
    args.write(self._oprot)
3199 
    self._oprot.writeMessageEnd()
3200 
    self._oprot.trans.flush()
3201 
 
3202 
  def recv_toggleDOAFlag(self, ):
3203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3204 
    if mtype == TMessageType.EXCEPTION:
3205 
      x = TApplicationException()
3206 
      x.read(self._iprot)
3207 
      self._iprot.readMessageEnd()
3208 
      raise x
3209 
    result = toggleDOAFlag_result()
3210 
    result.read(self._iprot)
3211 
    self._iprot.readMessageEnd()
3431 rajveer 3212 
    if result.success is not None:
2536 chandransh 3213 
      return result.success
3431 rajveer 3214 
    if result.ex is not None:
2536 chandransh 3215 
      raise result.ex
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3217 
 
4712 rajveer 3218 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3219 
    """
3220 
    Parameters:
3221 
     - orderId
3222 
     - deliveryTimestamp
3223 
     - receiver
3224 
    """
3225 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3226 
    self.recv_markOrderAsDelivered()
3227 
 
3228 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3229 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3230 
    args = markOrderAsDelivered_args()
3231 
    args.orderId = orderId
3232 
    args.deliveryTimestamp = deliveryTimestamp
3233 
    args.receiver = receiver
3234 
    args.write(self._oprot)
3235 
    self._oprot.writeMessageEnd()
3236 
    self._oprot.trans.flush()
3237 
 
3238 
  def recv_markOrderAsDelivered(self, ):
3239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3240 
    if mtype == TMessageType.EXCEPTION:
3241 
      x = TApplicationException()
3242 
      x.read(self._iprot)
3243 
      self._iprot.readMessageEnd()
3244 
      raise x
3245 
    result = markOrderAsDelivered_result()
3246 
    result.read(self._iprot)
3247 
    self._iprot.readMessageEnd()
3248 
    if result.ex is not None:
3249 
      raise result.ex
3250 
    return
3251 
 
5553 rajveer 3252 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3253 
    """
3254 
    Parameters:
3255 
     - orderId
3256 
     - deliveryTimestamp
3257 
    """
3258 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3259 
    self.recv_markOrderAsReceivedAtStore()
3260 
 
3261 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3262 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3263 
    args = markOrderAsReceivedAtStore_args()
3264 
    args.orderId = orderId
3265 
    args.deliveryTimestamp = deliveryTimestamp
3266 
    args.write(self._oprot)
3267 
    self._oprot.writeMessageEnd()
3268 
    self._oprot.trans.flush()
3269 
 
3270 
  def recv_markOrderAsReceivedAtStore(self, ):
3271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3272 
    if mtype == TMessageType.EXCEPTION:
3273 
      x = TApplicationException()
3274 
      x.read(self._iprot)
3275 
      self._iprot.readMessageEnd()
3276 
      raise x
3277 
    result = markOrderAsReceivedAtStore_result()
3278 
    result.read(self._iprot)
3279 
    self._iprot.readMessageEnd()
3280 
    if result.ex is not None:
3281 
      raise result.ex
3282 
    return
3283 
 
4454 rajveer 3284 
  def markOrderDoaRequestReceived(self, orderId):
3285 
    """
3286 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3287 
 
3288 
    Parameters:
3289 
     - orderId
3290 
    """
3291 
    self.send_markOrderDoaRequestReceived(orderId)
3292 
    return self.recv_markOrderDoaRequestReceived()
3293 
 
3294 
  def send_markOrderDoaRequestReceived(self, orderId):
3295 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3296 
    args = markOrderDoaRequestReceived_args()
3297 
    args.orderId = orderId
3298 
    args.write(self._oprot)
3299 
    self._oprot.writeMessageEnd()
3300 
    self._oprot.trans.flush()
3301 
 
3302 
  def recv_markOrderDoaRequestReceived(self, ):
3303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3304 
    if mtype == TMessageType.EXCEPTION:
3305 
      x = TApplicationException()
3306 
      x.read(self._iprot)
3307 
      self._iprot.readMessageEnd()
3308 
      raise x
3309 
    result = markOrderDoaRequestReceived_result()
3310 
    result.read(self._iprot)
3311 
    self._iprot.readMessageEnd()
3312 
    if result.success is not None:
3313 
      return result.success
3314 
    if result.ex is not None:
3315 
      raise result.ex
3316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3317 
 
3318 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3319 
    """
3320 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3321 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3322 
 
3323 
    Parameters:
3324 
     - orderId
3325 
     - isAuthorized
3326 
    """
3327 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3328 
    return self.recv_markOrderDoaRequestAuthorized()
3329 
 
3330 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3331 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3332 
    args = markOrderDoaRequestAuthorized_args()
3333 
    args.orderId = orderId
3334 
    args.isAuthorized = isAuthorized
3335 
    args.write(self._oprot)
3336 
    self._oprot.writeMessageEnd()
3337 
    self._oprot.trans.flush()
3338 
 
3339 
  def recv_markOrderDoaRequestAuthorized(self, ):
3340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3341 
    if mtype == TMessageType.EXCEPTION:
3342 
      x = TApplicationException()
3343 
      x.read(self._iprot)
3344 
      self._iprot.readMessageEnd()
3345 
      raise x
3346 
    result = markOrderDoaRequestAuthorized_result()
3347 
    result.read(self._iprot)
3348 
    self._iprot.readMessageEnd()
3349 
    if result.success is not None:
3350 
      return result.success
3351 
    if result.ex is not None:
3352 
      raise result.ex
3353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3354 
 
4488 rajveer 3355 
  def markOrderReturnRequestReceived(self, orderId):
3356 
    """
3357 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3358 
 
3359 
    Parameters:
3360 
     - orderId
3361 
    """
3362 
    self.send_markOrderReturnRequestReceived(orderId)
3363 
    return self.recv_markOrderReturnRequestReceived()
3364 
 
3365 
  def send_markOrderReturnRequestReceived(self, orderId):
3366 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3367 
    args = markOrderReturnRequestReceived_args()
3368 
    args.orderId = orderId
3369 
    args.write(self._oprot)
3370 
    self._oprot.writeMessageEnd()
3371 
    self._oprot.trans.flush()
3372 
 
3373 
  def recv_markOrderReturnRequestReceived(self, ):
3374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3375 
    if mtype == TMessageType.EXCEPTION:
3376 
      x = TApplicationException()
3377 
      x.read(self._iprot)
3378 
      self._iprot.readMessageEnd()
3379 
      raise x
3380 
    result = markOrderReturnRequestReceived_result()
3381 
    result.read(self._iprot)
3382 
    self._iprot.readMessageEnd()
3383 
    if result.success is not None:
3384 
      return result.success
3385 
    if result.ex is not None:
3386 
      raise result.ex
3387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3388 
 
3389 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3390 
    """
3391 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3392 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3393 
 
3394 
    Parameters:
3395 
     - orderId
3396 
     - isAuthorized
3397 
    """
3398 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3399 
    return self.recv_markOrderReturnRequestAuthorized()
3400 
 
3401 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3402 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3403 
    args = markOrderReturnRequestAuthorized_args()
3404 
    args.orderId = orderId
3405 
    args.isAuthorized = isAuthorized
3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_markOrderReturnRequestAuthorized(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = markOrderReturnRequestAuthorized_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3420 
    if result.success is not None:
3421 
      return result.success
3422 
    if result.ex is not None:
3423 
      raise result.ex
3424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3425 
 
4579 rajveer 3426 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3427 
    """
3428 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3429 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3430 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3431 
    For any other status, it returns false.
3432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3433 
 
2536 chandransh 3434 
    Parameters:
3435 
     - orderId
4579 rajveer 3436 
     - providerId
2536 chandransh 3437 
    """
4579 rajveer 3438 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3439 
    return self.recv_requestPickupNumber()
3440 
 
4579 rajveer 3441 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3442 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3443 
    args = requestPickupNumber_args()
3444 
    args.orderId = orderId
4579 rajveer 3445 
    args.providerId = providerId
2536 chandransh 3446 
    args.write(self._oprot)
3447 
    self._oprot.writeMessageEnd()
3448 
    self._oprot.trans.flush()
3449 
 
3450 
  def recv_requestPickupNumber(self, ):
3451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3452 
    if mtype == TMessageType.EXCEPTION:
3453 
      x = TApplicationException()
3454 
      x.read(self._iprot)
3455 
      self._iprot.readMessageEnd()
3456 
      raise x
3457 
    result = requestPickupNumber_result()
3458 
    result.read(self._iprot)
3459 
    self._iprot.readMessageEnd()
3431 rajveer 3460 
    if result.success is not None:
2536 chandransh 3461 
      return result.success
3431 rajveer 3462 
    if result.ex is not None:
2536 chandransh 3463 
      raise result.ex
3464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3465 
 
4602 rajveer 3466 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3467 
    """
4452 rajveer 3468 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3469 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3470 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3471 
    	3. Returns true
2591 chandransh 3472 
    If the order is in any other status, it returns false.
2536 chandransh 3473 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3474 
 
2536 chandransh 3475 
    Parameters:
3476 
     - orderId
3477 
     - pickupNumber
4602 rajveer 3478 
     - providerId
2536 chandransh 3479 
    """
4602 rajveer 3480 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3481 
    return self.recv_authorizePickup()
3482 
 
4602 rajveer 3483 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3484 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3485 
    args = authorizePickup_args()
3486 
    args.orderId = orderId
3487 
    args.pickupNumber = pickupNumber
4602 rajveer 3488 
    args.providerId = providerId
2536 chandransh 3489 
    args.write(self._oprot)
3490 
    self._oprot.writeMessageEnd()
3491 
    self._oprot.trans.flush()
3492 
 
3493 
  def recv_authorizePickup(self, ):
3494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3495 
    if mtype == TMessageType.EXCEPTION:
3496 
      x = TApplicationException()
3497 
      x.read(self._iprot)
3498 
      self._iprot.readMessageEnd()
3499 
      raise x
3500 
    result = authorizePickup_result()
3501 
    result.read(self._iprot)
3502 
    self._iprot.readMessageEnd()
3431 rajveer 3503 
    if result.success is not None:
2536 chandransh 3504 
      return result.success
3431 rajveer 3505 
    if result.ex is not None:
2536 chandransh 3506 
      raise result.ex
3507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3508 
 
2764 chandransh 3509 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3510 
    """
3511 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3512 
 
2764 chandransh 3513 
    Parameters:
3514 
     - providerId
3515 
     - pickupDetails
3516 
    """
3517 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3518 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3519 
 
3520 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3521 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3522 
    args = markDoasAsPickedUp_args()
3523 
    args.providerId = providerId
3524 
    args.pickupDetails = pickupDetails
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_markDoasAsPickedUp(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = markDoasAsPickedUp_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
4910 phani.kuma 3539 
    return
3540 
 
3541 
  def getDoasNotPickedUp(self, providerId):
3542 
    """
3543 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3544 
 
3545 
    Parameters:
3546 
     - providerId
3547 
    """
3548 
    self.send_getDoasNotPickedUp(providerId)
3549 
    return self.recv_getDoasNotPickedUp()
3550 
 
3551 
  def send_getDoasNotPickedUp(self, providerId):
3552 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3553 
    args = getDoasNotPickedUp_args()
3554 
    args.providerId = providerId
3555 
    args.write(self._oprot)
3556 
    self._oprot.writeMessageEnd()
3557 
    self._oprot.trans.flush()
3558 
 
3559 
  def recv_getDoasNotPickedUp(self, ):
3560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3561 
    if mtype == TMessageType.EXCEPTION:
3562 
      x = TApplicationException()
3563 
      x.read(self._iprot)
3564 
      self._iprot.readMessageEnd()
3565 
      raise x
3566 
    result = getDoasNotPickedUp_result()
3567 
    result.read(self._iprot)
3568 
    self._iprot.readMessageEnd()
3431 rajveer 3569 
    if result.success is not None:
2764 chandransh 3570 
      return result.success
4910 phani.kuma 3571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3572 
 
4741 phani.kuma 3573 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3574 
    """
3575 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3576 
 
3577 
    Parameters:
3578 
     - providerId
3579 
     - pickupDetails
3580 
    """
3581 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3582 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3583 
 
3584 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3585 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3586 
    args = markReturnOrdersAsPickedUp_args()
3587 
    args.providerId = providerId
3588 
    args.pickupDetails = pickupDetails
3589 
    args.write(self._oprot)
3590 
    self._oprot.writeMessageEnd()
3591 
    self._oprot.trans.flush()
3592 
 
3593 
  def recv_markReturnOrdersAsPickedUp(self, ):
3594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3595 
    if mtype == TMessageType.EXCEPTION:
3596 
      x = TApplicationException()
3597 
      x.read(self._iprot)
3598 
      self._iprot.readMessageEnd()
3599 
      raise x
3600 
    result = markReturnOrdersAsPickedUp_result()
3601 
    result.read(self._iprot)
3602 
    self._iprot.readMessageEnd()
4910 phani.kuma 3603 
    return
3604 
 
3605 
  def getReturnOrdersNotPickedUp(self, providerId):
3606 
    """
3607 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3608 
 
3609 
    Parameters:
3610 
     - providerId
3611 
    """
3612 
    self.send_getReturnOrdersNotPickedUp(providerId)
3613 
    return self.recv_getReturnOrdersNotPickedUp()
3614 
 
3615 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3616 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3617 
    args = getReturnOrdersNotPickedUp_args()
3618 
    args.providerId = providerId
3619 
    args.write(self._oprot)
3620 
    self._oprot.writeMessageEnd()
3621 
    self._oprot.trans.flush()
3622 
 
3623 
  def recv_getReturnOrdersNotPickedUp(self, ):
3624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3625 
    if mtype == TMessageType.EXCEPTION:
3626 
      x = TApplicationException()
3627 
      x.read(self._iprot)
3628 
      self._iprot.readMessageEnd()
3629 
      raise x
3630 
    result = getReturnOrdersNotPickedUp_result()
3631 
    result.read(self._iprot)
3632 
    self._iprot.readMessageEnd()
4741 phani.kuma 3633 
    if result.success is not None:
3634 
      return result.success
4910 phani.kuma 3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3636 
 
4479 rajveer 3637 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3638 
    """
4452 rajveer 3639 
    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 3640 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3641 
    If the order is in any other state, it returns false.
3642 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3643 
 
2591 chandransh 3644 
    Parameters:
3645 
     - orderId
4479 rajveer 3646 
     - receiveCondition
2591 chandransh 3647 
    """
4479 rajveer 3648 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3649 
    return self.recv_receiveReturn()
2536 chandransh 3650 
 
4479 rajveer 3651 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3652 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3653 
    args = receiveReturn_args()
2591 chandransh 3654 
    args.orderId = orderId
4479 rajveer 3655 
    args.receiveCondition = receiveCondition
2591 chandransh 3656 
    args.write(self._oprot)
3657 
    self._oprot.writeMessageEnd()
3658 
    self._oprot.trans.flush()
3659 
 
2616 chandransh 3660 
  def recv_receiveReturn(self, ):
2591 chandransh 3661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3662 
    if mtype == TMessageType.EXCEPTION:
3663 
      x = TApplicationException()
3664 
      x.read(self._iprot)
3665 
      self._iprot.readMessageEnd()
3666 
      raise x
2616 chandransh 3667 
    result = receiveReturn_result()
2591 chandransh 3668 
    result.read(self._iprot)
3669 
    self._iprot.readMessageEnd()
3431 rajveer 3670 
    if result.success is not None:
2591 chandransh 3671 
      return result.success
3431 rajveer 3672 
    if result.ex is not None:
2591 chandransh 3673 
      raise result.ex
2616 chandransh 3674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3675 
 
3676 
  def validateDoa(self, orderId, isValid):
3677 
    """
4452 rajveer 3678 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3679 
    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 3680 
    If the order is in any other state, it returns false.
3681 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3682 
 
2591 chandransh 3683 
    Parameters:
3684 
     - orderId
3685 
     - isValid
3686 
    """
3687 
    self.send_validateDoa(orderId, isValid)
3688 
    return self.recv_validateDoa()
3689 
 
3690 
  def send_validateDoa(self, orderId, isValid):
3691 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3692 
    args = validateDoa_args()
3693 
    args.orderId = orderId
3694 
    args.isValid = isValid
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_validateDoa(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = validateDoa_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3431 rajveer 3709 
    if result.success is not None:
2591 chandransh 3710 
      return result.success
3431 rajveer 3711 
    if result.ex is not None:
2591 chandransh 3712 
      raise result.ex
3713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3714 
 
4495 rajveer 3715 
  def validateReturnProduct(self, orderId, isUsable):
3716 
    """
3717 
    Parameters:
3718 
     - orderId
3719 
     - isUsable
3720 
    """
3721 
    self.send_validateReturnProduct(orderId, isUsable)
3722 
    return self.recv_validateReturnProduct()
3723 
 
3724 
  def send_validateReturnProduct(self, orderId, isUsable):
3725 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3726 
    args = validateReturnProduct_args()
3727 
    args.orderId = orderId
3728 
    args.isUsable = isUsable
3729 
    args.write(self._oprot)
3730 
    self._oprot.writeMessageEnd()
3731 
    self._oprot.trans.flush()
3732 
 
3733 
  def recv_validateReturnProduct(self, ):
3734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3735 
    if mtype == TMessageType.EXCEPTION:
3736 
      x = TApplicationException()
3737 
      x.read(self._iprot)
3738 
      self._iprot.readMessageEnd()
3739 
      raise x
3740 
    result = validateReturnProduct_result()
3741 
    result.read(self._iprot)
3742 
    self._iprot.readMessageEnd()
3743 
    if result.success is not None:
3744 
      return result.success
3745 
    if result.ex is not None:
3746 
      raise result.ex
3747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3748 
 
2616 chandransh 3749 
  def reshipOrder(self, orderId):
3750 
    """
4484 rajveer 3751 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3752 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3753 
    	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 3754 
 
3755 
    If the order is in DOA_CERT_VALID state, it does the following:
3756 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3757 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3758 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3759 
 
2616 chandransh 3760 
    Returns the id of the newly created order.
3431 rajveer 3761 
 
2616 chandransh 3762 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3763 
 
2616 chandransh 3764 
    Parameters:
3765 
     - orderId
3766 
    """
3767 
    self.send_reshipOrder(orderId)
3768 
    return self.recv_reshipOrder()
2591 chandransh 3769 
 
2616 chandransh 3770 
  def send_reshipOrder(self, orderId):
3771 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3772 
    args = reshipOrder_args()
3773 
    args.orderId = orderId
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_reshipOrder(self, ):
3779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3780 
    if mtype == TMessageType.EXCEPTION:
3781 
      x = TApplicationException()
3782 
      x.read(self._iprot)
3783 
      self._iprot.readMessageEnd()
3784 
      raise x
3785 
    result = reshipOrder_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3431 rajveer 3788 
    if result.success is not None:
2616 chandransh 3789 
      return result.success
3431 rajveer 3790 
    if result.ex is not None:
2616 chandransh 3791 
      raise result.ex
3792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3793 
 
3226 chandransh 3794 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3795 
    """
4484 rajveer 3796 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3797 
    	1. Creates a refund request for batch processing.
3798 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3799 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3800 
 
2616 chandransh 3801 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3802 
    	1. Creates a refund request for batch processing.
3226 chandransh 3803 
    	2. Cancels the reservation of the item in the warehouse.
3804 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3805 
 
3226 chandransh 3806 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3807 
    	1. Cancels the reservation of the item in the warehouse.
3808 
    	2. Marks the current order as CANCELED.
3809 
 
3810 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3811 
 
2616 chandransh 3812 
    Returns True if it is successful, False otherwise.
3431 rajveer 3813 
 
2616 chandransh 3814 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3815 
 
2616 chandransh 3816 
    Parameters:
3817 
     - orderId
3226 chandransh 3818 
     - refundedBy
3819 
     - reason
2616 chandransh 3820 
    """
3226 chandransh 3821 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3822 
    return self.recv_refundOrder()
3823 
 
3226 chandransh 3824 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3825 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3826 
    args = refundOrder_args()
3827 
    args.orderId = orderId
3226 chandransh 3828 
    args.refundedBy = refundedBy
3829 
    args.reason = reason
2616 chandransh 3830 
    args.write(self._oprot)
3831 
    self._oprot.writeMessageEnd()
3832 
    self._oprot.trans.flush()
3833 
 
3834 
  def recv_refundOrder(self, ):
3835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3836 
    if mtype == TMessageType.EXCEPTION:
3837 
      x = TApplicationException()
3838 
      x.read(self._iprot)
3839 
      self._iprot.readMessageEnd()
3840 
      raise x
3841 
    result = refundOrder_result()
3842 
    result.read(self._iprot)
3843 
    self._iprot.readMessageEnd()
3431 rajveer 3844 
    if result.success is not None:
2616 chandransh 3845 
      return result.success
3431 rajveer 3846 
    if result.ex is not None:
2616 chandransh 3847 
      raise result.ex
3848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3849 
 
2690 chandransh 3850 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3851 
    """
3852 
    Get all return orders created between the from and to dates for the given warehouse.
3853 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3854 
 
2690 chandransh 3855 
    Parameters:
3856 
     - warehouseId
3857 
     - fromDate
3858 
     - toDate
3859 
    """
3860 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3861 
    return self.recv_getReturnOrders()
2616 chandransh 3862 
 
2690 chandransh 3863 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3864 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3865 
    args = getReturnOrders_args()
3866 
    args.warehouseId = warehouseId
3867 
    args.fromDate = fromDate
3868 
    args.toDate = toDate
3869 
    args.write(self._oprot)
3870 
    self._oprot.writeMessageEnd()
3871 
    self._oprot.trans.flush()
3872 
 
3873 
  def recv_getReturnOrders(self, ):
3874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3875 
    if mtype == TMessageType.EXCEPTION:
3876 
      x = TApplicationException()
3877 
      x.read(self._iprot)
3878 
      self._iprot.readMessageEnd()
3879 
      raise x
3880 
    result = getReturnOrders_result()
3881 
    result.read(self._iprot)
3882 
    self._iprot.readMessageEnd()
3431 rajveer 3883 
    if result.success is not None:
2690 chandransh 3884 
      return result.success
3885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3886 
 
5481 phani.kuma 3887 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3888 
    """
3889 
    Get all return orders created between the from and to dates.
3890 
 
3891 
    Parameters:
3892 
     - onlyNotProcessed
3893 
     - fromDate
3894 
     - toDate
3895 
    """
3896 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3897 
    return self.recv_getAllReturnOrders()
3898 
 
3899 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3900 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3901 
    args = getAllReturnOrders_args()
3902 
    args.onlyNotProcessed = onlyNotProcessed
3903 
    args.fromDate = fromDate
3904 
    args.toDate = toDate
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_getAllReturnOrders(self, ):
3910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3911 
    if mtype == TMessageType.EXCEPTION:
3912 
      x = TApplicationException()
3913 
      x.read(self._iprot)
3914 
      self._iprot.readMessageEnd()
3915 
      raise x
3916 
    result = getAllReturnOrders_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3919 
    if result.success is not None:
3920 
      return result.success
3921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3922 
 
2700 chandransh 3923 
  def getReturnOrder(self, id):
3924 
    """
3925 
    Returns the ReturnOrder corresponding to the given id.
3926 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3927 
 
2700 chandransh 3928 
    Parameters:
3929 
     - id
3930 
    """
3931 
    self.send_getReturnOrder(id)
3932 
    return self.recv_getReturnOrder()
3933 
 
3934 
  def send_getReturnOrder(self, id):
3935 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3936 
    args = getReturnOrder_args()
3937 
    args.id = id
3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
3942 
  def recv_getReturnOrder(self, ):
3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
3949 
    result = getReturnOrder_result()
3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3431 rajveer 3952 
    if result.success is not None:
2700 chandransh 3953 
      return result.success
3431 rajveer 3954 
    if result.ex is not None:
2700 chandransh 3955 
      raise result.ex
3956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3957 
 
2690 chandransh 3958 
  def processReturn(self, returnOrderId):
3959 
    """
3960 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3961 
 
2690 chandransh 3962 
    Parameters:
3963 
     - returnOrderId
3964 
    """
3965 
    self.send_processReturn(returnOrderId)
3966 
    self.recv_processReturn()
3967 
 
3968 
  def send_processReturn(self, returnOrderId):
3969 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3970 
    args = processReturn_args()
3971 
    args.returnOrderId = returnOrderId
3972 
    args.write(self._oprot)
3973 
    self._oprot.writeMessageEnd()
3974 
    self._oprot.trans.flush()
3975 
 
3976 
  def recv_processReturn(self, ):
3977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3978 
    if mtype == TMessageType.EXCEPTION:
3979 
      x = TApplicationException()
3980 
      x.read(self._iprot)
3981 
      self._iprot.readMessageEnd()
3982 
      raise x
3983 
    result = processReturn_result()
3984 
    result.read(self._iprot)
3985 
    self._iprot.readMessageEnd()
3431 rajveer 3986 
    if result.ex is not None:
2690 chandransh 3987 
      raise result.ex
3988 
    return
3989 
 
3451 chandransh 3990 
  def updateWeight(self, orderId, weight):
3991 
    """
3992 
    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 3993 
 
3451 chandransh 3994 
    Parameters:
3995 
     - orderId
3996 
     - weight
3997 
    """
3998 
    self.send_updateWeight(orderId, weight)
3999 
    return self.recv_updateWeight()
4000 
 
4001 
  def send_updateWeight(self, orderId, weight):
4002 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4003 
    args = updateWeight_args()
4004 
    args.orderId = orderId
4005 
    args.weight = weight
4006 
    args.write(self._oprot)
4007 
    self._oprot.writeMessageEnd()
4008 
    self._oprot.trans.flush()
4009 
 
4010 
  def recv_updateWeight(self, ):
4011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4012 
    if mtype == TMessageType.EXCEPTION:
4013 
      x = TApplicationException()
4014 
      x.read(self._iprot)
4015 
      self._iprot.readMessageEnd()
4016 
      raise x
4017 
    result = updateWeight_result()
4018 
    result.read(self._iprot)
4019 
    self._iprot.readMessageEnd()
4020 
    if result.success is not None:
4021 
      return result.success
4022 
    if result.ex is not None:
4023 
      raise result.ex
4024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4025 
 
3469 chandransh 4026 
  def changeItem(self, orderId, itemId):
4027 
    """
4028 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4029 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4030 
 
3469 chandransh 4031 
    Parameters:
4032 
     - orderId
4033 
     - itemId
4034 
    """
4035 
    self.send_changeItem(orderId, itemId)
4036 
    return self.recv_changeItem()
4037 
 
4038 
  def send_changeItem(self, orderId, itemId):
4039 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4040 
    args = changeItem_args()
4041 
    args.orderId = orderId
4042 
    args.itemId = itemId
4043 
    args.write(self._oprot)
4044 
    self._oprot.writeMessageEnd()
4045 
    self._oprot.trans.flush()
4046 
 
4047 
  def recv_changeItem(self, ):
4048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4049 
    if mtype == TMessageType.EXCEPTION:
4050 
      x = TApplicationException()
4051 
      x.read(self._iprot)
4052 
      self._iprot.readMessageEnd()
4053 
      raise x
4054 
    result = changeItem_result()
4055 
    result.read(self._iprot)
4056 
    self._iprot.readMessageEnd()
4057 
    if result.success is not None:
4058 
      return result.success
4059 
    if result.ex is not None:
4060 
      raise result.ex
4061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4062 
 
4063 
  def shiftToWarehouse(self, orderId, warehouseId):
4064 
    """
4065 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4066 
 
4067 
    Parameters:
4068 
     - orderId
4069 
     - warehouseId
4070 
    """
4071 
    self.send_shiftToWarehouse(orderId, warehouseId)
4072 
    return self.recv_shiftToWarehouse()
4073 
 
4074 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4075 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4076 
    args = shiftToWarehouse_args()
4077 
    args.orderId = orderId
4078 
    args.warehouseId = warehouseId
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_shiftToWarehouse(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = shiftToWarehouse_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
4093 
    if result.success is not None:
4094 
      return result.success
4095 
    if result.ex is not None:
4096 
      raise result.ex
4097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4098 
 
4647 rajveer 4099 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4100 
    """
4101 
    Adds the given delay reason to the given order.
3986 chandransh 4102 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4103 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4104 
 
3553 chandransh 4105 
    Parameters:
4106 
     - orderId
4107 
     - delayReason
3986 chandransh 4108 
     - furtherDelay
4647 rajveer 4109 
     - delayReasonText
3553 chandransh 4110 
    """
4647 rajveer 4111 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4112 
    return self.recv_addDelayReason()
4113 
 
4647 rajveer 4114 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4115 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4116 
    args = addDelayReason_args()
4117 
    args.orderId = orderId
4118 
    args.delayReason = delayReason
3986 chandransh 4119 
    args.furtherDelay = furtherDelay
4647 rajveer 4120 
    args.delayReasonText = delayReasonText
3553 chandransh 4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_addDelayReason(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = addDelayReason_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.success is not None:
4136 
      return result.success
4137 
    if result.ex is not None:
4138 
      raise result.ex
4139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4140 
 
3956 chandransh 4141 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4142 
    """
4143 
    Marks the COD orders with given AWB nos. as having been processed.
4144 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4145 
 
3956 chandransh 4146 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4147 
    1. There is no order corresponding to an AWB number.
4148 
    2. The captured amount for a payment exceeds the total payment.
4149 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4150 
 
4151 
    Parameters:
4152 
     - collectedAmountMap
4153 
     - xferBy
4154 
     - xferTxnId
4155 
     - xferDate
4156 
    """
4157 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4158 
    return self.recv_reconcileCodCollection()
4159 
 
4160 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4161 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4162 
    args = reconcileCodCollection_args()
4163 
    args.collectedAmountMap = collectedAmountMap
4164 
    args.xferBy = xferBy
4165 
    args.xferTxnId = xferTxnId
4166 
    args.xferDate = xferDate
4167 
    args.write(self._oprot)
4168 
    self._oprot.writeMessageEnd()
4169 
    self._oprot.trans.flush()
4170 
 
4171 
  def recv_reconcileCodCollection(self, ):
4172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4173 
    if mtype == TMessageType.EXCEPTION:
4174 
      x = TApplicationException()
4175 
      x.read(self._iprot)
4176 
      self._iprot.readMessageEnd()
4177 
      raise x
4178 
    result = reconcileCodCollection_result()
4179 
    result.read(self._iprot)
4180 
    self._iprot.readMessageEnd()
4181 
    if result.success is not None:
4182 
      return result.success
4183 
    if result.ex is not None:
4184 
      raise result.ex
4185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4186 
 
4008 mandeep.dh 4187 
  def getTransactionsRequiringExtraProcessing(self, category):
4188 
    """
4065 mandeep.dh 4189 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4190 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4191 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4192 
 
4008 mandeep.dh 4193 
    Parameters:
4194 
     - category
4195 
    """
4196 
    self.send_getTransactionsRequiringExtraProcessing(category)
4197 
    return self.recv_getTransactionsRequiringExtraProcessing()
4198 
 
4199 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4200 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4201 
    args = getTransactionsRequiringExtraProcessing_args()
4202 
    args.category = category
4203 
    args.write(self._oprot)
4204 
    self._oprot.writeMessageEnd()
4205 
    self._oprot.trans.flush()
4206 
 
4207 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4209 
    if mtype == TMessageType.EXCEPTION:
4210 
      x = TApplicationException()
4211 
      x.read(self._iprot)
4212 
      self._iprot.readMessageEnd()
4213 
      raise x
4214 
    result = getTransactionsRequiringExtraProcessing_result()
4215 
    result.read(self._iprot)
4216 
    self._iprot.readMessageEnd()
4217 
    if result.success is not None:
4218 
      return result.success
4219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4220 
 
4221 
  def markTransactionAsProcessed(self, transactionId, category):
4222 
    """
4223 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4224 
    It essentially deletes the transaction id record for a particular
4225 
    processing type category (if present) from DB.
4226 
    This is currently used by CRM application.
4008 mandeep.dh 4227 
 
4228 
    Parameters:
4229 
     - transactionId
4230 
     - category
4231 
    """
4232 
    self.send_markTransactionAsProcessed(transactionId, category)
4233 
    self.recv_markTransactionAsProcessed()
4234 
 
4235 
  def send_markTransactionAsProcessed(self, transactionId, category):
4236 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4237 
    args = markTransactionAsProcessed_args()
4238 
    args.transactionId = transactionId
4239 
    args.category = category
4240 
    args.write(self._oprot)
4241 
    self._oprot.writeMessageEnd()
4242 
    self._oprot.trans.flush()
4243 
 
4244 
  def recv_markTransactionAsProcessed(self, ):
4245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4246 
    if mtype == TMessageType.EXCEPTION:
4247 
      x = TApplicationException()
4248 
      x.read(self._iprot)
4249 
      self._iprot.readMessageEnd()
4250 
      raise x
4251 
    result = markTransactionAsProcessed_result()
4252 
    result.read(self._iprot)
4253 
    self._iprot.readMessageEnd()
4254 
    return
4255 
 
4018 chandransh 4256 
  def getItemWiseRiskyOrdersCount(self, ):
4257 
    """
4258 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4259 
    is defined as one whose shipping date is about to expire.
4260 
    """
4261 
    self.send_getItemWiseRiskyOrdersCount()
4262 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4263 
 
4018 chandransh 4264 
  def send_getItemWiseRiskyOrdersCount(self, ):
4265 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4266 
    args = getItemWiseRiskyOrdersCount_args()
4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = getItemWiseRiskyOrdersCount_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    if result.success is not None:
4282 
      return result.success
4283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4284 
 
4295 varun.gupt 4285 
  def getOrdersForItemIds(self, itemIds):
4286 
    """
4287 
    Returns a list of all orders which have items with given id
4288 
 
4289 
    Parameters:
4290 
     - itemIds
4291 
    """
4292 
    self.send_getOrdersForItemIds(itemIds)
4293 
    return self.recv_getOrdersForItemIds()
4294 
 
4295 
  def send_getOrdersForItemIds(self, itemIds):
4296 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4297 
    args = getOrdersForItemIds_args()
4298 
    args.itemIds = itemIds
4299 
    args.write(self._oprot)
4300 
    self._oprot.writeMessageEnd()
4301 
    self._oprot.trans.flush()
4302 
 
4303 
  def recv_getOrdersForItemIds(self, ):
4304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4305 
    if mtype == TMessageType.EXCEPTION:
4306 
      x = TApplicationException()
4307 
      x.read(self._iprot)
4308 
      self._iprot.readMessageEnd()
4309 
      raise x
4310 
    result = getOrdersForItemIds_result()
4311 
    result.read(self._iprot)
4312 
    self._iprot.readMessageEnd()
4313 
    if result.success is not None:
4314 
      return result.success
4315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4316 
 
4247 rajveer 4317 
  def markOrderCancellationRequestReceived(self, orderId):
4318 
    """
4319 
    Mark order as cancellation request received. If customer sends request of cancellation of
4320 
    a particular order, this method will be called. It will just change status of the order
4321 
    depending on its current status. It also records the previous status, so that we can move
4322 
    back to that status if cancellation request is denied.
4018 chandransh 4323 
 
4247 rajveer 4324 
    Parameters:
4325 
     - orderId
4326 
    """
4327 
    self.send_markOrderCancellationRequestReceived(orderId)
4328 
    self.recv_markOrderCancellationRequestReceived()
4329 
 
4330 
  def send_markOrderCancellationRequestReceived(self, orderId):
4331 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4332 
    args = markOrderCancellationRequestReceived_args()
4333 
    args.orderId = orderId
4334 
    args.write(self._oprot)
4335 
    self._oprot.writeMessageEnd()
4336 
    self._oprot.trans.flush()
4337 
 
4338 
  def recv_markOrderCancellationRequestReceived(self, ):
4339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4340 
    if mtype == TMessageType.EXCEPTION:
4341 
      x = TApplicationException()
4342 
      x.read(self._iprot)
4343 
      self._iprot.readMessageEnd()
4344 
      raise x
4345 
    result = markOrderCancellationRequestReceived_result()
4346 
    result.read(self._iprot)
4347 
    self._iprot.readMessageEnd()
4348 
    if result.ex is not None:
4349 
      raise result.ex
4350 
    return
4351 
 
4352 
  def markOrderCancellationRequestConfirmed(self, orderId):
4353 
    """
4354 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4355 
    cancellation request confirmed. After this OM will be able to cancel the order.
4356 
 
4357 
    Parameters:
4358 
     - orderId
4359 
    """
4360 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4361 
    self.recv_markOrderCancellationRequestConfirmed()
4362 
 
4363 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4364 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4365 
    args = markOrderCancellationRequestConfirmed_args()
4366 
    args.orderId = orderId
4367 
    args.write(self._oprot)
4368 
    self._oprot.writeMessageEnd()
4369 
    self._oprot.trans.flush()
4370 
 
4371 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4373 
    if mtype == TMessageType.EXCEPTION:
4374 
      x = TApplicationException()
4375 
      x.read(self._iprot)
4376 
      self._iprot.readMessageEnd()
4377 
      raise x
4378 
    result = markOrderCancellationRequestConfirmed_result()
4379 
    result.read(self._iprot)
4380 
    self._iprot.readMessageEnd()
4381 
    if result.ex is not None:
4382 
      raise result.ex
4383 
    return
4384 
 
4385 
  def markOrderCancellationRequestDenied(self, orderId):
4386 
    """
4387 
    If we decide to not to cancel order, we will move the order ro previous status.
4388 
 
4389 
    Parameters:
4390 
     - orderId
4391 
    """
4392 
    self.send_markOrderCancellationRequestDenied(orderId)
4393 
    self.recv_markOrderCancellationRequestDenied()
4394 
 
4395 
  def send_markOrderCancellationRequestDenied(self, orderId):
4396 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4397 
    args = markOrderCancellationRequestDenied_args()
4398 
    args.orderId = orderId
4399 
    args.write(self._oprot)
4400 
    self._oprot.writeMessageEnd()
4401 
    self._oprot.trans.flush()
4402 
 
4403 
  def recv_markOrderCancellationRequestDenied(self, ):
4404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4405 
    if mtype == TMessageType.EXCEPTION:
4406 
      x = TApplicationException()
4407 
      x.read(self._iprot)
4408 
      self._iprot.readMessageEnd()
4409 
      raise x
4410 
    result = markOrderCancellationRequestDenied_result()
4411 
    result.read(self._iprot)
4412 
    self._iprot.readMessageEnd()
4413 
    if result.ex is not None:
4414 
      raise result.ex
4415 
    return
4416 
 
4258 rajveer 4417 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4418 
    """
4258 rajveer 4419 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4420 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4421 
 
4422 
    Parameters:
4258 rajveer 4423 
     - transactionId
4247 rajveer 4424 
    """
4258 rajveer 4425 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4426 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4427 
 
4258 rajveer 4428 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4429 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4430 
    args = markTransactionAsPaymentFlagRemoved_args()
4431 
    args.transactionId = transactionId
4247 rajveer 4432 
    args.write(self._oprot)
4433 
    self._oprot.writeMessageEnd()
4434 
    self._oprot.trans.flush()
4435 
 
4258 rajveer 4436 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4438 
    if mtype == TMessageType.EXCEPTION:
4439 
      x = TApplicationException()
4440 
      x.read(self._iprot)
4441 
      self._iprot.readMessageEnd()
4442 
      raise x
4258 rajveer 4443 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4444 
    result.read(self._iprot)
4445 
    self._iprot.readMessageEnd()
4446 
    if result.ex is not None:
4447 
      raise result.ex
4448 
    return
4449 
 
4259 anupam.sin 4450 
  def refundTransaction(self, transactionId, refundedBy, reason):
4451 
    """
4452 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4453 
    need to be cancelled
4247 rajveer 4454 
 
4259 anupam.sin 4455 
    Parameters:
4456 
     - transactionId
4457 
     - refundedBy
4458 
     - reason
4459 
    """
4460 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4461 
    self.recv_refundTransaction()
4462 
 
4463 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4464 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4465 
    args = refundTransaction_args()
4466 
    args.transactionId = transactionId
4467 
    args.refundedBy = refundedBy
4468 
    args.reason = reason
4469 
    args.write(self._oprot)
4470 
    self._oprot.writeMessageEnd()
4471 
    self._oprot.trans.flush()
4472 
 
4473 
  def recv_refundTransaction(self, ):
4474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4475 
    if mtype == TMessageType.EXCEPTION:
4476 
      x = TApplicationException()
4477 
      x.read(self._iprot)
4478 
      self._iprot.readMessageEnd()
4479 
      raise x
4480 
    result = refundTransaction_result()
4481 
    result.read(self._iprot)
4482 
    self._iprot.readMessageEnd()
4483 
    if result.ex is not None:
4484 
      raise result.ex
4485 
    return
4486 
 
4324 mandeep.dh 4487 
  def updateShipmentAddress(self, orderId, addressId):
4488 
    """
4489 
    Updates shipment address of an order. Delivery and shipping date estimates
4490 
    etc. are also updated here.
4491 
 
4492 
    Throws TransactionServiceException in case address change is not
4493 
    possible due to certain reasons such as new pincode in address is
4494 
    not serviceable etc.
4495 
 
4496 
    Parameters:
4497 
     - orderId
4498 
     - addressId
4499 
    """
4500 
    self.send_updateShipmentAddress(orderId, addressId)
4501 
    self.recv_updateShipmentAddress()
4502 
 
4503 
  def send_updateShipmentAddress(self, orderId, addressId):
4504 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4505 
    args = updateShipmentAddress_args()
4506 
    args.orderId = orderId
4507 
    args.addressId = addressId
4508 
    args.write(self._oprot)
4509 
    self._oprot.writeMessageEnd()
4510 
    self._oprot.trans.flush()
4511 
 
4512 
  def recv_updateShipmentAddress(self, ):
4513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4514 
    if mtype == TMessageType.EXCEPTION:
4515 
      x = TApplicationException()
4516 
      x.read(self._iprot)
4517 
      self._iprot.readMessageEnd()
4518 
      raise x
4519 
    result = updateShipmentAddress_result()
4520 
    result.read(self._iprot)
4521 
    self._iprot.readMessageEnd()
4522 
    if result.ex is not None:
4523 
      raise result.ex
4524 
    return
4525 
 
4285 rajveer 4526 
  def acceptOrdersForItemId(self, itemId, inventory):
4527 
    """
4528 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4529 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4530 
 
4285 rajveer 4531 
    Parameters:
4532 
     - itemId
4533 
     - inventory
4534 
    """
4535 
    self.send_acceptOrdersForItemId(itemId, inventory)
4536 
    return self.recv_acceptOrdersForItemId()
4537 
 
4538 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4539 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4540 
    args = acceptOrdersForItemId_args()
4541 
    args.itemId = itemId
4542 
    args.inventory = inventory
4543 
    args.write(self._oprot)
4544 
    self._oprot.writeMessageEnd()
4545 
    self._oprot.trans.flush()
4546 
 
4547 
  def recv_acceptOrdersForItemId(self, ):
4548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4549 
    if mtype == TMessageType.EXCEPTION:
4550 
      x = TApplicationException()
4551 
      x.read(self._iprot)
4552 
      self._iprot.readMessageEnd()
4553 
      raise x
4554 
    result = acceptOrdersForItemId_result()
4555 
    result.read(self._iprot)
4556 
    self._iprot.readMessageEnd()
4557 
    if result.success is not None:
4558 
      return result.success
4559 
    if result.ex is not None:
4560 
      raise result.ex
4561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4562 
 
4369 rajveer 4563 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4564 
    """
4565 
    Parameters:
4566 
     - vendorId
4567 
     - itemId
4568 
     - quantity
4569 
     - estimate
4369 rajveer 4570 
     - isReminder
4303 rajveer 4571 
    """
4369 rajveer 4572 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4573 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4574 
 
4369 rajveer 4575 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4576 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4577 
    args = markOrdersAsPORaised_args()
4578 
    args.vendorId = vendorId
4579 
    args.itemId = itemId
4580 
    args.quantity = quantity
4581 
    args.estimate = estimate
4369 rajveer 4582 
    args.isReminder = isReminder
4303 rajveer 4583 
    args.write(self._oprot)
4584 
    self._oprot.writeMessageEnd()
4585 
    self._oprot.trans.flush()
4586 
 
4587 
  def recv_markOrdersAsPORaised(self, ):
4588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4589 
    if mtype == TMessageType.EXCEPTION:
4590 
      x = TApplicationException()
4591 
      x.read(self._iprot)
4592 
      self._iprot.readMessageEnd()
4593 
      raise x
4594 
    result = markOrdersAsPORaised_result()
4595 
    result.read(self._iprot)
4596 
    self._iprot.readMessageEnd()
4597 
    if result.ex is not None:
4598 
      raise result.ex
4599 
    return
4600 
 
4369 rajveer 4601 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4602 
    """
4603 
    Parameters:
4604 
     - vendorId
4605 
     - itemId
4606 
     - quantity
4607 
     - estimate
4369 rajveer 4608 
     - isReminder
4303 rajveer 4609 
    """
4369 rajveer 4610 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4611 
    self.recv_markOrdersAsReversalInitiated()
4612 
 
4369 rajveer 4613 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4614 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4615 
    args = markOrdersAsReversalInitiated_args()
4616 
    args.vendorId = vendorId
4617 
    args.itemId = itemId
4618 
    args.quantity = quantity
4619 
    args.estimate = estimate
4369 rajveer 4620 
    args.isReminder = isReminder
4303 rajveer 4621 
    args.write(self._oprot)
4622 
    self._oprot.writeMessageEnd()
4623 
    self._oprot.trans.flush()
4624 
 
4625 
  def recv_markOrdersAsReversalInitiated(self, ):
4626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4627 
    if mtype == TMessageType.EXCEPTION:
4628 
      x = TApplicationException()
4629 
      x.read(self._iprot)
4630 
      self._iprot.readMessageEnd()
4631 
      raise x
4632 
    result = markOrdersAsReversalInitiated_result()
4633 
    result.read(self._iprot)
4634 
    self._iprot.readMessageEnd()
4635 
    if result.ex is not None:
4636 
      raise result.ex
4637 
    return
4638 
 
4369 rajveer 4639 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4640 
    """
4641 
    Parameters:
4642 
     - vendorId
4643 
     - itemId
4644 
     - quantity
4645 
     - estimate
4369 rajveer 4646 
     - isReminder
4303 rajveer 4647 
    """
4369 rajveer 4648 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4649 
    self.recv_markOrdersAsNotAvailabke()
4650 
 
4369 rajveer 4651 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4652 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4653 
    args = markOrdersAsNotAvailabke_args()
4654 
    args.vendorId = vendorId
4655 
    args.itemId = itemId
4656 
    args.quantity = quantity
4657 
    args.estimate = estimate
4369 rajveer 4658 
    args.isReminder = isReminder
4303 rajveer 4659 
    args.write(self._oprot)
4660 
    self._oprot.writeMessageEnd()
4661 
    self._oprot.trans.flush()
4662 
 
4663 
  def recv_markOrdersAsNotAvailabke(self, ):
4664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4665 
    if mtype == TMessageType.EXCEPTION:
4666 
      x = TApplicationException()
4667 
      x.read(self._iprot)
4668 
      self._iprot.readMessageEnd()
4669 
      raise x
4670 
    result = markOrdersAsNotAvailabke_result()
4671 
    result.read(self._iprot)
4672 
    self._iprot.readMessageEnd()
4673 
    if result.ex is not None:
4674 
      raise result.ex
4675 
    return
4676 
 
4369 rajveer 4677 
  def markOrdersAsTimeout(self, vendorId):
4678 
    """
4679 
    Parameters:
4680 
     - vendorId
4681 
    """
4682 
    self.send_markOrdersAsTimeout(vendorId)
4683 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4684 
 
4369 rajveer 4685 
  def send_markOrdersAsTimeout(self, vendorId):
4686 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4687 
    args = markOrdersAsTimeout_args()
4688 
    args.vendorId = vendorId
4689 
    args.write(self._oprot)
4690 
    self._oprot.writeMessageEnd()
4691 
    self._oprot.trans.flush()
4692 
 
4693 
  def recv_markOrdersAsTimeout(self, ):
4694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4695 
    if mtype == TMessageType.EXCEPTION:
4696 
      x = TApplicationException()
4697 
      x.read(self._iprot)
4698 
      self._iprot.readMessageEnd()
4699 
      raise x
4700 
    result = markOrdersAsTimeout_result()
4701 
    result.read(self._iprot)
4702 
    self._iprot.readMessageEnd()
4703 
    if result.success is not None:
4704 
      return result.success
4705 
    if result.ex is not None:
4706 
      raise result.ex
4707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4708 
 
4662 rajveer 4709 
  def markOrderAsLostInTransit(self, orderId):
4710 
    """
4711 
    Mark order as LOST_IN_TRANSIT
4712 
 
4713 
    Parameters:
4714 
     - orderId
4715 
    """
4716 
    self.send_markOrderAsLostInTransit(orderId)
4717 
    return self.recv_markOrderAsLostInTransit()
4718 
 
4719 
  def send_markOrderAsLostInTransit(self, orderId):
4720 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4721 
    args = markOrderAsLostInTransit_args()
4722 
    args.orderId = orderId
4723 
    args.write(self._oprot)
4724 
    self._oprot.writeMessageEnd()
4725 
    self._oprot.trans.flush()
4726 
 
4727 
  def recv_markOrderAsLostInTransit(self, ):
4728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4729 
    if mtype == TMessageType.EXCEPTION:
4730 
      x = TApplicationException()
4731 
      x.read(self._iprot)
4732 
      self._iprot.readMessageEnd()
4733 
      raise x
4734 
    result = markOrderAsLostInTransit_result()
4735 
    result.read(self._iprot)
4736 
    self._iprot.readMessageEnd()
4737 
    if result.success is not None:
4738 
      return result.success
4739 
    if result.ex is not None:
4740 
      raise result.ex
4741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4742 
 
4386 anupam.sin 4743 
  def getOrderForAwb(self, awb):
4744 
    """
4745 
    Returns the order corresponding to an AWB number
4369 rajveer 4746 
 
4386 anupam.sin 4747 
    Parameters:
4748 
     - awb
4749 
    """
4750 
    self.send_getOrderForAwb(awb)
4751 
    return self.recv_getOrderForAwb()
4752 
 
4753 
  def send_getOrderForAwb(self, awb):
4754 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4755 
    args = getOrderForAwb_args()
4756 
    args.awb = awb
4757 
    args.write(self._oprot)
4758 
    self._oprot.writeMessageEnd()
4759 
    self._oprot.trans.flush()
4760 
 
4761 
  def recv_getOrderForAwb(self, ):
4762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4763 
    if mtype == TMessageType.EXCEPTION:
4764 
      x = TApplicationException()
4765 
      x.read(self._iprot)
4766 
      self._iprot.readMessageEnd()
4767 
      raise x
4768 
    result = getOrderForAwb_result()
4769 
    result.read(self._iprot)
4770 
    self._iprot.readMessageEnd()
4771 
    if result.success is not None:
4772 
      return result.success
4773 
    if result.ex is not None:
4774 
      raise result.ex
4775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4776 
 
4910 phani.kuma 4777 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4778 
    """
4910 phani.kuma 4779 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4780 
 
4506 phani.kuma 4781 
    Parameters:
4782 
     - logistics_provider_id
4910 phani.kuma 4783 
     - order_status_list
4506 phani.kuma 4784 
    """
4910 phani.kuma 4785 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4786 
    return self.recv_getOrdersForProviderForStatus()
4787 
 
4910 phani.kuma 4788 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4789 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4790 
    args = getOrdersForProviderForStatus_args()
4791 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4792 
    args.order_status_list = order_status_list
4506 phani.kuma 4793 
    args.write(self._oprot)
4794 
    self._oprot.writeMessageEnd()
4795 
    self._oprot.trans.flush()
4796 
 
4797 
  def recv_getOrdersForProviderForStatus(self, ):
4798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4799 
    if mtype == TMessageType.EXCEPTION:
4800 
      x = TApplicationException()
4801 
      x.read(self._iprot)
4802 
      self._iprot.readMessageEnd()
4803 
      raise x
4804 
    result = getOrdersForProviderForStatus_result()
4805 
    result.read(self._iprot)
4806 
    self._iprot.readMessageEnd()
4807 
    if result.success is not None:
4808 
      return result.success
4809 
    if result.ex is not None:
4810 
      raise result.ex
4811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4812 
 
4600 varun.gupt 4813 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4814 
    """
4815 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4816 
 
4600 varun.gupt 4817 
    Parameters:
4818 
     - vendorId
4819 
     - billingDateFrom
4820 
     - billingDateTo
4821 
    """
4822 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4823 
    return self.recv_getBilledOrdersForVendor()
4824 
 
4825 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4826 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4827 
    args = getBilledOrdersForVendor_args()
4828 
    args.vendorId = vendorId
4829 
    args.billingDateFrom = billingDateFrom
4830 
    args.billingDateTo = billingDateTo
4831 
    args.write(self._oprot)
4832 
    self._oprot.writeMessageEnd()
4833 
    self._oprot.trans.flush()
4834 
 
4835 
  def recv_getBilledOrdersForVendor(self, ):
4836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4837 
    if mtype == TMessageType.EXCEPTION:
4838 
      x = TApplicationException()
4839 
      x.read(self._iprot)
4840 
      self._iprot.readMessageEnd()
4841 
      raise x
4842 
    result = getBilledOrdersForVendor_result()
4843 
    result.read(self._iprot)
4844 
    self._iprot.readMessageEnd()
4845 
    if result.success is not None:
4846 
      return result.success
4847 
    if result.ex is not None:
4848 
      raise result.ex
4849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4850 
 
4607 rajveer 4851 
  def getSlippedSippingDateOrders(self, ):
4852 
    self.send_getSlippedSippingDateOrders()
4853 
    return self.recv_getSlippedSippingDateOrders()
4854 
 
4855 
  def send_getSlippedSippingDateOrders(self, ):
4856 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4857 
    args = getSlippedSippingDateOrders_args()
4858 
    args.write(self._oprot)
4859 
    self._oprot.writeMessageEnd()
4860 
    self._oprot.trans.flush()
4861 
 
4862 
  def recv_getSlippedSippingDateOrders(self, ):
4863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4864 
    if mtype == TMessageType.EXCEPTION:
4865 
      x = TApplicationException()
4866 
      x.read(self._iprot)
4867 
      self._iprot.readMessageEnd()
4868 
      raise x
4869 
    result = getSlippedSippingDateOrders_result()
4870 
    result.read(self._iprot)
4871 
    self._iprot.readMessageEnd()
4872 
    if result.success is not None:
4873 
      return result.success
4874 
    if result.ex is not None:
4875 
      raise result.ex
4876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4877 
 
4709 rajveer 4878 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4879 
    """
4880 
    Parameters:
4881 
     - cancelDateFrom
4882 
     - cancelDateTo
4883 
    """
4884 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4885 
    return self.recv_getCancelledOrders()
4886 
 
4887 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4888 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4889 
    args = getCancelledOrders_args()
4890 
    args.cancelDateFrom = cancelDateFrom
4891 
    args.cancelDateTo = cancelDateTo
4892 
    args.write(self._oprot)
4893 
    self._oprot.writeMessageEnd()
4894 
    self._oprot.trans.flush()
4895 
 
4896 
  def recv_getCancelledOrders(self, ):
4897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4898 
    if mtype == TMessageType.EXCEPTION:
4899 
      x = TApplicationException()
4900 
      x.read(self._iprot)
4901 
      self._iprot.readMessageEnd()
4902 
      raise x
4903 
    result = getCancelledOrders_result()
4904 
    result.read(self._iprot)
4905 
    self._iprot.readMessageEnd()
4906 
    if result.success is not None:
4907 
      return result.success
4908 
    if result.ex is not None:
4909 
      raise result.ex
4910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4911 
 
4600 varun.gupt 4912 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4913 
    """
4914 
    Parameters:
4915 
     - mapAWBAndAmount
4916 
    """
4917 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4918 
    self.recv_saveBluedartSettlements()
4919 
 
4920 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4921 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4922 
    args = saveBluedartSettlements_args()
4923 
    args.mapAWBAndAmount = mapAWBAndAmount
4924 
    args.write(self._oprot)
4925 
    self._oprot.writeMessageEnd()
4926 
    self._oprot.trans.flush()
4927 
 
4928 
  def recv_saveBluedartSettlements(self, ):
4929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4930 
    if mtype == TMessageType.EXCEPTION:
4931 
      x = TApplicationException()
4932 
      x.read(self._iprot)
4933 
      self._iprot.readMessageEnd()
4934 
      raise x
4935 
    result = saveBluedartSettlements_result()
4936 
    result.read(self._iprot)
4937 
    self._iprot.readMessageEnd()
4938 
    if result.ex is not None:
4939 
      raise result.ex
4940 
    return
4941 
 
4905 varun.gupt 4942 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4943 
    """
4944 
    Parameters:
4945 
     - settlementDate
4946 
     - paymentGatewayId
4905 varun.gupt 4947 
     - referenceId
4600 varun.gupt 4948 
     - serviceTax
4949 
     - otherCharges
4950 
     - netCollection
4951 
    """
4905 varun.gupt 4952 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4953 
    self.recv_savePaymentSettlements()
4954 
 
4905 varun.gupt 4955 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4956 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4957 
    args = savePaymentSettlements_args()
4958 
    args.settlementDate = settlementDate
4959 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4960 
    args.referenceId = referenceId
4600 varun.gupt 4961 
    args.serviceTax = serviceTax
4962 
    args.otherCharges = otherCharges
4963 
    args.netCollection = netCollection
4964 
    args.write(self._oprot)
4965 
    self._oprot.writeMessageEnd()
4966 
    self._oprot.trans.flush()
4967 
 
4968 
  def recv_savePaymentSettlements(self, ):
4969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4970 
    if mtype == TMessageType.EXCEPTION:
4971 
      x = TApplicationException()
4972 
      x.read(self._iprot)
4973 
      self._iprot.readMessageEnd()
4974 
      raise x
4975 
    result = savePaymentSettlements_result()
4976 
    result.read(self._iprot)
4977 
    self._iprot.readMessageEnd()
4978 
    if result.ex is not None:
4979 
      raise result.ex
4980 
    return
4981 
 
4982 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4983 
    """
4984 
    Parameters:
4985 
     - settlementId
4986 
     - settlementDate
4987 
     - transactionDateFrom
4988 
     - transactionDateTo
4989 
     - amount
4990 
    """
4991 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4992 
    self.recv_saveEBSSettlementSummary()
4993 
 
4994 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4995 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4996 
    args = saveEBSSettlementSummary_args()
4997 
    args.settlementId = settlementId
4998 
    args.settlementDate = settlementDate
4999 
    args.transactionDateFrom = transactionDateFrom
5000 
    args.transactionDateTo = transactionDateTo
5001 
    args.amount = amount
5002 
    args.write(self._oprot)
5003 
    self._oprot.writeMessageEnd()
5004 
    self._oprot.trans.flush()
5005 
 
5006 
  def recv_saveEBSSettlementSummary(self, ):
5007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5008 
    if mtype == TMessageType.EXCEPTION:
5009 
      x = TApplicationException()
5010 
      x.read(self._iprot)
5011 
      self._iprot.readMessageEnd()
5012 
      raise x
5013 
    result = saveEBSSettlementSummary_result()
5014 
    result.read(self._iprot)
5015 
    self._iprot.readMessageEnd()
5016 
    if result.ex is not None:
5017 
      raise result.ex
5018 
    return
5019 
 
5386 phani.kuma 5020 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5021 
    """
5022 
    Parameters:
5189 varun.gupt 5023 
     - referenceId
5024 
     - isRefund
4600 varun.gupt 5025 
    """
5386 phani.kuma 5026 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5027 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5028 
 
5386 phani.kuma 5029 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5030 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5031 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5032 
    args.referenceId = referenceId
5033 
    args.isRefund = isRefund
4600 varun.gupt 5034 
    args.write(self._oprot)
5035 
    self._oprot.writeMessageEnd()
5036 
    self._oprot.trans.flush()
5037 
 
5386 phani.kuma 5038 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5040 
    if mtype == TMessageType.EXCEPTION:
5041 
      x = TApplicationException()
5042 
      x.read(self._iprot)
5043 
      self._iprot.readMessageEnd()
5044 
      raise x
5386 phani.kuma 5045 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5046 
    result.read(self._iprot)
5047 
    self._iprot.readMessageEnd()
5048 
    if result.success is not None:
5049 
      return result.success
5050 
    if result.ex is not None:
5051 
      raise result.ex
5386 phani.kuma 5052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5053 
 
5386 phani.kuma 5054 
  def getSettlementForCod(self, orderId, isRefund):
5055 
    """
5056 
    Parameters:
5057 
     - orderId
5058 
     - isRefund
5059 
    """
5060 
    self.send_getSettlementForCod(orderId, isRefund)
5061 
    return self.recv_getSettlementForCod()
5062 
 
5063 
  def send_getSettlementForCod(self, orderId, isRefund):
5064 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5065 
    args = getSettlementForCod_args()
5066 
    args.orderId = orderId
5067 
    args.isRefund = isRefund
5068 
    args.write(self._oprot)
5069 
    self._oprot.writeMessageEnd()
5070 
    self._oprot.trans.flush()
5071 
 
5072 
  def recv_getSettlementForCod(self, ):
5073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5074 
    if mtype == TMessageType.EXCEPTION:
5075 
      x = TApplicationException()
5076 
      x.read(self._iprot)
5077 
      self._iprot.readMessageEnd()
5078 
      raise x
5079 
    result = getSettlementForCod_result()
5080 
    result.read(self._iprot)
5081 
    self._iprot.readMessageEnd()
5082 
    if result.success is not None:
5083 
      return result.success
5084 
    if result.ex is not None:
5085 
      raise result.ex
5086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5087 
 
4600 varun.gupt 5088 
  def getEBSSettlementSummaries(self, ):
5089 
    self.send_getEBSSettlementSummaries()
5090 
    return self.recv_getEBSSettlementSummaries()
5091 
 
5092 
  def send_getEBSSettlementSummaries(self, ):
5093 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5094 
    args = getEBSSettlementSummaries_args()
5095 
    args.write(self._oprot)
5096 
    self._oprot.writeMessageEnd()
5097 
    self._oprot.trans.flush()
5098 
 
5099 
  def recv_getEBSSettlementSummaries(self, ):
5100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5101 
    if mtype == TMessageType.EXCEPTION:
5102 
      x = TApplicationException()
5103 
      x.read(self._iprot)
5104 
      self._iprot.readMessageEnd()
5105 
      raise x
5106 
    result = getEBSSettlementSummaries_result()
5107 
    result.read(self._iprot)
5108 
    self._iprot.readMessageEnd()
5109 
    if result.success is not None:
5110 
      return result.success
5111 
    if result.ex is not None:
5112 
      raise result.ex
5113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5114 
 
5115 
  def markEBSSettlementUploaded(self, settlementId):
5116 
    """
5117 
    Parameters:
5118 
     - settlementId
5119 
    """
5120 
    self.send_markEBSSettlementUploaded(settlementId)
5121 
    self.recv_markEBSSettlementUploaded()
5122 
 
5123 
  def send_markEBSSettlementUploaded(self, settlementId):
5124 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5125 
    args = markEBSSettlementUploaded_args()
5126 
    args.settlementId = settlementId
5127 
    args.write(self._oprot)
5128 
    self._oprot.writeMessageEnd()
5129 
    self._oprot.trans.flush()
5130 
 
5131 
  def recv_markEBSSettlementUploaded(self, ):
5132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5133 
    if mtype == TMessageType.EXCEPTION:
5134 
      x = TApplicationException()
5135 
      x.read(self._iprot)
5136 
      self._iprot.readMessageEnd()
5137 
      raise x
5138 
    result = markEBSSettlementUploaded_result()
5139 
    result.read(self._iprot)
5140 
    self._iprot.readMessageEnd()
5141 
    if result.ex is not None:
5142 
      raise result.ex
5143 
    return
5144 
 
5145 
  def getEBSSettlementDate(self, settlementId):
5146 
    """
5147 
    Parameters:
5148 
     - settlementId
5149 
    """
5150 
    self.send_getEBSSettlementDate(settlementId)
5151 
    return self.recv_getEBSSettlementDate()
5152 
 
5153 
  def send_getEBSSettlementDate(self, settlementId):
5154 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5155 
    args = getEBSSettlementDate_args()
5156 
    args.settlementId = settlementId
5157 
    args.write(self._oprot)
5158 
    self._oprot.writeMessageEnd()
5159 
    self._oprot.trans.flush()
5160 
 
5161 
  def recv_getEBSSettlementDate(self, ):
5162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5163 
    if mtype == TMessageType.EXCEPTION:
5164 
      x = TApplicationException()
5165 
      x.read(self._iprot)
5166 
      self._iprot.readMessageEnd()
5167 
      raise x
5168 
    result = getEBSSettlementDate_result()
5169 
    result.read(self._iprot)
5170 
    self._iprot.readMessageEnd()
5171 
    if result.success is not None:
5172 
      return result.success
5173 
    if result.ex is not None:
5174 
      raise result.ex
5175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5176 
 
4715 varun.gupt 5177 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5178 
    """
5179 
    Parameters:
5180 
     - settlementDateFrom
5181 
     - settlementDateTo
5182 
     - isRefund
5183 
    """
5184 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5185 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5186 
 
4715 varun.gupt 5187 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5188 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5189 
    args = getSettlementsByDate_args()
5190 
    args.settlementDateFrom = settlementDateFrom
5191 
    args.settlementDateTo = settlementDateTo
5192 
    args.isRefund = isRefund
5193 
    args.write(self._oprot)
5194 
    self._oprot.writeMessageEnd()
5195 
    self._oprot.trans.flush()
5196 
 
5197 
  def recv_getSettlementsByDate(self, ):
5198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5199 
    if mtype == TMessageType.EXCEPTION:
5200 
      x = TApplicationException()
5201 
      x.read(self._iprot)
5202 
      self._iprot.readMessageEnd()
5203 
      raise x
5204 
    result = getSettlementsByDate_result()
5205 
    result.read(self._iprot)
5206 
    self._iprot.readMessageEnd()
5207 
    if result.success is not None:
5208 
      return result.success
5209 
    if result.ex is not None:
5210 
      raise result.ex
5211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5212 
 
5213 
  def getReshippedOrderIds(self, orderIds):
5214 
    """
5215 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5216 
 
5217 
    Parameters:
5218 
     - orderIds
5219 
    """
5220 
    self.send_getReshippedOrderIds(orderIds)
5221 
    return self.recv_getReshippedOrderIds()
5222 
 
5223 
  def send_getReshippedOrderIds(self, orderIds):
5224 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5225 
    args = getReshippedOrderIds_args()
5226 
    args.orderIds = orderIds
5227 
    args.write(self._oprot)
5228 
    self._oprot.writeMessageEnd()
5229 
    self._oprot.trans.flush()
5230 
 
5231 
  def recv_getReshippedOrderIds(self, ):
5232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5233 
    if mtype == TMessageType.EXCEPTION:
5234 
      x = TApplicationException()
5235 
      x.read(self._iprot)
5236 
      self._iprot.readMessageEnd()
5237 
      raise x
5238 
    result = getReshippedOrderIds_result()
5239 
    result.read(self._iprot)
5240 
    self._iprot.readMessageEnd()
5241 
    if result.success is not None:
5242 
      return result.success
5243 
    if result.ex is not None:
5244 
      raise result.ex
5245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5246 
 
5481 phani.kuma 5247 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5248 
    """
5249 
    Parameters:
5250 
     - vendorId
5481 phani.kuma 5251 
     - onlyVendorNotPaid
5252 
     - billingDateFrom
5253 
     - billingDateTo
4875 varun.gupt 5254 
    """
5481 phani.kuma 5255 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5256 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5257 
 
5481 phani.kuma 5258 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5259 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5260 
    args = getBilledOrders_args()
4875 varun.gupt 5261 
    args.vendorId = vendorId
5481 phani.kuma 5262 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5263 
    args.billingDateFrom = billingDateFrom
5264 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5265 
    args.write(self._oprot)
5266 
    self._oprot.writeMessageEnd()
5267 
    self._oprot.trans.flush()
5268 
 
5481 phani.kuma 5269 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5271 
    if mtype == TMessageType.EXCEPTION:
5272 
      x = TApplicationException()
5273 
      x.read(self._iprot)
5274 
      self._iprot.readMessageEnd()
5275 
      raise x
5481 phani.kuma 5276 
    result = getBilledOrders_result()
4875 varun.gupt 5277 
    result.read(self._iprot)
5278 
    self._iprot.readMessageEnd()
5279 
    if result.success is not None:
5280 
      return result.success
5281 
    if result.ex is not None:
5282 
      raise result.ex
5481 phani.kuma 5283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5284 
 
5031 varun.gupt 5285 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5286 
    """
5287 
    Parameters:
5288 
     - startDate
5289 
     - endDate
5290 
    """
5291 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5292 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5293 
 
5031 varun.gupt 5294 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5295 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5296 
    args = getStatusDistributionOfOrders_args()
5297 
    args.startDate = startDate
5298 
    args.endDate = endDate
5299 
    args.write(self._oprot)
5300 
    self._oprot.writeMessageEnd()
5301 
    self._oprot.trans.flush()
5302 
 
5303 
  def recv_getStatusDistributionOfOrders(self, ):
5304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5305 
    if mtype == TMessageType.EXCEPTION:
5306 
      x = TApplicationException()
5307 
      x.read(self._iprot)
5308 
      self._iprot.readMessageEnd()
5309 
      raise x
5310 
    result = getStatusDistributionOfOrders_result()
5311 
    result.read(self._iprot)
5312 
    self._iprot.readMessageEnd()
5313 
    if result.success is not None:
5314 
      return result.success
5315 
    if result.ex is not None:
5316 
      raise result.ex
5317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5318 
 
5067 varun.gupt 5319 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5320 
    """
5321 
    Parameters:
5322 
     - status
5323 
     - startDatetime
5324 
     - endDatetime
5325 
    """
5326 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5327 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5328 
 
5067 varun.gupt 5329 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5330 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5331 
    args = getOrderIdsForStatus_args()
5332 
    args.status = status
5333 
    args.startDatetime = startDatetime
5334 
    args.endDatetime = endDatetime
5335 
    args.write(self._oprot)
5336 
    self._oprot.writeMessageEnd()
5337 
    self._oprot.trans.flush()
5338 
 
5339 
  def recv_getOrderIdsForStatus(self, ):
5340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5341 
    if mtype == TMessageType.EXCEPTION:
5342 
      x = TApplicationException()
5343 
      x.read(self._iprot)
5344 
      self._iprot.readMessageEnd()
5345 
      raise x
5346 
    result = getOrderIdsForStatus_result()
5347 
    result.read(self._iprot)
5348 
    self._iprot.readMessageEnd()
5349 
    if result.success is not None:
5350 
      return result.success
5351 
    if result.ex is not None:
5352 
      raise result.ex
5353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5354 
 
5348 anupam.sin 5355 
  def updateCODAgent(self, agent, orderId):
5356 
    """
5357 
    Updates the agent who handled the COD verification call
5358 
 
5359 
    Parameters:
5360 
     - agent
5361 
     - orderId
5362 
    """
5363 
    self.send_updateCODAgent(agent, orderId)
5364 
    self.recv_updateCODAgent()
5365 
 
5366 
  def send_updateCODAgent(self, agent, orderId):
5367 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5368 
    args = updateCODAgent_args()
5369 
    args.agent = agent
5370 
    args.orderId = orderId
5371 
    args.write(self._oprot)
5372 
    self._oprot.writeMessageEnd()
5373 
    self._oprot.trans.flush()
5374 
 
5375 
  def recv_updateCODAgent(self, ):
5376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5377 
    if mtype == TMessageType.EXCEPTION:
5378 
      x = TApplicationException()
5379 
      x.read(self._iprot)
5380 
      self._iprot.readMessageEnd()
5381 
      raise x
5382 
    result = updateCODAgent_result()
5383 
    result.read(self._iprot)
5384 
    self._iprot.readMessageEnd()
5385 
    if result.ex is not None:
5386 
      raise result.ex
5387 
    return
5388 
 
5099 varun.gupt 5389 
  def updateOrderAsPaidToVendor(self, orderId):
5390 
    """
5391 
    Parameters:
5392 
     - orderId
5393 
    """
5394 
    self.send_updateOrderAsPaidToVendor(orderId)
5395 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5396 
 
5099 varun.gupt 5397 
  def send_updateOrderAsPaidToVendor(self, orderId):
5398 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5399 
    args = updateOrderAsPaidToVendor_args()
5400 
    args.orderId = orderId
5401 
    args.write(self._oprot)
5402 
    self._oprot.writeMessageEnd()
5403 
    self._oprot.trans.flush()
5404 
 
5405 
  def recv_updateOrderAsPaidToVendor(self, ):
5406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5407 
    if mtype == TMessageType.EXCEPTION:
5408 
      x = TApplicationException()
5409 
      x.read(self._iprot)
5410 
      self._iprot.readMessageEnd()
5411 
      raise x
5412 
    result = updateOrderAsPaidToVendor_result()
5413 
    result.read(self._iprot)
5414 
    self._iprot.readMessageEnd()
5415 
    if result.ex is not None:
5416 
      raise result.ex
5417 
    return
5418 
 
5386 phani.kuma 5419 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5420 
    """
5421 
    Parameters:
5422 
     - orderId
5423 
    """
5424 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5425 
    self.recv_updateOrderOnlyAsPaidToVendor()
5426 
 
5427 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5428 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5429 
    args = updateOrderOnlyAsPaidToVendor_args()
5430 
    args.orderId = orderId
5431 
    args.write(self._oprot)
5432 
    self._oprot.writeMessageEnd()
5433 
    self._oprot.trans.flush()
5434 
 
5435 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5437 
    if mtype == TMessageType.EXCEPTION:
5438 
      x = TApplicationException()
5439 
      x.read(self._iprot)
5440 
      self._iprot.readMessageEnd()
5441 
      raise x
5442 
    result = updateOrderOnlyAsPaidToVendor_result()
5443 
    result.read(self._iprot)
5444 
    self._iprot.readMessageEnd()
5445 
    if result.ex is not None:
5446 
      raise result.ex
5447 
    return
5448 
 
5208 varun.gupt 5449 
  def getRefundedOrdersMarkedPaid(self, ):
5450 
    self.send_getRefundedOrdersMarkedPaid()
5451 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5452 
 
5208 varun.gupt 5453 
  def send_getRefundedOrdersMarkedPaid(self, ):
5454 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5455 
    args = getRefundedOrdersMarkedPaid_args()
5456 
    args.write(self._oprot)
5457 
    self._oprot.writeMessageEnd()
5458 
    self._oprot.trans.flush()
5459 
 
5460 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5462 
    if mtype == TMessageType.EXCEPTION:
5463 
      x = TApplicationException()
5464 
      x.read(self._iprot)
5465 
      self._iprot.readMessageEnd()
5466 
      raise x
5467 
    result = getRefundedOrdersMarkedPaid_result()
5468 
    result.read(self._iprot)
5469 
    self._iprot.readMessageEnd()
5470 
    if result.success is not None:
5471 
      return result.success
5472 
    if result.ex is not None:
5473 
      raise result.ex
5474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5475 
 
5447 anupam.sin 5476 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5477 
    """
5478 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5479 
 
5447 anupam.sin 5480 
 
5481 
    Parameters:
5482 
     - minOrderId
5483 
     - maxOrderId
5484 
    """
5485 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5486 
    return self.recv_getAllVerificationAgents()
5487 
 
5488 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5489 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5490 
    args = getAllVerificationAgents_args()
5491 
    args.minOrderId = minOrderId
5492 
    args.maxOrderId = maxOrderId
5493 
    args.write(self._oprot)
5494 
    self._oprot.writeMessageEnd()
5495 
    self._oprot.trans.flush()
5496 
 
5497 
  def recv_getAllVerificationAgents(self, ):
5498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5499 
    if mtype == TMessageType.EXCEPTION:
5500 
      x = TApplicationException()
5501 
      x.read(self._iprot)
5502 
      self._iprot.readMessageEnd()
5503 
      raise x
5504 
    result = getAllVerificationAgents_result()
5505 
    result.read(self._iprot)
5506 
    self._iprot.readMessageEnd()
5507 
    if result.success is not None:
5508 
      return result.success
5509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5510 
 
5527 anupam.sin 5511 
  def getAllAttributesForOrderId(self, orderId):
5512 
    """
5513 
    gets all attributes for a given orderId
5447 anupam.sin 5514 
 
5527 anupam.sin 5515 
    Parameters:
5516 
     - orderId
5517 
    """
5518 
    self.send_getAllAttributesForOrderId(orderId)
5519 
    return self.recv_getAllAttributesForOrderId()
5520 
 
5521 
  def send_getAllAttributesForOrderId(self, orderId):
5522 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5523 
    args = getAllAttributesForOrderId_args()
5524 
    args.orderId = orderId
5525 
    args.write(self._oprot)
5526 
    self._oprot.writeMessageEnd()
5527 
    self._oprot.trans.flush()
5528 
 
5529 
  def recv_getAllAttributesForOrderId(self, ):
5530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5531 
    if mtype == TMessageType.EXCEPTION:
5532 
      x = TApplicationException()
5533 
      x.read(self._iprot)
5534 
      self._iprot.readMessageEnd()
5535 
      raise x
5536 
    result = getAllAttributesForOrderId_result()
5537 
    result.read(self._iprot)
5538 
    self._iprot.readMessageEnd()
5539 
    if result.success is not None:
5540 
      return result.success
5541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5542 
 
5676 rajveer 5543 
  def setOrderAttributes(self, orderId, attributes):
5544 
    """
5545 
    sets attributes for an order
5546 
 
5547 
    Parameters:
5548 
     - orderId
5549 
     - attributes
5550 
    """
5551 
    self.send_setOrderAttributes(orderId, attributes)
5552 
    self.recv_setOrderAttributes()
5553 
 
5554 
  def send_setOrderAttributes(self, orderId, attributes):
5555 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5556 
    args = setOrderAttributes_args()
5557 
    args.orderId = orderId
5558 
    args.attributes = attributes
5559 
    args.write(self._oprot)
5560 
    self._oprot.writeMessageEnd()
5561 
    self._oprot.trans.flush()
5562 
 
5563 
  def recv_setOrderAttributes(self, ):
5564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5565 
    if mtype == TMessageType.EXCEPTION:
5566 
      x = TApplicationException()
5567 
      x.read(self._iprot)
5568 
      self._iprot.readMessageEnd()
5569 
      raise x
5570 
    result = setOrderAttributes_result()
5571 
    result.read(self._iprot)
5572 
    self._iprot.readMessageEnd()
5573 
    return
5574 
 
5527 anupam.sin 5575 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5576 
    """
5577 
    sets attributes for all orders in a transaction
5578 
 
5579 
    Parameters:
5580 
     - transactionId
5581 
     - attribute
5582 
    """
5583 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5584 
    self.recv_setOrderAttributeForTransaction()
5585 
 
5586 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5587 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5588 
    args = setOrderAttributeForTransaction_args()
5589 
    args.transactionId = transactionId
5590 
    args.attribute = attribute
5591 
    args.write(self._oprot)
5592 
    self._oprot.writeMessageEnd()
5593 
    self._oprot.trans.flush()
5594 
 
5595 
  def recv_setOrderAttributeForTransaction(self, ):
5596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5597 
    if mtype == TMessageType.EXCEPTION:
5598 
      x = TApplicationException()
5599 
      x.read(self._iprot)
5600 
      self._iprot.readMessageEnd()
5601 
      raise x
5602 
    result = setOrderAttributeForTransaction_result()
5603 
    result.read(self._iprot)
5604 
    self._iprot.readMessageEnd()
5605 
    return
5606 
 
5553 rajveer 5607 
  def getReceivePendingOrders(self, storeId):
5608 
    """
5609 
    Parameters:
5610 
     - storeId
5611 
    """
5612 
    self.send_getReceivePendingOrders(storeId)
5613 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5614 
 
5553 rajveer 5615 
  def send_getReceivePendingOrders(self, storeId):
5616 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5617 
    args = getReceivePendingOrders_args()
5618 
    args.storeId = storeId
5619 
    args.write(self._oprot)
5620 
    self._oprot.writeMessageEnd()
5621 
    self._oprot.trans.flush()
5622 
 
5623 
  def recv_getReceivePendingOrders(self, ):
5624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5625 
    if mtype == TMessageType.EXCEPTION:
5626 
      x = TApplicationException()
5627 
      x.read(self._iprot)
5628 
      self._iprot.readMessageEnd()
5629 
      raise x
5630 
    result = getReceivePendingOrders_result()
5631 
    result.read(self._iprot)
5632 
    self._iprot.readMessageEnd()
5633 
    if result.success is not None:
5634 
      return result.success
5635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5636 
 
5637 
  def getReceivedAtStoreOrders(self, storeId):
5638 
    """
5639 
    Parameters:
5640 
     - storeId
5641 
    """
5642 
    self.send_getReceivedAtStoreOrders(storeId)
5643 
    return self.recv_getReceivedAtStoreOrders()
5644 
 
5645 
  def send_getReceivedAtStoreOrders(self, storeId):
5646 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5647 
    args = getReceivedAtStoreOrders_args()
5648 
    args.storeId = storeId
5649 
    args.write(self._oprot)
5650 
    self._oprot.writeMessageEnd()
5651 
    self._oprot.trans.flush()
5652 
 
5653 
  def recv_getReceivedAtStoreOrders(self, ):
5654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5655 
    if mtype == TMessageType.EXCEPTION:
5656 
      x = TApplicationException()
5657 
      x.read(self._iprot)
5658 
      self._iprot.readMessageEnd()
5659 
      raise x
5660 
    result = getReceivedAtStoreOrders_result()
5661 
    result.read(self._iprot)
5662 
    self._iprot.readMessageEnd()
5663 
    if result.success is not None:
5664 
      return result.success
5665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5666 
 
5713 rajveer 5667 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5668 
    """
5669 
    Parameters:
5670 
     - storeId
5671 
     - fromDate
5672 
     - toDate
5673 
     - onlyCod
5674 
    """
5675 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5676 
    return self.recv_getOrdersCollectionAtStore()
5677 
 
5678 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5679 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5680 
    args = getOrdersCollectionAtStore_args()
5681 
    args.storeId = storeId
5682 
    args.fromDate = fromDate
5683 
    args.toDate = toDate
5684 
    args.onlyCod = onlyCod
5685 
    args.write(self._oprot)
5686 
    self._oprot.writeMessageEnd()
5687 
    self._oprot.trans.flush()
5688 
 
5689 
  def recv_getOrdersCollectionAtStore(self, ):
5690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5691 
    if mtype == TMessageType.EXCEPTION:
5692 
      x = TApplicationException()
5693 
      x.read(self._iprot)
5694 
      self._iprot.readMessageEnd()
5695 
      raise x
5696 
    result = getOrdersCollectionAtStore_result()
5697 
    result.read(self._iprot)
5698 
    self._iprot.readMessageEnd()
5699 
    if result.success is not None:
5700 
      return result.success
5701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5702 
 
5833 rajveer 5703 
  def getOrderAttributeValue(self, orderId, attributeName):
5704 
    """
5705 
    Parameters:
5706 
     - orderId
5707 
     - attributeName
5708 
    """
5709 
    self.send_getOrderAttributeValue(orderId, attributeName)
5710 
    return self.recv_getOrderAttributeValue()
5711 
 
5712 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5713 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5714 
    args = getOrderAttributeValue_args()
5715 
    args.orderId = orderId
5716 
    args.attributeName = attributeName
5717 
    args.write(self._oprot)
5718 
    self._oprot.writeMessageEnd()
5719 
    self._oprot.trans.flush()
5720 
 
5721 
  def recv_getOrderAttributeValue(self, ):
5722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5723 
    if mtype == TMessageType.EXCEPTION:
5724 
      x = TApplicationException()
5725 
      x.read(self._iprot)
5726 
      self._iprot.readMessageEnd()
5727 
      raise x
5728 
    result = getOrderAttributeValue_result()
5729 
    result.read(self._iprot)
5730 
    self._iprot.readMessageEnd()
5731 
    if result.success is not None:
5732 
      return result.success
5733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5734 
 
6019 rajveer 5735 
  def changeJacketNumber(self, orderId, jacketNumber):
5736 
    """
5737 
    Parameters:
5738 
     - orderId
5739 
     - jacketNumber
5740 
    """
5741 
    self.send_changeJacketNumber(orderId, jacketNumber)
5742 
    return self.recv_changeJacketNumber()
5743 
 
5744 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5745 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5746 
    args = changeJacketNumber_args()
5747 
    args.orderId = orderId
5748 
    args.jacketNumber = jacketNumber
5749 
    args.write(self._oprot)
5750 
    self._oprot.writeMessageEnd()
5751 
    self._oprot.trans.flush()
5752 
 
5753 
  def recv_changeJacketNumber(self, ):
5754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5755 
    if mtype == TMessageType.EXCEPTION:
5756 
      x = TApplicationException()
5757 
      x.read(self._iprot)
5758 
      self._iprot.readMessageEnd()
5759 
      raise x
5760 
    result = changeJacketNumber_result()
5761 
    result.read(self._iprot)
5762 
    self._iprot.readMessageEnd()
5763 
    if result.success is not None:
5764 
      return result.success
5765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5766 
 
5767 
  def markOrderAsRtoInTransit(self, orderId):
5768 
    """
5769 
    Parameters:
5770 
     - orderId
5771 
    """
5772 
    self.send_markOrderAsRtoInTransit(orderId)
5773 
    return self.recv_markOrderAsRtoInTransit()
5774 
 
5775 
  def send_markOrderAsRtoInTransit(self, orderId):
5776 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5777 
    args = markOrderAsRtoInTransit_args()
5778 
    args.orderId = orderId
5779 
    args.write(self._oprot)
5780 
    self._oprot.writeMessageEnd()
5781 
    self._oprot.trans.flush()
5782 
 
5783 
  def recv_markOrderAsRtoInTransit(self, ):
5784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5785 
    if mtype == TMessageType.EXCEPTION:
5786 
      x = TApplicationException()
5787 
      x.read(self._iprot)
5788 
      self._iprot.readMessageEnd()
5789 
      raise x
5790 
    result = markOrderAsRtoInTransit_result()
5791 
    result.read(self._iprot)
5792 
    self._iprot.readMessageEnd()
5793 
    if result.success is not None:
5794 
      return result.success
5795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5796 
 
5593 mandeep.dh 5797 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5798 
    """
5799 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5800 
    invoked while scanning IN of items.
5553 rajveer 5801 
 
5593 mandeep.dh 5802 
    Parameters:
5803 
     - itemId
5804 
     - quantity
5805 
     - fulfilmentWarehouseId
5806 
     - billingWarehouseId
5807 
    """
5808 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5809 
    self.recv_acceptOrderForItem()
5810 
 
5811 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5812 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5813 
    args = acceptOrderForItem_args()
5814 
    args.itemId = itemId
5815 
    args.quantity = quantity
5816 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5817 
    args.billingWarehouseId = billingWarehouseId
5818 
    args.write(self._oprot)
5819 
    self._oprot.writeMessageEnd()
5820 
    self._oprot.trans.flush()
5821 
 
5822 
  def recv_acceptOrderForItem(self, ):
5823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5824 
    if mtype == TMessageType.EXCEPTION:
5825 
      x = TApplicationException()
5826 
      x.read(self._iprot)
5827 
      self._iprot.readMessageEnd()
5828 
      raise x
5829 
    result = acceptOrderForItem_result()
5830 
    result.read(self._iprot)
5831 
    self._iprot.readMessageEnd()
5832 
    return
5833 
 
6000 mandeep.dh 5834 
  def createRechargeOrder(self, rechargeOrder):
5835 
    """
5836 
    Parameters:
5837 
     - rechargeOrder
5838 
    """
5839 
    self.send_createRechargeOrder(rechargeOrder)
5840 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5841 
 
6000 mandeep.dh 5842 
  def send_createRechargeOrder(self, rechargeOrder):
5843 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5844 
    args = createRechargeOrder_args()
5845 
    args.rechargeOrder = rechargeOrder
5846 
    args.write(self._oprot)
5847 
    self._oprot.writeMessageEnd()
5848 
    self._oprot.trans.flush()
5849 
 
5850 
  def recv_createRechargeOrder(self, ):
5851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5852 
    if mtype == TMessageType.EXCEPTION:
5853 
      x = TApplicationException()
5854 
      x.read(self._iprot)
5855 
      self._iprot.readMessageEnd()
5856 
      raise x
5857 
    result = createRechargeOrder_result()
5858 
    result.read(self._iprot)
5859 
    self._iprot.readMessageEnd()
5860 
    if result.success is not None:
5861 
      return result.success
5862 
    if result.ex is not None:
5863 
      raise result.ex
5864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5865 
 
6031 rajveer 5866 
  def getRechargeOrder(self, rechargeRrderId):
5867 
    """
5868 
    Parameters:
5869 
     - rechargeRrderId
5870 
    """
5871 
    self.send_getRechargeOrder(rechargeRrderId)
5872 
    return self.recv_getRechargeOrder()
5873 
 
5874 
  def send_getRechargeOrder(self, rechargeRrderId):
5875 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5876 
    args = getRechargeOrder_args()
5877 
    args.rechargeRrderId = rechargeRrderId
5878 
    args.write(self._oprot)
5879 
    self._oprot.writeMessageEnd()
5880 
    self._oprot.trans.flush()
5881 
 
5882 
  def recv_getRechargeOrder(self, ):
5883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5884 
    if mtype == TMessageType.EXCEPTION:
5885 
      x = TApplicationException()
5886 
      x.read(self._iprot)
5887 
      self._iprot.readMessageEnd()
5888 
      raise x
5889 
    result = getRechargeOrder_result()
5890 
    result.read(self._iprot)
5891 
    self._iprot.readMessageEnd()
5892 
    if result.success is not None:
5893 
      return result.success
5894 
    if result.ex is not None:
5895 
      raise result.ex
5896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5897 
 
5898 
  def getRechargeOrders(self, userId):
5899 
    """
5900 
    Parameters:
5901 
     - userId
5902 
    """
5903 
    self.send_getRechargeOrders(userId)
5904 
    return self.recv_getRechargeOrders()
5905 
 
5906 
  def send_getRechargeOrders(self, userId):
5907 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5908 
    args = getRechargeOrders_args()
5909 
    args.userId = userId
5910 
    args.write(self._oprot)
5911 
    self._oprot.writeMessageEnd()
5912 
    self._oprot.trans.flush()
5913 
 
5914 
  def recv_getRechargeOrders(self, ):
5915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5916 
    if mtype == TMessageType.EXCEPTION:
5917 
      x = TApplicationException()
5918 
      x.read(self._iprot)
5919 
      self._iprot.readMessageEnd()
5920 
      raise x
5921 
    result = getRechargeOrders_result()
5922 
    result.read(self._iprot)
5923 
    self._iprot.readMessageEnd()
5924 
    if result.success is not None:
5925 
      return result.success
5926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5927 
 
6000 mandeep.dh 5928 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5929 
    """
5930 
    Parameters:
5931 
     - rechargeOrderId
5932 
     - rechargeOrderStatus
5933 
    """
5934 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5935 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5936 
 
5937 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5938 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5939 
    args = updateRechargeOrderStatus_args()
5940 
    args.rechargeOrderId = rechargeOrderId
5941 
    args.rechargeOrderStatus = rechargeOrderStatus
5942 
    args.write(self._oprot)
5943 
    self._oprot.writeMessageEnd()
5944 
    self._oprot.trans.flush()
5945 
 
5946 
  def recv_updateRechargeOrderStatus(self, ):
5947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5948 
    if mtype == TMessageType.EXCEPTION:
5949 
      x = TApplicationException()
5950 
      x.read(self._iprot)
5951 
      self._iprot.readMessageEnd()
5952 
      raise x
5953 
    result = updateRechargeOrderStatus_result()
5954 
    result.read(self._iprot)
5955 
    self._iprot.readMessageEnd()
6031 rajveer 5956 
    if result.success is not None:
5957 
      return result.success
6000 mandeep.dh 5958 
    if result.ex is not None:
5959 
      raise result.ex
6031 rajveer 5960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5961 
 
6031 rajveer 5962 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5963 
    """
5964 
    Parameters:
6031 rajveer 5965 
     - rechargeOrderId
6000 mandeep.dh 5966 
    """
6031 rajveer 5967 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5968 
    return self.recv_activateRechargeTxn()
5969 
 
6031 rajveer 5970 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5971 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5972 
    args = activateRechargeTxn_args()
6031 rajveer 5973 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5974 
    args.write(self._oprot)
5975 
    self._oprot.writeMessageEnd()
5976 
    self._oprot.trans.flush()
5977 
 
5978 
  def recv_activateRechargeTxn(self, ):
5979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5980 
    if mtype == TMessageType.EXCEPTION:
5981 
      x = TApplicationException()
5982 
      x.read(self._iprot)
5983 
      self._iprot.readMessageEnd()
5984 
      raise x
5985 
    result = activateRechargeTxn_result()
5986 
    result.read(self._iprot)
5987 
    self._iprot.readMessageEnd()
5988 
    if result.success is not None:
5989 
      return result.success
5990 
    if result.ex is not None:
5991 
      raise result.ex
5992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5993 
 
6031 rajveer 5994 
  def getUserWallet(self, userId):
6000 mandeep.dh 5995 
    """
5996 
    Parameters:
6031 rajveer 5997 
     - userId
6000 mandeep.dh 5998 
    """
6031 rajveer 5999 
    self.send_getUserWallet(userId)
6000 
    return self.recv_getUserWallet()
6000 mandeep.dh 6001 
 
6031 rajveer 6002 
  def send_getUserWallet(self, userId):
6003 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6004 
    args = getUserWallet_args()
6005 
    args.userId = userId
6000 mandeep.dh 6006 
    args.write(self._oprot)
6007 
    self._oprot.writeMessageEnd()
6008 
    self._oprot.trans.flush()
6009 
 
6031 rajveer 6010 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6012 
    if mtype == TMessageType.EXCEPTION:
6013 
      x = TApplicationException()
6014 
      x.read(self._iprot)
6015 
      self._iprot.readMessageEnd()
6016 
      raise x
6031 rajveer 6017 
    result = getUserWallet_result()
6000 mandeep.dh 6018 
    result.read(self._iprot)
6019 
    self._iprot.readMessageEnd()
6020 
    if result.success is not None:
6021 
      return result.success
6031 rajveer 6022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6023 
 
6031 rajveer 6024 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6025 
    """
6026 
    Parameters:
6031 rajveer 6027 
     - userId
6000 mandeep.dh 6028 
    """
6031 rajveer 6029 
    self.send_getUserWalletHistory(userId)
6030 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6031 
 
6031 rajveer 6032 
  def send_getUserWalletHistory(self, userId):
6033 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6034 
    args = getUserWalletHistory_args()
6035 
    args.userId = userId
6000 mandeep.dh 6036 
    args.write(self._oprot)
6037 
    self._oprot.writeMessageEnd()
6038 
    self._oprot.trans.flush()
6039 
 
6031 rajveer 6040 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6042 
    if mtype == TMessageType.EXCEPTION:
6043 
      x = TApplicationException()
6044 
      x.read(self._iprot)
6045 
      self._iprot.readMessageEnd()
6046 
      raise x
6031 rajveer 6047 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6048 
    result.read(self._iprot)
6049 
    self._iprot.readMessageEnd()
6050 
    if result.success is not None:
6051 
      return result.success
6031 rajveer 6052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6053 
 
6050 anupam.sin 6054 
  def getRechargeOrdersForTransaction(self, txnId):
6055 
    """
6056 
    Returns a recharge order for a given transactionId
6057 
 
6058 
    Parameters:
6059 
     - txnId
6060 
    """
6061 
    self.send_getRechargeOrdersForTransaction(txnId)
6062 
    return self.recv_getRechargeOrdersForTransaction()
6063 
 
6064 
  def send_getRechargeOrdersForTransaction(self, txnId):
6065 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6066 
    args = getRechargeOrdersForTransaction_args()
6067 
    args.txnId = txnId
6068 
    args.write(self._oprot)
6069 
    self._oprot.writeMessageEnd()
6070 
    self._oprot.trans.flush()
6071 
 
6072 
  def recv_getRechargeOrdersForTransaction(self, ):
6073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6074 
    if mtype == TMessageType.EXCEPTION:
6075 
      x = TApplicationException()
6076 
      x.read(self._iprot)
6077 
      self._iprot.readMessageEnd()
6078 
      raise x
6079 
    result = getRechargeOrdersForTransaction_result()
6080 
    result.read(self._iprot)
6081 
    self._iprot.readMessageEnd()
6082 
    if result.success is not None:
6083 
      return result.success
6084 
    if result.ex is not None:
6085 
      raise result.ex
6086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6087 
 
6048 rajveer 6088 
  def getServiceProviders(self, rechargeType):
6089 
    """
6090 
    Parameters:
6091 
     - rechargeType
6092 
    """
6093 
    self.send_getServiceProviders(rechargeType)
6094 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6095 
 
6048 rajveer 6096 
  def send_getServiceProviders(self, rechargeType):
6097 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6098 
    args = getServiceProviders_args()
6099 
    args.rechargeType = rechargeType
6100 
    args.write(self._oprot)
6101 
    self._oprot.writeMessageEnd()
6102 
    self._oprot.trans.flush()
6103 
 
6104 
  def recv_getServiceProviders(self, ):
6105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6106 
    if mtype == TMessageType.EXCEPTION:
6107 
      x = TApplicationException()
6108 
      x.read(self._iprot)
6109 
      self._iprot.readMessageEnd()
6110 
      raise x
6111 
    result = getServiceProviders_result()
6112 
    result.read(self._iprot)
6113 
    self._iprot.readMessageEnd()
6114 
    if result.success is not None:
6115 
      return result.success
6116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6117 
 
6049 rajveer 6118 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6119 
    """
6120 
    Parameters:
6049 rajveer 6121 
     - rechargeType
6048 rajveer 6122 
     - deviceNumber
6123 
    """
6049 rajveer 6124 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6125 
    return self.recv_getServiceProviderForDevice()
6126 
 
6049 rajveer 6127 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6128 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6129 
    args = getServiceProviderForDevice_args()
6049 rajveer 6130 
    args.rechargeType = rechargeType
6048 rajveer 6131 
    args.deviceNumber = deviceNumber
6132 
    args.write(self._oprot)
6133 
    self._oprot.writeMessageEnd()
6134 
    self._oprot.trans.flush()
6135 
 
6136 
  def recv_getServiceProviderForDevice(self, ):
6137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6138 
    if mtype == TMessageType.EXCEPTION:
6139 
      x = TApplicationException()
6140 
      x.read(self._iprot)
6141 
      self._iprot.readMessageEnd()
6142 
      raise x
6143 
    result = getServiceProviderForDevice_result()
6144 
    result.read(self._iprot)
6145 
    self._iprot.readMessageEnd()
6146 
    if result.success is not None:
6147 
      return result.success
6148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6149 
 
6094 rajveer 6150 
  def getRechargeOrdersForDevice(self, deviceNumber):
6151 
    """
6152 
    Parameters:
6153 
     - deviceNumber
6154 
    """
6155 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6156 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6157 
 
6094 rajveer 6158 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6159 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6160 
    args = getRechargeOrdersForDevice_args()
6161 
    args.deviceNumber = deviceNumber
6162 
    args.write(self._oprot)
6163 
    self._oprot.writeMessageEnd()
6164 
    self._oprot.trans.flush()
6165 
 
6166 
  def recv_getRechargeOrdersForDevice(self, ):
6167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6168 
    if mtype == TMessageType.EXCEPTION:
6169 
      x = TApplicationException()
6170 
      x.read(self._iprot)
6171 
      self._iprot.readMessageEnd()
6172 
      raise x
6173 
    result = getRechargeOrdersForDevice_result()
6174 
    result.read(self._iprot)
6175 
    self._iprot.readMessageEnd()
6176 
    if result.success is not None:
6177 
      return result.success
6178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6179 
 
6180 
  def addAmountToWallet(self, userId, orderId, amount):
6181 
    """
6182 
    Parameters:
6183 
     - userId
6184 
     - orderId
6185 
     - amount
6186 
    """
6187 
    self.send_addAmountToWallet(userId, orderId, amount)
6188 
    self.recv_addAmountToWallet()
6189 
 
6190 
  def send_addAmountToWallet(self, userId, orderId, amount):
6191 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6192 
    args = addAmountToWallet_args()
6193 
    args.userId = userId
6194 
    args.orderId = orderId
6195 
    args.amount = amount
6196 
    args.write(self._oprot)
6197 
    self._oprot.writeMessageEnd()
6198 
    self._oprot.trans.flush()
6199 
 
6200 
  def recv_addAmountToWallet(self, ):
6201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6202 
    if mtype == TMessageType.EXCEPTION:
6203 
      x = TApplicationException()
6204 
      x.read(self._iprot)
6205 
      self._iprot.readMessageEnd()
6206 
      raise x
6207 
    result = addAmountToWallet_result()
6208 
    result.read(self._iprot)
6209 
    self._iprot.readMessageEnd()
6210 
    return
6211 
 
6154 rajveer 6212 
  def getRechargeOrdersForStatus(self, status):
6213 
    """
6214 
    Parameters:
6215 
     - status
6216 
    """
6217 
    self.send_getRechargeOrdersForStatus(status)
6218 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6219 
 
6154 rajveer 6220 
  def send_getRechargeOrdersForStatus(self, status):
6221 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6222 
    args = getRechargeOrdersForStatus_args()
6223 
    args.status = status
6224 
    args.write(self._oprot)
6225 
    self._oprot.writeMessageEnd()
6226 
    self._oprot.trans.flush()
6227 
 
6228 
  def recv_getRechargeOrdersForStatus(self, ):
6229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6230 
    if mtype == TMessageType.EXCEPTION:
6231 
      x = TApplicationException()
6232 
      x.read(self._iprot)
6233 
      self._iprot.readMessageEnd()
6234 
      raise x
6235 
    result = getRechargeOrdersForStatus_result()
6236 
    result.read(self._iprot)
6237 
    self._iprot.readMessageEnd()
6238 
    if result.success is not None:
6239 
      return result.success
6240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6241 
 
6159 rajveer 6242 
  def getPlansForOperator(self, operatorId):
6243 
    """
6244 
    Parameters:
6245 
     - operatorId
6246 
    """
6247 
    self.send_getPlansForOperator(operatorId)
6248 
    return self.recv_getPlansForOperator()
6154 rajveer 6249 
 
6159 rajveer 6250 
  def send_getPlansForOperator(self, operatorId):
6251 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6252 
    args = getPlansForOperator_args()
6253 
    args.operatorId = operatorId
6254 
    args.write(self._oprot)
6255 
    self._oprot.writeMessageEnd()
6256 
    self._oprot.trans.flush()
6257 
 
6258 
  def recv_getPlansForOperator(self, ):
6259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6260 
    if mtype == TMessageType.EXCEPTION:
6261 
      x = TApplicationException()
6262 
      x.read(self._iprot)
6263 
      self._iprot.readMessageEnd()
6264 
      raise x
6265 
    result = getPlansForOperator_result()
6266 
    result.read(self._iprot)
6267 
    self._iprot.readMessageEnd()
6268 
    if result.success is not None:
6269 
      return result.success
6270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6271 
 
6272 
 
3376 rajveer 6273 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6274 
  def __init__(self, handler):
3376 rajveer 6275 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6276 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6277 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6278 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6279 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6280 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6281 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6282 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6283 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6284 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6285 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6286 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6287 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6288 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6289 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6290 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6291 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6292 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6293 
    self._processMap["createOrder"] = Processor.process_createOrder
6294 
    self._processMap["getOrder"] = Processor.process_getOrder
6295 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6296 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6297 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6298 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6299 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6300 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6301 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6302 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6303 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6304 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6305 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6306 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6307 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6308 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6309 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6310 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6311 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6312 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6313 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6314 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6315 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6316 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6317 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6318 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6319 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6320 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6321 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6322 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6323 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6324 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6325 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6326 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6327 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6328 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6329 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6330 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6331 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6332 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6333 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6334 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6335 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6336 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6337 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6338 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6339 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6340 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6341 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6342 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6343 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6344 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6345 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6346 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6347 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6348 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6349 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6350 
    self._processMap["changeItem"] = Processor.process_changeItem
6351 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6352 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6353 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6354 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6355 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6356 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6357 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6358 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6359 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6360 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6361 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6362 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6363 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6364 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6365 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6366 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6367 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6368 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6369 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6370 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6371 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6372 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6373 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6374 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6375 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6376 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6377 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6378 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6379 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6380 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6381 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6382 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6383 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6384 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6385 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6386 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6387 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6388 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6389 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6390 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6391 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6392 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6393 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6394 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6395 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6396 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6397 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6398 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6399 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6400 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6401 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6402 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6403 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6404 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6405 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6406 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6407 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6408 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6409 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6410 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6411 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6412 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6094 rajveer 6413 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6414 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6154 rajveer 6415 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6416 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
94 ashish 6417 
 
6418 
  def process(self, iprot, oprot):
6419 
    (name, type, seqid) = iprot.readMessageBegin()
6420 
    if name not in self._processMap:
6421 
      iprot.skip(TType.STRUCT)
6422 
      iprot.readMessageEnd()
6423 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6424 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6425 
      x.write(oprot)
6426 
      oprot.writeMessageEnd()
6427 
      oprot.trans.flush()
6428 
      return
6429 
    else:
6430 
      self._processMap[name](self, seqid, iprot, oprot)
6431 
    return True
6432 
 
6433 
  def process_createTransaction(self, seqid, iprot, oprot):
6434 
    args = createTransaction_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = createTransaction_result()
6438 
    try:
132 ashish 6439 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6440 
    except TransactionServiceException, ex:
6441 
      result.ex = ex
6442 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6443 
    result.write(oprot)
6444 
    oprot.writeMessageEnd()
6445 
    oprot.trans.flush()
6446 
 
6447 
  def process_getTransaction(self, seqid, iprot, oprot):
6448 
    args = getTransaction_args()
6449 
    args.read(iprot)
6450 
    iprot.readMessageEnd()
6451 
    result = getTransaction_result()
6452 
    try:
6453 
      result.success = self._handler.getTransaction(args.id)
6454 
    except TransactionServiceException, ex:
6455 
      result.ex = ex
6456 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6457 
    result.write(oprot)
6458 
    oprot.writeMessageEnd()
6459 
    oprot.trans.flush()
6460 
 
6461 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6462 
    args = getTransactionsForCustomer_args()
6463 
    args.read(iprot)
6464 
    iprot.readMessageEnd()
6465 
    result = getTransactionsForCustomer_result()
6466 
    try:
6467 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6468 
    except TransactionServiceException, ex:
6469 
      result.ex = ex
6470 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6471 
    result.write(oprot)
6472 
    oprot.writeMessageEnd()
6473 
    oprot.trans.flush()
6474 
 
132 ashish 6475 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6476 
    args = getTransactionsForShoppingCartId_args()
6477 
    args.read(iprot)
6478 
    iprot.readMessageEnd()
6479 
    result = getTransactionsForShoppingCartId_result()
6480 
    try:
6481 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6482 
    except TransactionServiceException, ex:
6483 
      result.ex = ex
6484 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6485 
    result.write(oprot)
6486 
    oprot.writeMessageEnd()
6487 
    oprot.trans.flush()
6488 
 
94 ashish 6489 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6490 
    args = getTransactionStatus_args()
6491 
    args.read(iprot)
6492 
    iprot.readMessageEnd()
6493 
    result = getTransactionStatus_result()
6494 
    try:
6495 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6496 
    except TransactionServiceException, ex:
6497 
      result.ex = ex
6498 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6499 
    result.write(oprot)
6500 
    oprot.writeMessageEnd()
6501 
    oprot.trans.flush()
6502 
 
6503 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6504 
    args = changeTransactionStatus_args()
6505 
    args.read(iprot)
6506 
    iprot.readMessageEnd()
6507 
    result = changeTransactionStatus_result()
6508 
    try:
5527 anupam.sin 6509 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6510 
    except TransactionServiceException, ex:
6511 
      result.ex = ex
6512 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6513 
    result.write(oprot)
6514 
    oprot.writeMessageEnd()
6515 
    oprot.trans.flush()
6516 
 
1398 varun.gupt 6517 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6518 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6519 
    args.read(iprot)
6520 
    iprot.readMessageEnd()
1398 varun.gupt 6521 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6522 
    try:
1398 varun.gupt 6523 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6524 
    except TransactionServiceException, ex:
6525 
      result.ex = ex
1398 varun.gupt 6526 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6527 
    result.write(oprot)
6528 
    oprot.writeMessageEnd()
6529 
    oprot.trans.flush()
6530 
 
483 rajveer 6531 
  def process_getAllOrders(self, seqid, iprot, oprot):
6532 
    args = getAllOrders_args()
94 ashish 6533 
    args.read(iprot)
6534 
    iprot.readMessageEnd()
483 rajveer 6535 
    result = getAllOrders_result()
94 ashish 6536 
    try:
4801 anupam.sin 6537 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6538 
    except TransactionServiceException, ex:
6539 
      result.ex = ex
483 rajveer 6540 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6541 
    result.write(oprot)
6542 
    oprot.writeMessageEnd()
6543 
    oprot.trans.flush()
6544 
 
4133 chandransh 6545 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6546 
    args = getOrdersInBatch_args()
6547 
    args.read(iprot)
6548 
    iprot.readMessageEnd()
6549 
    result = getOrdersInBatch_result()
6550 
    try:
6551 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6552 
    except TransactionServiceException, ex:
6553 
      result.ex = ex
6554 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6555 
    result.write(oprot)
6556 
    oprot.writeMessageEnd()
6557 
    oprot.trans.flush()
6558 
 
6559 
  def process_getOrderCount(self, seqid, iprot, oprot):
6560 
    args = getOrderCount_args()
6561 
    args.read(iprot)
6562 
    iprot.readMessageEnd()
6563 
    result = getOrderCount_result()
6564 
    try:
6565 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6566 
    except TransactionServiceException, ex:
6567 
      result.ex = ex
6568 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6569 
    result.write(oprot)
6570 
    oprot.writeMessageEnd()
6571 
    oprot.trans.flush()
6572 
 
999 varun.gupt 6573 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6574 
    args = getOrdersByBillingDate_args()
6575 
    args.read(iprot)
6576 
    iprot.readMessageEnd()
6577 
    result = getOrdersByBillingDate_result()
6578 
    try:
6579 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6580 
    except TransactionServiceException, ex:
6581 
      result.ex = ex
6582 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
3427 chandransh 6587 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6588 
    args = getOrdersByShippingDate_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getOrdersByShippingDate_result()
6592 
    try:
3451 chandransh 6593 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6594 
    except TransactionServiceException, ex:
6595 
      result.ex = ex
6596 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
6600 
 
1382 varun.gupt 6601 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6602 
    args = getReturnableOrdersForCustomer_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getReturnableOrdersForCustomer_result()
6606 
    try:
6607 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6608 
    except TransactionServiceException, ex:
6609 
      result.ex = ex
6610 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
6614 
 
6615 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6616 
    args = getCancellableOrdersForCustomer_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getCancellableOrdersForCustomer_result()
6620 
    try:
6621 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6622 
    except TransactionServiceException, ex:
6623 
      result.ex = ex
6624 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6625 
    result.write(oprot)
6626 
    oprot.writeMessageEnd()
6627 
    oprot.trans.flush()
6628 
 
483 rajveer 6629 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6630 
    args = changeOrderStatus_args()
94 ashish 6631 
    args.read(iprot)
6632 
    iprot.readMessageEnd()
483 rajveer 6633 
    result = changeOrderStatus_result()
94 ashish 6634 
    try:
483 rajveer 6635 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6636 
    except TransactionServiceException, ex:
6637 
      result.ex = ex
483 rajveer 6638 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6639 
    result.write(oprot)
6640 
    oprot.writeMessageEnd()
6641 
    oprot.trans.flush()
6642 
 
483 rajveer 6643 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6644 
    args = getOrdersForTransaction_args()
94 ashish 6645 
    args.read(iprot)
6646 
    iprot.readMessageEnd()
483 rajveer 6647 
    result = getOrdersForTransaction_result()
94 ashish 6648 
    try:
1528 ankur.sing 6649 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6650 
    except TransactionServiceException, ex:
6651 
      result.ex = ex
483 rajveer 6652 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6653 
    result.write(oprot)
6654 
    oprot.writeMessageEnd()
6655 
    oprot.trans.flush()
6656 
 
483 rajveer 6657 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6658 
    args = getOrdersForCustomer_args()
94 ashish 6659 
    args.read(iprot)
6660 
    iprot.readMessageEnd()
483 rajveer 6661 
    result = getOrdersForCustomer_result()
94 ashish 6662 
    try:
3014 chandransh 6663 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6664 
    except TransactionServiceException, ex:
6665 
      result.ex = ex
483 rajveer 6666 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6667 
    result.write(oprot)
6668 
    oprot.writeMessageEnd()
6669 
    oprot.trans.flush()
6670 
 
483 rajveer 6671 
  def process_createOrder(self, seqid, iprot, oprot):
6672 
    args = createOrder_args()
94 ashish 6673 
    args.read(iprot)
6674 
    iprot.readMessageEnd()
483 rajveer 6675 
    result = createOrder_result()
94 ashish 6676 
    try:
483 rajveer 6677 
      result.success = self._handler.createOrder(args.order)
94 ashish 6678 
    except TransactionServiceException, ex:
6679 
      result.ex = ex
483 rajveer 6680 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6681 
    result.write(oprot)
6682 
    oprot.writeMessageEnd()
6683 
    oprot.trans.flush()
6684 
 
483 rajveer 6685 
  def process_getOrder(self, seqid, iprot, oprot):
6686 
    args = getOrder_args()
94 ashish 6687 
    args.read(iprot)
6688 
    iprot.readMessageEnd()
483 rajveer 6689 
    result = getOrder_result()
94 ashish 6690 
    try:
483 rajveer 6691 
      result.success = self._handler.getOrder(args.id)
94 ashish 6692 
    except TransactionServiceException, ex:
6693 
      result.ex = ex
483 rajveer 6694 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6695 
    result.write(oprot)
6696 
    oprot.writeMessageEnd()
6697 
    oprot.trans.flush()
6698 
 
483 rajveer 6699 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6700 
    args = getLineItemsForOrder_args()
94 ashish 6701 
    args.read(iprot)
6702 
    iprot.readMessageEnd()
483 rajveer 6703 
    result = getLineItemsForOrder_result()
94 ashish 6704 
    try:
483 rajveer 6705 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6706 
    except TransactionServiceException, ex:
6707 
      result.ex = ex
483 rajveer 6708 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6709 
    result.write(oprot)
6710 
    oprot.writeMessageEnd()
6711 
    oprot.trans.flush()
6712 
 
4999 phani.kuma 6713 
  def process_getOrderList(self, seqid, iprot, oprot):
6714 
    args = getOrderList_args()
6715 
    args.read(iprot)
6716 
    iprot.readMessageEnd()
6717 
    result = getOrderList_result()
6718 
    result.success = self._handler.getOrderList(args.order_ids)
6719 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
6723 
 
5386 phani.kuma 6724 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6725 
    args = getOrderListForVendor_args()
6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
6728 
    result = getOrderListForVendor_result()
6729 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6730 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6731 
    result.write(oprot)
6732 
    oprot.writeMessageEnd()
6733 
    oprot.trans.flush()
6734 
 
1528 ankur.sing 6735 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6736 
    args = getOrderForCustomer_args()
6737 
    args.read(iprot)
6738 
    iprot.readMessageEnd()
6739 
    result = getOrderForCustomer_result()
6740 
    try:
6741 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6742 
    except TransactionServiceException, ex:
6743 
      result.ex = ex
6744 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6745 
    result.write(oprot)
6746 
    oprot.writeMessageEnd()
6747 
    oprot.trans.flush()
6748 
 
3064 chandransh 6749 
  def process_getAlerts(self, seqid, iprot, oprot):
6750 
    args = getAlerts_args()
6751 
    args.read(iprot)
6752 
    iprot.readMessageEnd()
6753 
    result = getAlerts_result()
4444 rajveer 6754 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6755 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6756 
    result.write(oprot)
6757 
    oprot.writeMessageEnd()
6758 
    oprot.trans.flush()
6759 
 
4394 rajveer 6760 
  def process_addAlert(self, seqid, iprot, oprot):
6761 
    args = addAlert_args()
3064 chandransh 6762 
    args.read(iprot)
6763 
    iprot.readMessageEnd()
4394 rajveer 6764 
    result = addAlert_result()
4444 rajveer 6765 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6766 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6767 
    result.write(oprot)
6768 
    oprot.writeMessageEnd()
6769 
    oprot.trans.flush()
6770 
 
4444 rajveer 6771 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6772 
    args = markAlertsAsSeen_args()
6773 
    args.read(iprot)
6774 
    iprot.readMessageEnd()
6775 
    result = markAlertsAsSeen_result()
6776 
    self._handler.markAlertsAsSeen(args.warehouseId)
6777 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6778 
    result.write(oprot)
6779 
    oprot.writeMessageEnd()
6780 
    oprot.trans.flush()
6781 
 
3064 chandransh 6782 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6783 
    args = getValidOrderCount_args()
6784 
    args.read(iprot)
6785 
    iprot.readMessageEnd()
6786 
    result = getValidOrderCount_result()
6787 
    result.success = self._handler.getValidOrderCount()
6788 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6789 
    result.write(oprot)
6790 
    oprot.writeMessageEnd()
6791 
    oprot.trans.flush()
6792 
 
6793 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6794 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6795 
    args.read(iprot)
6796 
    iprot.readMessageEnd()
6797 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6798 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6799 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6800 
    result.write(oprot)
6801 
    oprot.writeMessageEnd()
6802 
    oprot.trans.flush()
6803 
 
6804 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6805 
    args = getValidOrdersAmountRange_args()
6806 
    args.read(iprot)
6807 
    iprot.readMessageEnd()
6808 
    result = getValidOrdersAmountRange_result()
6809 
    result.success = self._handler.getValidOrdersAmountRange()
6810 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6811 
    result.write(oprot)
6812 
    oprot.writeMessageEnd()
6813 
    oprot.trans.flush()
6814 
 
6815 
  def process_getValidOrders(self, seqid, iprot, oprot):
6816 
    args = getValidOrders_args()
6817 
    args.read(iprot)
6818 
    iprot.readMessageEnd()
6819 
    result = getValidOrders_result()
5874 rajveer 6820 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6821 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6822 
    result.write(oprot)
6823 
    oprot.writeMessageEnd()
6824 
    oprot.trans.flush()
6825 
 
1220 chandransh 6826 
  def process_batchOrders(self, seqid, iprot, oprot):
6827 
    args = batchOrders_args()
6828 
    args.read(iprot)
6829 
    iprot.readMessageEnd()
6830 
    result = batchOrders_result()
6831 
    try:
6832 
      result.success = self._handler.batchOrders(args.warehouseId)
6833 
    except TransactionServiceException, ex:
6834 
      result.ex = ex
6835 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6836 
    result.write(oprot)
6837 
    oprot.writeMessageEnd()
6838 
    oprot.trans.flush()
6839 
 
1208 chandransh 6840 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6841 
    args = markOrderAsOutOfStock_args()
6842 
    args.read(iprot)
6843 
    iprot.readMessageEnd()
6844 
    result = markOrderAsOutOfStock_result()
6845 
    try:
6846 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6847 
    except TransactionServiceException, ex:
6848 
      result.ex = ex
6849 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6850 
    result.write(oprot)
6851 
    oprot.writeMessageEnd()
6852 
    oprot.trans.flush()
6853 
 
3064 chandransh 6854 
  def process_verifyOrder(self, seqid, iprot, oprot):
6855 
    args = verifyOrder_args()
759 chandransh 6856 
    args.read(iprot)
6857 
    iprot.readMessageEnd()
3064 chandransh 6858 
    result = verifyOrder_result()
759 chandransh 6859 
    try:
3064 chandransh 6860 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6861 
    except TransactionServiceException, ex:
6862 
      result.ex = ex
3064 chandransh 6863 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6864 
    result.write(oprot)
6865 
    oprot.writeMessageEnd()
6866 
    oprot.trans.flush()
6867 
 
3064 chandransh 6868 
  def process_acceptOrder(self, seqid, iprot, oprot):
6869 
    args = acceptOrder_args()
1113 chandransh 6870 
    args.read(iprot)
6871 
    iprot.readMessageEnd()
3064 chandransh 6872 
    result = acceptOrder_result()
1113 chandransh 6873 
    try:
3064 chandransh 6874 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6875 
    except TransactionServiceException, ex:
6876 
      result.ex = ex
3064 chandransh 6877 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6878 
    result.write(oprot)
6879 
    oprot.writeMessageEnd()
6880 
    oprot.trans.flush()
6881 
 
3064 chandransh 6882 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6883 
    args = addBillingDetails_args()
1135 chandransh 6884 
    args.read(iprot)
6885 
    iprot.readMessageEnd()
3064 chandransh 6886 
    result = addBillingDetails_result()
1135 chandransh 6887 
    try:
5110 mandeep.dh 6888 
      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 6889 
    except TransactionServiceException, ex:
6890 
      result.ex = ex
3064 chandransh 6891 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6892 
    result.write(oprot)
6893 
    oprot.writeMessageEnd()
6894 
    oprot.trans.flush()
6895 
 
4579 rajveer 6896 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6897 
    args = addInvoiceNumber_args()
6898 
    args.read(iprot)
6899 
    iprot.readMessageEnd()
6900 
    result = addInvoiceNumber_result()
6901 
    try:
4763 rajveer 6902 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6903 
    except TransactionServiceException, ex:
6904 
      result.ex = ex
6905 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6906 
    result.write(oprot)
6907 
    oprot.writeMessageEnd()
6908 
    oprot.trans.flush()
6909 
 
4410 rajveer 6910 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6911 
    args = markOrdersAsShippedFromWarehouse_args()
6912 
    args.read(iprot)
6913 
    iprot.readMessageEnd()
6914 
    result = markOrdersAsShippedFromWarehouse_result()
6915 
    try:
4789 rajveer 6916 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6917 
    except TransactionServiceException, ex:
6918 
      result.ex = ex
6919 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6920 
    result.write(oprot)
6921 
    oprot.writeMessageEnd()
6922 
    oprot.trans.flush()
6923 
 
5676 rajveer 6924 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6925 
    args = markOrdersAsReturnedFromStore_args()
6926 
    args.read(iprot)
6927 
    iprot.readMessageEnd()
6928 
    result = markOrdersAsReturnedFromStore_result()
6929 
    try:
5713 rajveer 6930 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6931 
    except TransactionServiceException, ex:
6932 
      result.ex = ex
6933 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6934 
    result.write(oprot)
6935 
    oprot.writeMessageEnd()
6936 
    oprot.trans.flush()
6937 
 
3064 chandransh 6938 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6939 
    args = markOrdersAsPickedUp_args()
304 ashish 6940 
    args.read(iprot)
6941 
    iprot.readMessageEnd()
3064 chandransh 6942 
    result = markOrdersAsPickedUp_result()
6943 
    try:
4910 phani.kuma 6944 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6945 
    except TransactionServiceException, ex:
6946 
      result.ex = ex
6947 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6948 
    result.write(oprot)
6949 
    oprot.writeMessageEnd()
6950 
    oprot.trans.flush()
94 ashish 6951 
 
4910 phani.kuma 6952 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6953 
    args = getOrdersNotPickedUp_args()
6954 
    args.read(iprot)
6955 
    iprot.readMessageEnd()
6956 
    result = getOrdersNotPickedUp_result()
6957 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6958 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6959 
    result.write(oprot)
6960 
    oprot.writeMessageEnd()
6961 
    oprot.trans.flush()
6962 
 
3064 chandransh 6963 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6964 
    args = markOrdersAsDelivered_args()
304 ashish 6965 
    args.read(iprot)
6966 
    iprot.readMessageEnd()
3064 chandransh 6967 
    result = markOrdersAsDelivered_result()
6968 
    try:
6969 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6970 
    except TransactionServiceException, ex:
6971 
      result.ex = ex
6972 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6973 
    result.write(oprot)
6974 
    oprot.writeMessageEnd()
6975 
    oprot.trans.flush()
6976 
 
4910 phani.kuma 6977 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6978 
    args = markAsRTOrders_args()
1596 ankur.sing 6979 
    args.read(iprot)
6980 
    iprot.readMessageEnd()
4910 phani.kuma 6981 
    result = markAsRTOrders_result()
3064 chandransh 6982 
    try:
4910 phani.kuma 6983 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6984 
    except TransactionServiceException, ex:
6985 
      result.ex = ex
4910 phani.kuma 6986 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6987 
    result.write(oprot)
6988 
    oprot.writeMessageEnd()
6989 
    oprot.trans.flush()
304 ashish 6990 
 
4910 phani.kuma 6991 
  def process_getRTOrders(self, seqid, iprot, oprot):
6992 
    args = getRTOrders_args()
6993 
    args.read(iprot)
6994 
    iprot.readMessageEnd()
6995 
    result = getRTOrders_result()
6996 
    result.success = self._handler.getRTOrders(args.providerId)
6997 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6998 
    result.write(oprot)
6999 
    oprot.writeMessageEnd()
7000 
    oprot.trans.flush()
7001 
 
3064 chandransh 7002 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7003 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7004 
    args.read(iprot)
7005 
    iprot.readMessageEnd()
3064 chandransh 7006 
    result = updateNonDeliveryReason_result()
7007 
    try:
4910 phani.kuma 7008 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7009 
    except TransactionServiceException, ex:
7010 
      result.ex = ex
7011 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7012 
    result.write(oprot)
7013 
    oprot.writeMessageEnd()
7014 
    oprot.trans.flush()
1596 ankur.sing 7015 
 
4910 phani.kuma 7016 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7017 
    args = getNonDeliveredOrdersbyCourier_args()
7018 
    args.read(iprot)
7019 
    iprot.readMessageEnd()
7020 
    result = getNonDeliveredOrdersbyCourier_result()
7021 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7022 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7023 
    result.write(oprot)
7024 
    oprot.writeMessageEnd()
7025 
    oprot.trans.flush()
7026 
 
7027 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7028 
    args = markOrdersAsLocalConnected_args()
7029 
    args.read(iprot)
7030 
    iprot.readMessageEnd()
7031 
    result = markOrdersAsLocalConnected_result()
7032 
    try:
7033 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7034 
    except TransactionServiceException, ex:
7035 
      result.ex = ex
7036 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7037 
    result.write(oprot)
7038 
    oprot.writeMessageEnd()
7039 
    oprot.trans.flush()
7040 
 
7041 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7042 
    args = getOrdersNotLocalConnected_args()
7043 
    args.read(iprot)
7044 
    iprot.readMessageEnd()
7045 
    result = getOrdersNotLocalConnected_result()
7046 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7047 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7048 
    result.write(oprot)
7049 
    oprot.writeMessageEnd()
7050 
    oprot.trans.flush()
7051 
 
7052 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7053 
    args = markOrdersAsDestinationCityReached_args()
7054 
    args.read(iprot)
7055 
    iprot.readMessageEnd()
7056 
    result = markOrdersAsDestinationCityReached_result()
7057 
    try:
7058 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7059 
    except TransactionServiceException, ex:
7060 
      result.ex = ex
7061 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7062 
    result.write(oprot)
7063 
    oprot.writeMessageEnd()
7064 
    oprot.trans.flush()
7065 
 
7066 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7067 
    args = markOrdersAsFirstDeliveryAttempted_args()
7068 
    args.read(iprot)
7069 
    iprot.readMessageEnd()
7070 
    result = markOrdersAsFirstDeliveryAttempted_result()
7071 
    try:
7072 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7073 
    except TransactionServiceException, ex:
7074 
      result.ex = ex
7075 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7076 
    result.write(oprot)
7077 
    oprot.writeMessageEnd()
7078 
    oprot.trans.flush()
7079 
 
3064 chandransh 7080 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7081 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7082 
    args.read(iprot)
7083 
    iprot.readMessageEnd()
3064 chandransh 7084 
    result = getUndeliveredOrders_result()
7085 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7086 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7087 
    result.write(oprot)
7088 
    oprot.writeMessageEnd()
7089 
    oprot.trans.flush()
7090 
 
4783 phani.kuma 7091 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7092 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7093 
    args.read(iprot)
7094 
    iprot.readMessageEnd()
7095 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7096 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7097 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7098 
    result.write(oprot)
7099 
    oprot.writeMessageEnd()
7100 
    oprot.trans.flush()
7101 
 
2536 chandransh 7102 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7103 
    args = toggleDOAFlag_args()
7104 
    args.read(iprot)
7105 
    iprot.readMessageEnd()
7106 
    result = toggleDOAFlag_result()
7107 
    try:
7108 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7109 
    except TransactionServiceException, ex:
7110 
      result.ex = ex
7111 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7112 
    result.write(oprot)
7113 
    oprot.writeMessageEnd()
7114 
    oprot.trans.flush()
1886 ankur.sing 7115 
 
4712 rajveer 7116 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7117 
    args = markOrderAsDelivered_args()
7118 
    args.read(iprot)
7119 
    iprot.readMessageEnd()
7120 
    result = markOrderAsDelivered_result()
7121 
    try:
7122 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7123 
    except TransactionServiceException, ex:
7124 
      result.ex = ex
7125 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7126 
    result.write(oprot)
7127 
    oprot.writeMessageEnd()
7128 
    oprot.trans.flush()
7129 
 
5553 rajveer 7130 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7131 
    args = markOrderAsReceivedAtStore_args()
7132 
    args.read(iprot)
7133 
    iprot.readMessageEnd()
7134 
    result = markOrderAsReceivedAtStore_result()
7135 
    try:
7136 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7137 
    except TransactionServiceException, ex:
7138 
      result.ex = ex
7139 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7140 
    result.write(oprot)
7141 
    oprot.writeMessageEnd()
7142 
    oprot.trans.flush()
7143 
 
4454 rajveer 7144 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7145 
    args = markOrderDoaRequestReceived_args()
7146 
    args.read(iprot)
7147 
    iprot.readMessageEnd()
7148 
    result = markOrderDoaRequestReceived_result()
7149 
    try:
7150 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7151 
    except TransactionServiceException, ex:
7152 
      result.ex = ex
7153 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7154 
    result.write(oprot)
7155 
    oprot.writeMessageEnd()
7156 
    oprot.trans.flush()
7157 
 
7158 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7159 
    args = markOrderDoaRequestAuthorized_args()
7160 
    args.read(iprot)
7161 
    iprot.readMessageEnd()
7162 
    result = markOrderDoaRequestAuthorized_result()
7163 
    try:
7164 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7165 
    except TransactionServiceException, ex:
7166 
      result.ex = ex
7167 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7168 
    result.write(oprot)
7169 
    oprot.writeMessageEnd()
7170 
    oprot.trans.flush()
7171 
 
4488 rajveer 7172 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7173 
    args = markOrderReturnRequestReceived_args()
7174 
    args.read(iprot)
7175 
    iprot.readMessageEnd()
7176 
    result = markOrderReturnRequestReceived_result()
7177 
    try:
7178 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7179 
    except TransactionServiceException, ex:
7180 
      result.ex = ex
7181 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7182 
    result.write(oprot)
7183 
    oprot.writeMessageEnd()
7184 
    oprot.trans.flush()
7185 
 
7186 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7187 
    args = markOrderReturnRequestAuthorized_args()
7188 
    args.read(iprot)
7189 
    iprot.readMessageEnd()
7190 
    result = markOrderReturnRequestAuthorized_result()
7191 
    try:
7192 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7193 
    except TransactionServiceException, ex:
7194 
      result.ex = ex
7195 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7196 
    result.write(oprot)
7197 
    oprot.writeMessageEnd()
7198 
    oprot.trans.flush()
7199 
 
2536 chandransh 7200 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7201 
    args = requestPickupNumber_args()
7202 
    args.read(iprot)
7203 
    iprot.readMessageEnd()
7204 
    result = requestPickupNumber_result()
7205 
    try:
4579 rajveer 7206 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7207 
    except TransactionServiceException, ex:
7208 
      result.ex = ex
7209 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7210 
    result.write(oprot)
7211 
    oprot.writeMessageEnd()
7212 
    oprot.trans.flush()
7213 
 
7214 
  def process_authorizePickup(self, seqid, iprot, oprot):
7215 
    args = authorizePickup_args()
7216 
    args.read(iprot)
7217 
    iprot.readMessageEnd()
7218 
    result = authorizePickup_result()
7219 
    try:
4602 rajveer 7220 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7221 
    except TransactionServiceException, ex:
7222 
      result.ex = ex
7223 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7224 
    result.write(oprot)
7225 
    oprot.writeMessageEnd()
7226 
    oprot.trans.flush()
7227 
 
2764 chandransh 7228 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7229 
    args = markDoasAsPickedUp_args()
7230 
    args.read(iprot)
7231 
    iprot.readMessageEnd()
7232 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7233 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7234 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7235 
    result.write(oprot)
7236 
    oprot.writeMessageEnd()
7237 
    oprot.trans.flush()
7238 
 
4910 phani.kuma 7239 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7240 
    args = getDoasNotPickedUp_args()
7241 
    args.read(iprot)
7242 
    iprot.readMessageEnd()
7243 
    result = getDoasNotPickedUp_result()
7244 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7245 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7246 
    result.write(oprot)
7247 
    oprot.writeMessageEnd()
7248 
    oprot.trans.flush()
7249 
 
4741 phani.kuma 7250 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7251 
    args = markReturnOrdersAsPickedUp_args()
7252 
    args.read(iprot)
7253 
    iprot.readMessageEnd()
7254 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7255 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7256 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7257 
    result.write(oprot)
7258 
    oprot.writeMessageEnd()
7259 
    oprot.trans.flush()
7260 
 
4910 phani.kuma 7261 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7262 
    args = getReturnOrdersNotPickedUp_args()
7263 
    args.read(iprot)
7264 
    iprot.readMessageEnd()
7265 
    result = getReturnOrdersNotPickedUp_result()
7266 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7267 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7268 
    result.write(oprot)
7269 
    oprot.writeMessageEnd()
7270 
    oprot.trans.flush()
7271 
 
2616 chandransh 7272 
  def process_receiveReturn(self, seqid, iprot, oprot):
7273 
    args = receiveReturn_args()
2591 chandransh 7274 
    args.read(iprot)
7275 
    iprot.readMessageEnd()
2616 chandransh 7276 
    result = receiveReturn_result()
2591 chandransh 7277 
    try:
4479 rajveer 7278 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7279 
    except TransactionServiceException, ex:
7280 
      result.ex = ex
2616 chandransh 7281 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
2536 chandransh 7285 
 
2591 chandransh 7286 
  def process_validateDoa(self, seqid, iprot, oprot):
7287 
    args = validateDoa_args()
7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
7290 
    result = validateDoa_result()
7291 
    try:
7292 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7293 
    except TransactionServiceException, ex:
7294 
      result.ex = ex
7295 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7296 
    result.write(oprot)
7297 
    oprot.writeMessageEnd()
7298 
    oprot.trans.flush()
7299 
 
4495 rajveer 7300 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7301 
    args = validateReturnProduct_args()
7302 
    args.read(iprot)
7303 
    iprot.readMessageEnd()
7304 
    result = validateReturnProduct_result()
7305 
    try:
7306 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7307 
    except TransactionServiceException, ex:
7308 
      result.ex = ex
7309 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7310 
    result.write(oprot)
7311 
    oprot.writeMessageEnd()
7312 
    oprot.trans.flush()
7313 
 
2616 chandransh 7314 
  def process_reshipOrder(self, seqid, iprot, oprot):
7315 
    args = reshipOrder_args()
7316 
    args.read(iprot)
7317 
    iprot.readMessageEnd()
7318 
    result = reshipOrder_result()
7319 
    try:
7320 
      result.success = self._handler.reshipOrder(args.orderId)
7321 
    except TransactionServiceException, ex:
7322 
      result.ex = ex
7323 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7324 
    result.write(oprot)
7325 
    oprot.writeMessageEnd()
7326 
    oprot.trans.flush()
2591 chandransh 7327 
 
2616 chandransh 7328 
  def process_refundOrder(self, seqid, iprot, oprot):
7329 
    args = refundOrder_args()
7330 
    args.read(iprot)
7331 
    iprot.readMessageEnd()
7332 
    result = refundOrder_result()
7333 
    try:
3226 chandransh 7334 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7335 
    except TransactionServiceException, ex:
7336 
      result.ex = ex
7337 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7338 
    result.write(oprot)
7339 
    oprot.writeMessageEnd()
7340 
    oprot.trans.flush()
7341 
 
2690 chandransh 7342 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7343 
    args = getReturnOrders_args()
7344 
    args.read(iprot)
7345 
    iprot.readMessageEnd()
7346 
    result = getReturnOrders_result()
7347 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7348 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7349 
    result.write(oprot)
7350 
    oprot.writeMessageEnd()
7351 
    oprot.trans.flush()
2616 chandransh 7352 
 
5481 phani.kuma 7353 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7354 
    args = getAllReturnOrders_args()
7355 
    args.read(iprot)
7356 
    iprot.readMessageEnd()
7357 
    result = getAllReturnOrders_result()
7358 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7359 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7360 
    result.write(oprot)
7361 
    oprot.writeMessageEnd()
7362 
    oprot.trans.flush()
7363 
 
2700 chandransh 7364 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7365 
    args = getReturnOrder_args()
7366 
    args.read(iprot)
7367 
    iprot.readMessageEnd()
7368 
    result = getReturnOrder_result()
7369 
    try:
7370 
      result.success = self._handler.getReturnOrder(args.id)
7371 
    except TransactionServiceException, ex:
7372 
      result.ex = ex
7373 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7374 
    result.write(oprot)
7375 
    oprot.writeMessageEnd()
7376 
    oprot.trans.flush()
7377 
 
2690 chandransh 7378 
  def process_processReturn(self, seqid, iprot, oprot):
7379 
    args = processReturn_args()
7380 
    args.read(iprot)
7381 
    iprot.readMessageEnd()
7382 
    result = processReturn_result()
7383 
    try:
7384 
      self._handler.processReturn(args.returnOrderId)
7385 
    except TransactionServiceException, ex:
7386 
      result.ex = ex
7387 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7388 
    result.write(oprot)
7389 
    oprot.writeMessageEnd()
7390 
    oprot.trans.flush()
7391 
 
3451 chandransh 7392 
  def process_updateWeight(self, seqid, iprot, oprot):
7393 
    args = updateWeight_args()
7394 
    args.read(iprot)
7395 
    iprot.readMessageEnd()
7396 
    result = updateWeight_result()
7397 
    try:
7398 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7399 
    except TransactionServiceException, ex:
7400 
      result.ex = ex
7401 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7402 
    result.write(oprot)
7403 
    oprot.writeMessageEnd()
7404 
    oprot.trans.flush()
2819 chandransh 7405 
 
3469 chandransh 7406 
  def process_changeItem(self, seqid, iprot, oprot):
7407 
    args = changeItem_args()
7408 
    args.read(iprot)
7409 
    iprot.readMessageEnd()
7410 
    result = changeItem_result()
7411 
    try:
7412 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7413 
    except TransactionServiceException, ex:
7414 
      result.ex = ex
7415 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7416 
    result.write(oprot)
7417 
    oprot.writeMessageEnd()
7418 
    oprot.trans.flush()
3451 chandransh 7419 
 
3469 chandransh 7420 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7421 
    args = shiftToWarehouse_args()
7422 
    args.read(iprot)
7423 
    iprot.readMessageEnd()
7424 
    result = shiftToWarehouse_result()
7425 
    try:
7426 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7427 
    except TransactionServiceException, ex:
7428 
      result.ex = ex
7429 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7430 
    result.write(oprot)
7431 
    oprot.writeMessageEnd()
7432 
    oprot.trans.flush()
7433 
 
3553 chandransh 7434 
  def process_addDelayReason(self, seqid, iprot, oprot):
7435 
    args = addDelayReason_args()
7436 
    args.read(iprot)
7437 
    iprot.readMessageEnd()
7438 
    result = addDelayReason_result()
7439 
    try:
4647 rajveer 7440 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7441 
    except TransactionServiceException, ex:
7442 
      result.ex = ex
7443 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7444 
    result.write(oprot)
7445 
    oprot.writeMessageEnd()
7446 
    oprot.trans.flush()
3469 chandransh 7447 
 
3956 chandransh 7448 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7449 
    args = reconcileCodCollection_args()
7450 
    args.read(iprot)
7451 
    iprot.readMessageEnd()
7452 
    result = reconcileCodCollection_result()
7453 
    try:
7454 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7455 
    except TransactionServiceException, ex:
7456 
      result.ex = ex
7457 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7458 
    result.write(oprot)
7459 
    oprot.writeMessageEnd()
7460 
    oprot.trans.flush()
3553 chandransh 7461 
 
4008 mandeep.dh 7462 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7463 
    args = getTransactionsRequiringExtraProcessing_args()
7464 
    args.read(iprot)
7465 
    iprot.readMessageEnd()
7466 
    result = getTransactionsRequiringExtraProcessing_result()
7467 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7468 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7469 
    result.write(oprot)
7470 
    oprot.writeMessageEnd()
7471 
    oprot.trans.flush()
3956 chandransh 7472 
 
4008 mandeep.dh 7473 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7474 
    args = markTransactionAsProcessed_args()
7475 
    args.read(iprot)
7476 
    iprot.readMessageEnd()
7477 
    result = markTransactionAsProcessed_result()
7478 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7479 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7480 
    result.write(oprot)
7481 
    oprot.writeMessageEnd()
7482 
    oprot.trans.flush()
7483 
 
4018 chandransh 7484 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7485 
    args = getItemWiseRiskyOrdersCount_args()
7486 
    args.read(iprot)
7487 
    iprot.readMessageEnd()
7488 
    result = getItemWiseRiskyOrdersCount_result()
7489 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7490 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7491 
    result.write(oprot)
7492 
    oprot.writeMessageEnd()
7493 
    oprot.trans.flush()
4008 mandeep.dh 7494 
 
4295 varun.gupt 7495 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7496 
    args = getOrdersForItemIds_args()
7497 
    args.read(iprot)
7498 
    iprot.readMessageEnd()
7499 
    result = getOrdersForItemIds_result()
7500 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7501 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7502 
    result.write(oprot)
7503 
    oprot.writeMessageEnd()
7504 
    oprot.trans.flush()
7505 
 
4247 rajveer 7506 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7507 
    args = markOrderCancellationRequestReceived_args()
7508 
    args.read(iprot)
7509 
    iprot.readMessageEnd()
7510 
    result = markOrderCancellationRequestReceived_result()
7511 
    try:
7512 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7513 
    except TransactionServiceException, ex:
7514 
      result.ex = ex
7515 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7516 
    result.write(oprot)
7517 
    oprot.writeMessageEnd()
7518 
    oprot.trans.flush()
4018 chandransh 7519 
 
4247 rajveer 7520 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7521 
    args = markOrderCancellationRequestConfirmed_args()
7522 
    args.read(iprot)
7523 
    iprot.readMessageEnd()
7524 
    result = markOrderCancellationRequestConfirmed_result()
7525 
    try:
7526 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7527 
    except TransactionServiceException, ex:
7528 
      result.ex = ex
7529 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7530 
    result.write(oprot)
7531 
    oprot.writeMessageEnd()
7532 
    oprot.trans.flush()
7533 
 
7534 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7535 
    args = markOrderCancellationRequestDenied_args()
7536 
    args.read(iprot)
7537 
    iprot.readMessageEnd()
7538 
    result = markOrderCancellationRequestDenied_result()
7539 
    try:
7540 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7541 
    except TransactionServiceException, ex:
7542 
      result.ex = ex
7543 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7544 
    result.write(oprot)
7545 
    oprot.writeMessageEnd()
7546 
    oprot.trans.flush()
7547 
 
4258 rajveer 7548 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7549 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7550 
    args.read(iprot)
7551 
    iprot.readMessageEnd()
4258 rajveer 7552 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7553 
    try:
4258 rajveer 7554 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7555 
    except TransactionServiceException, ex:
7556 
      result.ex = ex
4258 rajveer 7557 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7558 
    result.write(oprot)
7559 
    oprot.writeMessageEnd()
7560 
    oprot.trans.flush()
7561 
 
4259 anupam.sin 7562 
  def process_refundTransaction(self, seqid, iprot, oprot):
7563 
    args = refundTransaction_args()
7564 
    args.read(iprot)
7565 
    iprot.readMessageEnd()
7566 
    result = refundTransaction_result()
7567 
    try:
7568 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7569 
    except TransactionServiceException, ex:
7570 
      result.ex = ex
7571 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7572 
    result.write(oprot)
7573 
    oprot.writeMessageEnd()
7574 
    oprot.trans.flush()
4247 rajveer 7575 
 
4324 mandeep.dh 7576 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7577 
    args = updateShipmentAddress_args()
7578 
    args.read(iprot)
7579 
    iprot.readMessageEnd()
7580 
    result = updateShipmentAddress_result()
7581 
    try:
7582 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7583 
    except TransactionServiceException, ex:
7584 
      result.ex = ex
7585 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7586 
    result.write(oprot)
7587 
    oprot.writeMessageEnd()
7588 
    oprot.trans.flush()
7589 
 
4285 rajveer 7590 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7591 
    args = acceptOrdersForItemId_args()
7592 
    args.read(iprot)
7593 
    iprot.readMessageEnd()
7594 
    result = acceptOrdersForItemId_result()
7595 
    try:
7596 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7597 
    except TransactionServiceException, ex:
7598 
      result.ex = ex
7599 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7600 
    result.write(oprot)
7601 
    oprot.writeMessageEnd()
7602 
    oprot.trans.flush()
4259 anupam.sin 7603 
 
4303 rajveer 7604 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7605 
    args = markOrdersAsPORaised_args()
7606 
    args.read(iprot)
7607 
    iprot.readMessageEnd()
7608 
    result = markOrdersAsPORaised_result()
7609 
    try:
4369 rajveer 7610 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7611 
    except TransactionServiceException, ex:
7612 
      result.ex = ex
7613 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7614 
    result.write(oprot)
7615 
    oprot.writeMessageEnd()
7616 
    oprot.trans.flush()
4285 rajveer 7617 
 
4303 rajveer 7618 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7619 
    args = markOrdersAsReversalInitiated_args()
7620 
    args.read(iprot)
7621 
    iprot.readMessageEnd()
7622 
    result = markOrdersAsReversalInitiated_result()
7623 
    try:
4369 rajveer 7624 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7625 
    except TransactionServiceException, ex:
7626 
      result.ex = ex
7627 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7628 
    result.write(oprot)
7629 
    oprot.writeMessageEnd()
7630 
    oprot.trans.flush()
7631 
 
7632 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7633 
    args = markOrdersAsNotAvailabke_args()
7634 
    args.read(iprot)
7635 
    iprot.readMessageEnd()
7636 
    result = markOrdersAsNotAvailabke_result()
7637 
    try:
4369 rajveer 7638 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7639 
    except TransactionServiceException, ex:
7640 
      result.ex = ex
7641 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
7645 
 
4369 rajveer 7646 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7647 
    args = markOrdersAsTimeout_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = markOrdersAsTimeout_result()
7651 
    try:
7652 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7653 
    except TransactionServiceException, ex:
7654 
      result.ex = ex
7655 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
4303 rajveer 7659 
 
4662 rajveer 7660 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7661 
    args = markOrderAsLostInTransit_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = markOrderAsLostInTransit_result()
7665 
    try:
7666 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7667 
    except TransactionServiceException, ex:
7668 
      result.ex = ex
7669 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
4386 anupam.sin 7674 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7675 
    args = getOrderForAwb_args()
7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
7678 
    result = getOrderForAwb_result()
7679 
    try:
7680 
      result.success = self._handler.getOrderForAwb(args.awb)
7681 
    except TransactionServiceException, ex:
7682 
      result.ex = ex
7683 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
4369 rajveer 7687 
 
4506 phani.kuma 7688 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7689 
    args = getOrdersForProviderForStatus_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = getOrdersForProviderForStatus_result()
7693 
    try:
4910 phani.kuma 7694 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7695 
    except TransactionServiceException, ex:
7696 
      result.ex = ex
7697 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7698 
    result.write(oprot)
7699 
    oprot.writeMessageEnd()
7700 
    oprot.trans.flush()
4386 anupam.sin 7701 
 
4600 varun.gupt 7702 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7703 
    args = getBilledOrdersForVendor_args()
7704 
    args.read(iprot)
7705 
    iprot.readMessageEnd()
7706 
    result = getBilledOrdersForVendor_result()
7707 
    try:
7708 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7709 
    except TransactionServiceException, ex:
7710 
      result.ex = ex
7711 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
4506 phani.kuma 7715 
 
4607 rajveer 7716 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7717 
    args = getSlippedSippingDateOrders_args()
7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
7720 
    result = getSlippedSippingDateOrders_result()
7721 
    try:
7722 
      result.success = self._handler.getSlippedSippingDateOrders()
7723 
    except TransactionServiceException, ex:
7724 
      result.ex = ex
7725 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7729 
 
4709 rajveer 7730 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7731 
    args = getCancelledOrders_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = getCancelledOrders_result()
7735 
    try:
7736 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7737 
    except TransactionServiceException, ex:
7738 
      result.ex = ex
7739 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
7743 
 
4600 varun.gupt 7744 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7745 
    args = saveBluedartSettlements_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = saveBluedartSettlements_result()
7749 
    try:
7750 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7751 
    except TransactionServiceException, ex:
7752 
      result.ex = ex
7753 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
7758 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7759 
    args = savePaymentSettlements_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = savePaymentSettlements_result()
7763 
    try:
4905 varun.gupt 7764 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7765 
    except TransactionServiceException, ex:
7766 
      result.ex = ex
7767 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
7771 
 
7772 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7773 
    args = saveEBSSettlementSummary_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = saveEBSSettlementSummary_result()
7777 
    try:
7778 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7779 
    except TransactionServiceException, ex:
7780 
      result.ex = ex
7781 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
7785 
 
5386 phani.kuma 7786 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7787 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
5386 phani.kuma 7790 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7791 
    try:
5386 phani.kuma 7792 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7793 
    except TransactionServiceException, ex:
7794 
      result.ex = ex
5386 phani.kuma 7795 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
5386 phani.kuma 7800 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7801 
    args = getSettlementForCod_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = getSettlementForCod_result()
7805 
    try:
7806 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7807 
    except TransactionServiceException, ex:
7808 
      result.ex = ex
7809 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
7813 
 
4600 varun.gupt 7814 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7815 
    args = getEBSSettlementSummaries_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = getEBSSettlementSummaries_result()
7819 
    try:
7820 
      result.success = self._handler.getEBSSettlementSummaries()
7821 
    except TransactionServiceException, ex:
7822 
      result.ex = ex
7823 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7824 
    result.write(oprot)
7825 
    oprot.writeMessageEnd()
7826 
    oprot.trans.flush()
7827 
 
7828 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7829 
    args = markEBSSettlementUploaded_args()
7830 
    args.read(iprot)
7831 
    iprot.readMessageEnd()
7832 
    result = markEBSSettlementUploaded_result()
7833 
    try:
7834 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7835 
    except TransactionServiceException, ex:
7836 
      result.ex = ex
7837 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7838 
    result.write(oprot)
7839 
    oprot.writeMessageEnd()
7840 
    oprot.trans.flush()
7841 
 
7842 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7843 
    args = getEBSSettlementDate_args()
7844 
    args.read(iprot)
7845 
    iprot.readMessageEnd()
7846 
    result = getEBSSettlementDate_result()
7847 
    try:
7848 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7849 
    except TransactionServiceException, ex:
7850 
      result.ex = ex
7851 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
7855 
 
4715 varun.gupt 7856 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7857 
    args = getSettlementsByDate_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = getSettlementsByDate_result()
7861 
    try:
7862 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7863 
    except TransactionServiceException, ex:
7864 
      result.ex = ex
7865 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7866 
    result.write(oprot)
7867 
    oprot.writeMessageEnd()
7868 
    oprot.trans.flush()
4600 varun.gupt 7869 
 
4715 varun.gupt 7870 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7871 
    args = getReshippedOrderIds_args()
7872 
    args.read(iprot)
7873 
    iprot.readMessageEnd()
7874 
    result = getReshippedOrderIds_result()
7875 
    try:
7876 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7877 
    except TransactionServiceException, ex:
7878 
      result.ex = ex
7879 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7880 
    result.write(oprot)
7881 
    oprot.writeMessageEnd()
7882 
    oprot.trans.flush()
7883 
 
5481 phani.kuma 7884 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7885 
    args = getBilledOrders_args()
4875 varun.gupt 7886 
    args.read(iprot)
7887 
    iprot.readMessageEnd()
5481 phani.kuma 7888 
    result = getBilledOrders_result()
4875 varun.gupt 7889 
    try:
5481 phani.kuma 7890 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7891 
    except TransactionServiceException, ex:
7892 
      result.ex = ex
5481 phani.kuma 7893 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7894 
    result.write(oprot)
7895 
    oprot.writeMessageEnd()
7896 
    oprot.trans.flush()
4757 mandeep.dh 7897 
 
5031 varun.gupt 7898 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7899 
    args = getStatusDistributionOfOrders_args()
7900 
    args.read(iprot)
7901 
    iprot.readMessageEnd()
7902 
    result = getStatusDistributionOfOrders_result()
7903 
    try:
7904 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7905 
    except TransactionServiceException, ex:
7906 
      result.ex = ex
7907 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7908 
    result.write(oprot)
7909 
    oprot.writeMessageEnd()
7910 
    oprot.trans.flush()
4875 varun.gupt 7911 
 
5067 varun.gupt 7912 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7913 
    args = getOrderIdsForStatus_args()
7914 
    args.read(iprot)
7915 
    iprot.readMessageEnd()
7916 
    result = getOrderIdsForStatus_result()
7917 
    try:
7918 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7919 
    except TransactionServiceException, ex:
7920 
      result.ex = ex
7921 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7922 
    result.write(oprot)
7923 
    oprot.writeMessageEnd()
7924 
    oprot.trans.flush()
5031 varun.gupt 7925 
 
5348 anupam.sin 7926 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7927 
    args = updateCODAgent_args()
7928 
    args.read(iprot)
7929 
    iprot.readMessageEnd()
7930 
    result = updateCODAgent_result()
7931 
    try:
7932 
      self._handler.updateCODAgent(args.agent, args.orderId)
7933 
    except TransactionServiceException, ex:
7934 
      result.ex = ex
7935 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
7939 
 
5099 varun.gupt 7940 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7941 
    args = updateOrderAsPaidToVendor_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = updateOrderAsPaidToVendor_result()
7945 
    try:
7946 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7947 
    except TransactionServiceException, ex:
7948 
      result.ex = ex
7949 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7950 
    result.write(oprot)
7951 
    oprot.writeMessageEnd()
7952 
    oprot.trans.flush()
5067 varun.gupt 7953 
 
5386 phani.kuma 7954 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7955 
    args = updateOrderOnlyAsPaidToVendor_args()
7956 
    args.read(iprot)
7957 
    iprot.readMessageEnd()
7958 
    result = updateOrderOnlyAsPaidToVendor_result()
7959 
    try:
7960 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7961 
    except TransactionServiceException, ex:
7962 
      result.ex = ex
7963 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
7967 
 
5208 varun.gupt 7968 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7969 
    args = getRefundedOrdersMarkedPaid_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = getRefundedOrdersMarkedPaid_result()
7973 
    try:
7974 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7975 
    except TransactionServiceException, ex:
7976 
      result.ex = ex
7977 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7978 
    result.write(oprot)
7979 
    oprot.writeMessageEnd()
7980 
    oprot.trans.flush()
5099 varun.gupt 7981 
 
5447 anupam.sin 7982 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7983 
    args = getAllVerificationAgents_args()
7984 
    args.read(iprot)
7985 
    iprot.readMessageEnd()
7986 
    result = getAllVerificationAgents_result()
7987 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7988 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
5208 varun.gupt 7992 
 
5527 anupam.sin 7993 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7994 
    args = getAllAttributesForOrderId_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = getAllAttributesForOrderId_result()
7998 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7999 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8000 
    result.write(oprot)
8001 
    oprot.writeMessageEnd()
8002 
    oprot.trans.flush()
5447 anupam.sin 8003 
 
5676 rajveer 8004 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8005 
    args = setOrderAttributes_args()
8006 
    args.read(iprot)
8007 
    iprot.readMessageEnd()
8008 
    result = setOrderAttributes_result()
8009 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8010 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8011 
    result.write(oprot)
8012 
    oprot.writeMessageEnd()
8013 
    oprot.trans.flush()
8014 
 
5527 anupam.sin 8015 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8016 
    args = setOrderAttributeForTransaction_args()
8017 
    args.read(iprot)
8018 
    iprot.readMessageEnd()
8019 
    result = setOrderAttributeForTransaction_result()
8020 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8021 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8022 
    result.write(oprot)
8023 
    oprot.writeMessageEnd()
8024 
    oprot.trans.flush()
8025 
 
5553 rajveer 8026 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8027 
    args = getReceivePendingOrders_args()
8028 
    args.read(iprot)
8029 
    iprot.readMessageEnd()
8030 
    result = getReceivePendingOrders_result()
8031 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8032 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8033 
    result.write(oprot)
8034 
    oprot.writeMessageEnd()
8035 
    oprot.trans.flush()
5527 anupam.sin 8036 
 
5553 rajveer 8037 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8038 
    args = getReceivedAtStoreOrders_args()
8039 
    args.read(iprot)
8040 
    iprot.readMessageEnd()
8041 
    result = getReceivedAtStoreOrders_result()
8042 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8043 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8044 
    result.write(oprot)
8045 
    oprot.writeMessageEnd()
8046 
    oprot.trans.flush()
8047 
 
5713 rajveer 8048 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8049 
    args = getOrdersCollectionAtStore_args()
8050 
    args.read(iprot)
8051 
    iprot.readMessageEnd()
8052 
    result = getOrdersCollectionAtStore_result()
8053 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8054 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8055 
    result.write(oprot)
8056 
    oprot.writeMessageEnd()
8057 
    oprot.trans.flush()
8058 
 
5833 rajveer 8059 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8060 
    args = getOrderAttributeValue_args()
8061 
    args.read(iprot)
8062 
    iprot.readMessageEnd()
8063 
    result = getOrderAttributeValue_result()
8064 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8065 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8066 
    result.write(oprot)
8067 
    oprot.writeMessageEnd()
8068 
    oprot.trans.flush()
8069 
 
6019 rajveer 8070 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8071 
    args = changeJacketNumber_args()
8072 
    args.read(iprot)
8073 
    iprot.readMessageEnd()
8074 
    result = changeJacketNumber_result()
8075 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8076 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8077 
    result.write(oprot)
8078 
    oprot.writeMessageEnd()
8079 
    oprot.trans.flush()
8080 
 
8081 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8082 
    args = markOrderAsRtoInTransit_args()
8083 
    args.read(iprot)
8084 
    iprot.readMessageEnd()
8085 
    result = markOrderAsRtoInTransit_result()
8086 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8087 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8088 
    result.write(oprot)
8089 
    oprot.writeMessageEnd()
8090 
    oprot.trans.flush()
8091 
 
5593 mandeep.dh 8092 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8093 
    args = acceptOrderForItem_args()
8094 
    args.read(iprot)
8095 
    iprot.readMessageEnd()
8096 
    result = acceptOrderForItem_result()
8097 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8098 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8099 
    result.write(oprot)
8100 
    oprot.writeMessageEnd()
8101 
    oprot.trans.flush()
5553 rajveer 8102 
 
6000 mandeep.dh 8103 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8104 
    args = createRechargeOrder_args()
8105 
    args.read(iprot)
8106 
    iprot.readMessageEnd()
8107 
    result = createRechargeOrder_result()
8108 
    try:
8109 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8110 
    except TransactionServiceException, ex:
8111 
      result.ex = ex
8112 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8113 
    result.write(oprot)
8114 
    oprot.writeMessageEnd()
8115 
    oprot.trans.flush()
5593 mandeep.dh 8116 
 
6031 rajveer 8117 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8118 
    args = getRechargeOrder_args()
8119 
    args.read(iprot)
8120 
    iprot.readMessageEnd()
8121 
    result = getRechargeOrder_result()
8122 
    try:
8123 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8124 
    except TransactionServiceException, ex:
8125 
      result.ex = ex
8126 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8127 
    result.write(oprot)
8128 
    oprot.writeMessageEnd()
8129 
    oprot.trans.flush()
8130 
 
8131 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8132 
    args = getRechargeOrders_args()
8133 
    args.read(iprot)
8134 
    iprot.readMessageEnd()
8135 
    result = getRechargeOrders_result()
8136 
    result.success = self._handler.getRechargeOrders(args.userId)
8137 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8138 
    result.write(oprot)
8139 
    oprot.writeMessageEnd()
8140 
    oprot.trans.flush()
8141 
 
6000 mandeep.dh 8142 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8143 
    args = updateRechargeOrderStatus_args()
8144 
    args.read(iprot)
8145 
    iprot.readMessageEnd()
8146 
    result = updateRechargeOrderStatus_result()
8147 
    try:
6031 rajveer 8148 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8149 
    except TransactionServiceException, ex:
8150 
      result.ex = ex
8151 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8152 
    result.write(oprot)
8153 
    oprot.writeMessageEnd()
8154 
    oprot.trans.flush()
8155 
 
8156 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8157 
    args = activateRechargeTxn_args()
8158 
    args.read(iprot)
8159 
    iprot.readMessageEnd()
8160 
    result = activateRechargeTxn_result()
8161 
    try:
6031 rajveer 8162 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8163 
    except TransactionServiceException, ex:
8164 
      result.ex = ex
8165 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8166 
    result.write(oprot)
8167 
    oprot.writeMessageEnd()
8168 
    oprot.trans.flush()
8169 
 
6031 rajveer 8170 
  def process_getUserWallet(self, seqid, iprot, oprot):
8171 
    args = getUserWallet_args()
6000 mandeep.dh 8172 
    args.read(iprot)
8173 
    iprot.readMessageEnd()
6031 rajveer 8174 
    result = getUserWallet_result()
8175 
    result.success = self._handler.getUserWallet(args.userId)
8176 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8177 
    result.write(oprot)
8178 
    oprot.writeMessageEnd()
8179 
    oprot.trans.flush()
8180 
 
6031 rajveer 8181 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8182 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8183 
    args.read(iprot)
8184 
    iprot.readMessageEnd()
6031 rajveer 8185 
    result = getUserWalletHistory_result()
8186 
    result.success = self._handler.getUserWalletHistory(args.userId)
8187 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8188 
    result.write(oprot)
8189 
    oprot.writeMessageEnd()
8190 
    oprot.trans.flush()
8191 
 
6050 anupam.sin 8192 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8193 
    args = getRechargeOrdersForTransaction_args()
8194 
    args.read(iprot)
8195 
    iprot.readMessageEnd()
8196 
    result = getRechargeOrdersForTransaction_result()
8197 
    try:
8198 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8199 
    except TransactionServiceException, ex:
8200 
      result.ex = ex
8201 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8202 
    result.write(oprot)
8203 
    oprot.writeMessageEnd()
8204 
    oprot.trans.flush()
8205 
 
6048 rajveer 8206 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8207 
    args = getServiceProviders_args()
8208 
    args.read(iprot)
8209 
    iprot.readMessageEnd()
8210 
    result = getServiceProviders_result()
8211 
    result.success = self._handler.getServiceProviders(args.rechargeType)
8212 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8213 
    result.write(oprot)
8214 
    oprot.writeMessageEnd()
8215 
    oprot.trans.flush()
6000 mandeep.dh 8216 
 
6048 rajveer 8217 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8218 
    args = getServiceProviderForDevice_args()
8219 
    args.read(iprot)
8220 
    iprot.readMessageEnd()
8221 
    result = getServiceProviderForDevice_result()
6049 rajveer 8222 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8223 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8224 
    result.write(oprot)
8225 
    oprot.writeMessageEnd()
8226 
    oprot.trans.flush()
8227 
 
6094 rajveer 8228 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8229 
    args = getRechargeOrdersForDevice_args()
8230 
    args.read(iprot)
8231 
    iprot.readMessageEnd()
8232 
    result = getRechargeOrdersForDevice_result()
8233 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8234 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8235 
    result.write(oprot)
8236 
    oprot.writeMessageEnd()
8237 
    oprot.trans.flush()
6048 rajveer 8238 
 
6094 rajveer 8239 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8240 
    args = addAmountToWallet_args()
8241 
    args.read(iprot)
8242 
    iprot.readMessageEnd()
8243 
    result = addAmountToWallet_result()
8244 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8245 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8246 
    result.write(oprot)
8247 
    oprot.writeMessageEnd()
8248 
    oprot.trans.flush()
8249 
 
6154 rajveer 8250 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8251 
    args = getRechargeOrdersForStatus_args()
8252 
    args.read(iprot)
8253 
    iprot.readMessageEnd()
8254 
    result = getRechargeOrdersForStatus_result()
8255 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8256 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8257 
    result.write(oprot)
8258 
    oprot.writeMessageEnd()
8259 
    oprot.trans.flush()
6094 rajveer 8260 
 
6159 rajveer 8261 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8262 
    args = getPlansForOperator_args()
8263 
    args.read(iprot)
8264 
    iprot.readMessageEnd()
8265 
    result = getPlansForOperator_result()
8266 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8267 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8268 
    result.write(oprot)
8269 
    oprot.writeMessageEnd()
8270 
    oprot.trans.flush()
6154 rajveer 8271 
 
6159 rajveer 8272 
 
94 ashish 8273 
# HELPER FUNCTIONS AND STRUCTURES
8274 
 
8275 
class createTransaction_args:
8276 
  """
8277 
  Attributes:
8278 
   - transaction
8279 
  """
8280 
 
8281 
  thrift_spec = (
8282 
    None, # 0
8283 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8284 
  )
8285 
 
8286 
  def __init__(self, transaction=None,):
8287 
    self.transaction = transaction
8288 
 
8289 
  def read(self, iprot):
8290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8292 
      return
8293 
    iprot.readStructBegin()
8294 
    while True:
8295 
      (fname, ftype, fid) = iprot.readFieldBegin()
8296 
      if ftype == TType.STOP:
8297 
        break
8298 
      if fid == 1:
8299 
        if ftype == TType.STRUCT:
8300 
          self.transaction = Transaction()
8301 
          self.transaction.read(iprot)
8302 
        else:
8303 
          iprot.skip(ftype)
8304 
      else:
8305 
        iprot.skip(ftype)
8306 
      iprot.readFieldEnd()
8307 
    iprot.readStructEnd()
8308 
 
8309 
  def write(self, oprot):
8310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8312 
      return
8313 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8314 
    if self.transaction is not None:
94 ashish 8315 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8316 
      self.transaction.write(oprot)
8317 
      oprot.writeFieldEnd()
8318 
    oprot.writeFieldStop()
8319 
    oprot.writeStructEnd()
8320 
 
3431 rajveer 8321 
  def validate(self):
8322 
    return
8323 
 
8324 
 
94 ashish 8325 
  def __repr__(self):
8326 
    L = ['%s=%r' % (key, value)
8327 
      for key, value in self.__dict__.iteritems()]
8328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8329 
 
8330 
  def __eq__(self, other):
8331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8332 
 
8333 
  def __ne__(self, other):
8334 
    return not (self == other)
8335 
 
8336 
class createTransaction_result:
8337 
  """
8338 
  Attributes:
132 ashish 8339 
   - success
94 ashish 8340 
   - ex
8341 
  """
8342 
 
8343 
  thrift_spec = (
132 ashish 8344 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8346 
  )
8347 
 
132 ashish 8348 
  def __init__(self, success=None, ex=None,):
8349 
    self.success = success
94 ashish 8350 
    self.ex = ex
8351 
 
8352 
  def read(self, iprot):
8353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8355 
      return
8356 
    iprot.readStructBegin()
8357 
    while True:
8358 
      (fname, ftype, fid) = iprot.readFieldBegin()
8359 
      if ftype == TType.STOP:
8360 
        break
132 ashish 8361 
      if fid == 0:
8362 
        if ftype == TType.I64:
8363 
          self.success = iprot.readI64();
8364 
        else:
8365 
          iprot.skip(ftype)
8366 
      elif fid == 1:
94 ashish 8367 
        if ftype == TType.STRUCT:
8368 
          self.ex = TransactionServiceException()
8369 
          self.ex.read(iprot)
8370 
        else:
8371 
          iprot.skip(ftype)
8372 
      else:
8373 
        iprot.skip(ftype)
8374 
      iprot.readFieldEnd()
8375 
    iprot.readStructEnd()
8376 
 
8377 
  def write(self, oprot):
8378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8380 
      return
8381 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8382 
    if self.success is not None:
132 ashish 8383 
      oprot.writeFieldBegin('success', TType.I64, 0)
8384 
      oprot.writeI64(self.success)
8385 
      oprot.writeFieldEnd()
3431 rajveer 8386 
    if self.ex is not None:
94 ashish 8387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8388 
      self.ex.write(oprot)
8389 
      oprot.writeFieldEnd()
8390 
    oprot.writeFieldStop()
8391 
    oprot.writeStructEnd()
8392 
 
3431 rajveer 8393 
  def validate(self):
8394 
    return
8395 
 
8396 
 
94 ashish 8397 
  def __repr__(self):
8398 
    L = ['%s=%r' % (key, value)
8399 
      for key, value in self.__dict__.iteritems()]
8400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8401 
 
8402 
  def __eq__(self, other):
8403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8404 
 
8405 
  def __ne__(self, other):
8406 
    return not (self == other)
8407 
 
8408 
class getTransaction_args:
8409 
  """
8410 
  Attributes:
8411 
   - id
8412 
  """
8413 
 
8414 
  thrift_spec = (
8415 
    None, # 0
8416 
    (1, TType.I64, 'id', None, None, ), # 1
8417 
  )
8418 
 
8419 
  def __init__(self, id=None,):
8420 
    self.id = id
8421 
 
8422 
  def read(self, iprot):
8423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8425 
      return
8426 
    iprot.readStructBegin()
8427 
    while True:
8428 
      (fname, ftype, fid) = iprot.readFieldBegin()
8429 
      if ftype == TType.STOP:
8430 
        break
8431 
      if fid == 1:
8432 
        if ftype == TType.I64:
8433 
          self.id = iprot.readI64();
8434 
        else:
8435 
          iprot.skip(ftype)
8436 
      else:
8437 
        iprot.skip(ftype)
8438 
      iprot.readFieldEnd()
8439 
    iprot.readStructEnd()
8440 
 
8441 
  def write(self, oprot):
8442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8444 
      return
8445 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8446 
    if self.id is not None:
94 ashish 8447 
      oprot.writeFieldBegin('id', TType.I64, 1)
8448 
      oprot.writeI64(self.id)
8449 
      oprot.writeFieldEnd()
8450 
    oprot.writeFieldStop()
8451 
    oprot.writeStructEnd()
8452 
 
3431 rajveer 8453 
  def validate(self):
8454 
    return
8455 
 
8456 
 
94 ashish 8457 
  def __repr__(self):
8458 
    L = ['%s=%r' % (key, value)
8459 
      for key, value in self.__dict__.iteritems()]
8460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8461 
 
8462 
  def __eq__(self, other):
8463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8464 
 
8465 
  def __ne__(self, other):
8466 
    return not (self == other)
8467 
 
8468 
class getTransaction_result:
8469 
  """
8470 
  Attributes:
8471 
   - success
8472 
   - ex
8473 
  """
8474 
 
8475 
  thrift_spec = (
8476 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8478 
  )
8479 
 
8480 
  def __init__(self, success=None, ex=None,):
8481 
    self.success = success
8482 
    self.ex = ex
8483 
 
8484 
  def read(self, iprot):
8485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8487 
      return
8488 
    iprot.readStructBegin()
8489 
    while True:
8490 
      (fname, ftype, fid) = iprot.readFieldBegin()
8491 
      if ftype == TType.STOP:
8492 
        break
8493 
      if fid == 0:
8494 
        if ftype == TType.STRUCT:
8495 
          self.success = Transaction()
8496 
          self.success.read(iprot)
8497 
        else:
8498 
          iprot.skip(ftype)
8499 
      elif fid == 1:
8500 
        if ftype == TType.STRUCT:
8501 
          self.ex = TransactionServiceException()
8502 
          self.ex.read(iprot)
8503 
        else:
8504 
          iprot.skip(ftype)
8505 
      else:
8506 
        iprot.skip(ftype)
8507 
      iprot.readFieldEnd()
8508 
    iprot.readStructEnd()
8509 
 
8510 
  def write(self, oprot):
8511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8513 
      return
8514 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8515 
    if self.success is not None:
94 ashish 8516 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8517 
      self.success.write(oprot)
8518 
      oprot.writeFieldEnd()
3431 rajveer 8519 
    if self.ex is not None:
94 ashish 8520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8521 
      self.ex.write(oprot)
8522 
      oprot.writeFieldEnd()
8523 
    oprot.writeFieldStop()
8524 
    oprot.writeStructEnd()
8525 
 
3431 rajveer 8526 
  def validate(self):
8527 
    return
8528 
 
8529 
 
94 ashish 8530 
  def __repr__(self):
8531 
    L = ['%s=%r' % (key, value)
8532 
      for key, value in self.__dict__.iteritems()]
8533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8534 
 
8535 
  def __eq__(self, other):
8536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8537 
 
8538 
  def __ne__(self, other):
8539 
    return not (self == other)
8540 
 
8541 
class getTransactionsForCustomer_args:
8542 
  """
8543 
  Attributes:
8544 
   - customerId
8545 
   - from_date
8546 
   - to_date
8547 
   - status
8548 
  """
8549 
 
8550 
  thrift_spec = (
8551 
    None, # 0
8552 
    (1, TType.I64, 'customerId', None, None, ), # 1
8553 
    (2, TType.I64, 'from_date', None, None, ), # 2
8554 
    (3, TType.I64, 'to_date', None, None, ), # 3
8555 
    (4, TType.I32, 'status', None, None, ), # 4
8556 
  )
8557 
 
8558 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8559 
    self.customerId = customerId
8560 
    self.from_date = from_date
8561 
    self.to_date = to_date
8562 
    self.status = status
8563 
 
8564 
  def read(self, iprot):
8565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8567 
      return
8568 
    iprot.readStructBegin()
8569 
    while True:
8570 
      (fname, ftype, fid) = iprot.readFieldBegin()
8571 
      if ftype == TType.STOP:
8572 
        break
8573 
      if fid == 1:
8574 
        if ftype == TType.I64:
8575 
          self.customerId = iprot.readI64();
8576 
        else:
8577 
          iprot.skip(ftype)
8578 
      elif fid == 2:
8579 
        if ftype == TType.I64:
8580 
          self.from_date = iprot.readI64();
8581 
        else:
8582 
          iprot.skip(ftype)
8583 
      elif fid == 3:
8584 
        if ftype == TType.I64:
8585 
          self.to_date = iprot.readI64();
8586 
        else:
8587 
          iprot.skip(ftype)
8588 
      elif fid == 4:
8589 
        if ftype == TType.I32:
8590 
          self.status = iprot.readI32();
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      else:
8594 
        iprot.skip(ftype)
8595 
      iprot.readFieldEnd()
8596 
    iprot.readStructEnd()
8597 
 
8598 
  def write(self, oprot):
8599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8601 
      return
8602 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8603 
    if self.customerId is not None:
94 ashish 8604 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8605 
      oprot.writeI64(self.customerId)
8606 
      oprot.writeFieldEnd()
3431 rajveer 8607 
    if self.from_date is not None:
94 ashish 8608 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8609 
      oprot.writeI64(self.from_date)
8610 
      oprot.writeFieldEnd()
3431 rajveer 8611 
    if self.to_date is not None:
94 ashish 8612 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8613 
      oprot.writeI64(self.to_date)
8614 
      oprot.writeFieldEnd()
3431 rajveer 8615 
    if self.status is not None:
94 ashish 8616 
      oprot.writeFieldBegin('status', TType.I32, 4)
8617 
      oprot.writeI32(self.status)
8618 
      oprot.writeFieldEnd()
8619 
    oprot.writeFieldStop()
8620 
    oprot.writeStructEnd()
8621 
 
3431 rajveer 8622 
  def validate(self):
8623 
    return
8624 
 
8625 
 
94 ashish 8626 
  def __repr__(self):
8627 
    L = ['%s=%r' % (key, value)
8628 
      for key, value in self.__dict__.iteritems()]
8629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8630 
 
8631 
  def __eq__(self, other):
8632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8633 
 
8634 
  def __ne__(self, other):
8635 
    return not (self == other)
8636 
 
8637 
class getTransactionsForCustomer_result:
8638 
  """
8639 
  Attributes:
8640 
   - success
8641 
   - ex
8642 
  """
8643 
 
8644 
  thrift_spec = (
8645 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8647 
  )
8648 
 
8649 
  def __init__(self, success=None, ex=None,):
8650 
    self.success = success
8651 
    self.ex = ex
8652 
 
8653 
  def read(self, iprot):
8654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8656 
      return
8657 
    iprot.readStructBegin()
8658 
    while True:
8659 
      (fname, ftype, fid) = iprot.readFieldBegin()
8660 
      if ftype == TType.STOP:
8661 
        break
8662 
      if fid == 0:
8663 
        if ftype == TType.LIST:
8664 
          self.success = []
6031 rajveer 8665 
          (_etype66, _size63) = iprot.readListBegin()
8666 
          for _i67 in xrange(_size63):
8667 
            _elem68 = Transaction()
8668 
            _elem68.read(iprot)
8669 
            self.success.append(_elem68)
94 ashish 8670 
          iprot.readListEnd()
8671 
        else:
8672 
          iprot.skip(ftype)
8673 
      elif fid == 1:
8674 
        if ftype == TType.STRUCT:
8675 
          self.ex = TransactionServiceException()
8676 
          self.ex.read(iprot)
8677 
        else:
8678 
          iprot.skip(ftype)
8679 
      else:
8680 
        iprot.skip(ftype)
8681 
      iprot.readFieldEnd()
8682 
    iprot.readStructEnd()
8683 
 
8684 
  def write(self, oprot):
8685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8687 
      return
8688 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8689 
    if self.success is not None:
94 ashish 8690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8692 
      for iter69 in self.success:
8693 
        iter69.write(oprot)
94 ashish 8694 
      oprot.writeListEnd()
8695 
      oprot.writeFieldEnd()
3431 rajveer 8696 
    if self.ex is not None:
94 ashish 8697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8698 
      self.ex.write(oprot)
8699 
      oprot.writeFieldEnd()
8700 
    oprot.writeFieldStop()
8701 
    oprot.writeStructEnd()
8702 
 
3431 rajveer 8703 
  def validate(self):
8704 
    return
8705 
 
8706 
 
94 ashish 8707 
  def __repr__(self):
8708 
    L = ['%s=%r' % (key, value)
8709 
      for key, value in self.__dict__.iteritems()]
8710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8711 
 
8712 
  def __eq__(self, other):
8713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8714 
 
8715 
  def __ne__(self, other):
8716 
    return not (self == other)
8717 
 
132 ashish 8718 
class getTransactionsForShoppingCartId_args:
8719 
  """
8720 
  Attributes:
8721 
   - shoppingCartId
8722 
  """
8723 
 
8724 
  thrift_spec = (
8725 
    None, # 0
8726 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8727 
  )
8728 
 
8729 
  def __init__(self, shoppingCartId=None,):
8730 
    self.shoppingCartId = shoppingCartId
8731 
 
8732 
  def read(self, iprot):
8733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8735 
      return
8736 
    iprot.readStructBegin()
8737 
    while True:
8738 
      (fname, ftype, fid) = iprot.readFieldBegin()
8739 
      if ftype == TType.STOP:
8740 
        break
8741 
      if fid == 1:
8742 
        if ftype == TType.I64:
8743 
          self.shoppingCartId = iprot.readI64();
8744 
        else:
8745 
          iprot.skip(ftype)
8746 
      else:
8747 
        iprot.skip(ftype)
8748 
      iprot.readFieldEnd()
8749 
    iprot.readStructEnd()
8750 
 
8751 
  def write(self, oprot):
8752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8754 
      return
8755 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8756 
    if self.shoppingCartId is not None:
132 ashish 8757 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8758 
      oprot.writeI64(self.shoppingCartId)
8759 
      oprot.writeFieldEnd()
8760 
    oprot.writeFieldStop()
8761 
    oprot.writeStructEnd()
8762 
 
3431 rajveer 8763 
  def validate(self):
8764 
    return
8765 
 
8766 
 
132 ashish 8767 
  def __repr__(self):
8768 
    L = ['%s=%r' % (key, value)
8769 
      for key, value in self.__dict__.iteritems()]
8770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8771 
 
8772 
  def __eq__(self, other):
8773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8774 
 
8775 
  def __ne__(self, other):
8776 
    return not (self == other)
8777 
 
8778 
class getTransactionsForShoppingCartId_result:
8779 
  """
8780 
  Attributes:
8781 
   - success
8782 
   - ex
8783 
  """
8784 
 
8785 
  thrift_spec = (
8786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8787 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8788 
  )
8789 
 
8790 
  def __init__(self, success=None, ex=None,):
8791 
    self.success = success
8792 
    self.ex = ex
8793 
 
8794 
  def read(self, iprot):
8795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8797 
      return
8798 
    iprot.readStructBegin()
8799 
    while True:
8800 
      (fname, ftype, fid) = iprot.readFieldBegin()
8801 
      if ftype == TType.STOP:
8802 
        break
8803 
      if fid == 0:
8804 
        if ftype == TType.LIST:
8805 
          self.success = []
6031 rajveer 8806 
          (_etype73, _size70) = iprot.readListBegin()
8807 
          for _i74 in xrange(_size70):
8808 
            _elem75 = Transaction()
8809 
            _elem75.read(iprot)
8810 
            self.success.append(_elem75)
132 ashish 8811 
          iprot.readListEnd()
8812 
        else:
8813 
          iprot.skip(ftype)
8814 
      elif fid == 1:
8815 
        if ftype == TType.STRUCT:
8816 
          self.ex = TransactionServiceException()
8817 
          self.ex.read(iprot)
8818 
        else:
8819 
          iprot.skip(ftype)
8820 
      else:
8821 
        iprot.skip(ftype)
8822 
      iprot.readFieldEnd()
8823 
    iprot.readStructEnd()
8824 
 
8825 
  def write(self, oprot):
8826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8828 
      return
8829 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8830 
    if self.success is not None:
132 ashish 8831 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8832 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8833 
      for iter76 in self.success:
8834 
        iter76.write(oprot)
132 ashish 8835 
      oprot.writeListEnd()
8836 
      oprot.writeFieldEnd()
3431 rajveer 8837 
    if self.ex is not None:
132 ashish 8838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8839 
      self.ex.write(oprot)
8840 
      oprot.writeFieldEnd()
8841 
    oprot.writeFieldStop()
8842 
    oprot.writeStructEnd()
8843 
 
3431 rajveer 8844 
  def validate(self):
8845 
    return
8846 
 
8847 
 
132 ashish 8848 
  def __repr__(self):
8849 
    L = ['%s=%r' % (key, value)
8850 
      for key, value in self.__dict__.iteritems()]
8851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8852 
 
8853 
  def __eq__(self, other):
8854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8855 
 
8856 
  def __ne__(self, other):
8857 
    return not (self == other)
8858 
 
94 ashish 8859 
class getTransactionStatus_args:
8860 
  """
8861 
  Attributes:
8862 
   - transactionId
8863 
  """
8864 
 
8865 
  thrift_spec = (
8866 
    None, # 0
8867 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8868 
  )
8869 
 
8870 
  def __init__(self, transactionId=None,):
8871 
    self.transactionId = transactionId
8872 
 
8873 
  def read(self, iprot):
8874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8876 
      return
8877 
    iprot.readStructBegin()
8878 
    while True:
8879 
      (fname, ftype, fid) = iprot.readFieldBegin()
8880 
      if ftype == TType.STOP:
8881 
        break
8882 
      if fid == 1:
8883 
        if ftype == TType.I64:
8884 
          self.transactionId = iprot.readI64();
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      else:
8888 
        iprot.skip(ftype)
8889 
      iprot.readFieldEnd()
8890 
    iprot.readStructEnd()
8891 
 
8892 
  def write(self, oprot):
8893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8895 
      return
8896 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8897 
    if self.transactionId is not None:
94 ashish 8898 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8899 
      oprot.writeI64(self.transactionId)
8900 
      oprot.writeFieldEnd()
8901 
    oprot.writeFieldStop()
8902 
    oprot.writeStructEnd()
8903 
 
3431 rajveer 8904 
  def validate(self):
8905 
    return
8906 
 
8907 
 
94 ashish 8908 
  def __repr__(self):
8909 
    L = ['%s=%r' % (key, value)
8910 
      for key, value in self.__dict__.iteritems()]
8911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8912 
 
8913 
  def __eq__(self, other):
8914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8915 
 
8916 
  def __ne__(self, other):
8917 
    return not (self == other)
8918 
 
8919 
class getTransactionStatus_result:
8920 
  """
8921 
  Attributes:
8922 
   - success
8923 
   - ex
8924 
  """
8925 
 
8926 
  thrift_spec = (
8927 
    (0, TType.I32, 'success', None, None, ), # 0
8928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8929 
  )
8930 
 
8931 
  def __init__(self, success=None, ex=None,):
8932 
    self.success = success
8933 
    self.ex = ex
8934 
 
8935 
  def read(self, iprot):
8936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8938 
      return
8939 
    iprot.readStructBegin()
8940 
    while True:
8941 
      (fname, ftype, fid) = iprot.readFieldBegin()
8942 
      if ftype == TType.STOP:
8943 
        break
8944 
      if fid == 0:
8945 
        if ftype == TType.I32:
8946 
          self.success = iprot.readI32();
8947 
        else:
8948 
          iprot.skip(ftype)
8949 
      elif fid == 1:
8950 
        if ftype == TType.STRUCT:
8951 
          self.ex = TransactionServiceException()
8952 
          self.ex.read(iprot)
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      else:
8956 
        iprot.skip(ftype)
8957 
      iprot.readFieldEnd()
8958 
    iprot.readStructEnd()
8959 
 
8960 
  def write(self, oprot):
8961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8963 
      return
8964 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8965 
    if self.success is not None:
94 ashish 8966 
      oprot.writeFieldBegin('success', TType.I32, 0)
8967 
      oprot.writeI32(self.success)
8968 
      oprot.writeFieldEnd()
3431 rajveer 8969 
    if self.ex is not None:
94 ashish 8970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8971 
      self.ex.write(oprot)
8972 
      oprot.writeFieldEnd()
8973 
    oprot.writeFieldStop()
8974 
    oprot.writeStructEnd()
8975 
 
3431 rajveer 8976 
  def validate(self):
8977 
    return
8978 
 
8979 
 
94 ashish 8980 
  def __repr__(self):
8981 
    L = ['%s=%r' % (key, value)
8982 
      for key, value in self.__dict__.iteritems()]
8983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8984 
 
8985 
  def __eq__(self, other):
8986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8987 
 
8988 
  def __ne__(self, other):
8989 
    return not (self == other)
8990 
 
8991 
class changeTransactionStatus_args:
8992 
  """
8993 
  Attributes:
8994 
   - transactionId
8995 
   - status
8996 
   - description
5527 anupam.sin 8997 
   - pickUp
8998 
   - orderType
94 ashish 8999 
  """
9000 
 
9001 
  thrift_spec = (
9002 
    None, # 0
9003 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9004 
    (2, TType.I32, 'status', None, None, ), # 2
9005 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9006 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9007 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9008 
  )
9009 
 
5527 anupam.sin 9010 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9011 
    self.transactionId = transactionId
9012 
    self.status = status
9013 
    self.description = description
5527 anupam.sin 9014 
    self.pickUp = pickUp
9015 
    self.orderType = orderType
94 ashish 9016 
 
9017 
  def read(self, iprot):
9018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9020 
      return
9021 
    iprot.readStructBegin()
9022 
    while True:
9023 
      (fname, ftype, fid) = iprot.readFieldBegin()
9024 
      if ftype == TType.STOP:
9025 
        break
9026 
      if fid == 1:
9027 
        if ftype == TType.I64:
9028 
          self.transactionId = iprot.readI64();
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      elif fid == 2:
9032 
        if ftype == TType.I32:
9033 
          self.status = iprot.readI32();
9034 
        else:
9035 
          iprot.skip(ftype)
9036 
      elif fid == 3:
9037 
        if ftype == TType.STRING:
9038 
          self.description = iprot.readString();
9039 
        else:
9040 
          iprot.skip(ftype)
5387 rajveer 9041 
      elif fid == 4:
5527 anupam.sin 9042 
        if ftype == TType.I64:
9043 
          self.pickUp = iprot.readI64();
5387 rajveer 9044 
        else:
9045 
          iprot.skip(ftype)
5527 anupam.sin 9046 
      elif fid == 5:
9047 
        if ftype == TType.I32:
9048 
          self.orderType = iprot.readI32();
9049 
        else:
9050 
          iprot.skip(ftype)
94 ashish 9051 
      else:
9052 
        iprot.skip(ftype)
9053 
      iprot.readFieldEnd()
9054 
    iprot.readStructEnd()
9055 
 
9056 
  def write(self, oprot):
9057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9059 
      return
9060 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9061 
    if self.transactionId is not None:
94 ashish 9062 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9063 
      oprot.writeI64(self.transactionId)
9064 
      oprot.writeFieldEnd()
3431 rajveer 9065 
    if self.status is not None:
94 ashish 9066 
      oprot.writeFieldBegin('status', TType.I32, 2)
9067 
      oprot.writeI32(self.status)
9068 
      oprot.writeFieldEnd()
3431 rajveer 9069 
    if self.description is not None:
94 ashish 9070 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9071 
      oprot.writeString(self.description)
9072 
      oprot.writeFieldEnd()
5527 anupam.sin 9073 
    if self.pickUp is not None:
9074 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9075 
      oprot.writeI64(self.pickUp)
5387 rajveer 9076 
      oprot.writeFieldEnd()
5527 anupam.sin 9077 
    if self.orderType is not None:
9078 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9079 
      oprot.writeI32(self.orderType)
9080 
      oprot.writeFieldEnd()
94 ashish 9081 
    oprot.writeFieldStop()
9082 
    oprot.writeStructEnd()
9083 
 
3431 rajveer 9084 
  def validate(self):
9085 
    return
9086 
 
9087 
 
94 ashish 9088 
  def __repr__(self):
9089 
    L = ['%s=%r' % (key, value)
9090 
      for key, value in self.__dict__.iteritems()]
9091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9092 
 
9093 
  def __eq__(self, other):
9094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9095 
 
9096 
  def __ne__(self, other):
9097 
    return not (self == other)
9098 
 
9099 
class changeTransactionStatus_result:
9100 
  """
9101 
  Attributes:
9102 
   - success
9103 
   - ex
9104 
  """
9105 
 
9106 
  thrift_spec = (
9107 
    (0, TType.BOOL, 'success', None, None, ), # 0
9108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9109 
  )
9110 
 
9111 
  def __init__(self, success=None, ex=None,):
9112 
    self.success = success
9113 
    self.ex = ex
9114 
 
9115 
  def read(self, iprot):
9116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9118 
      return
9119 
    iprot.readStructBegin()
9120 
    while True:
9121 
      (fname, ftype, fid) = iprot.readFieldBegin()
9122 
      if ftype == TType.STOP:
9123 
        break
9124 
      if fid == 0:
9125 
        if ftype == TType.BOOL:
9126 
          self.success = iprot.readBool();
9127 
        else:
9128 
          iprot.skip(ftype)
9129 
      elif fid == 1:
9130 
        if ftype == TType.STRUCT:
9131 
          self.ex = TransactionServiceException()
9132 
          self.ex.read(iprot)
9133 
        else:
9134 
          iprot.skip(ftype)
9135 
      else:
9136 
        iprot.skip(ftype)
9137 
      iprot.readFieldEnd()
9138 
    iprot.readStructEnd()
9139 
 
9140 
  def write(self, oprot):
9141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9143 
      return
9144 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9145 
    if self.success is not None:
94 ashish 9146 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9147 
      oprot.writeBool(self.success)
9148 
      oprot.writeFieldEnd()
3431 rajveer 9149 
    if self.ex is not None:
94 ashish 9150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9151 
      self.ex.write(oprot)
9152 
      oprot.writeFieldEnd()
9153 
    oprot.writeFieldStop()
9154 
    oprot.writeStructEnd()
9155 
 
3431 rajveer 9156 
  def validate(self):
9157 
    return
9158 
 
9159 
 
94 ashish 9160 
  def __repr__(self):
9161 
    L = ['%s=%r' % (key, value)
9162 
      for key, value in self.__dict__.iteritems()]
9163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9164 
 
9165 
  def __eq__(self, other):
9166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9167 
 
9168 
  def __ne__(self, other):
9169 
    return not (self == other)
9170 
 
1398 varun.gupt 9171 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9172 
  """
9173 
  Attributes:
9174 
   - transactionId
9175 
  """
9176 
 
9177 
  thrift_spec = (
9178 
    None, # 0
9179 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9180 
  )
9181 
 
9182 
  def __init__(self, transactionId=None,):
9183 
    self.transactionId = transactionId
9184 
 
9185 
  def read(self, iprot):
9186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9188 
      return
9189 
    iprot.readStructBegin()
9190 
    while True:
9191 
      (fname, ftype, fid) = iprot.readFieldBegin()
9192 
      if ftype == TType.STOP:
9193 
        break
9194 
      if fid == 1:
9195 
        if ftype == TType.I64:
9196 
          self.transactionId = iprot.readI64();
9197 
        else:
9198 
          iprot.skip(ftype)
9199 
      else:
9200 
        iprot.skip(ftype)
9201 
      iprot.readFieldEnd()
9202 
    iprot.readStructEnd()
9203 
 
9204 
  def write(self, oprot):
9205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9207 
      return
1398 varun.gupt 9208 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9209 
    if self.transactionId is not None:
1382 varun.gupt 9210 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9211 
      oprot.writeI64(self.transactionId)
9212 
      oprot.writeFieldEnd()
9213 
    oprot.writeFieldStop()
9214 
    oprot.writeStructEnd()
9215 
 
3431 rajveer 9216 
  def validate(self):
9217 
    return
9218 
 
9219 
 
1382 varun.gupt 9220 
  def __repr__(self):
9221 
    L = ['%s=%r' % (key, value)
9222 
      for key, value in self.__dict__.iteritems()]
9223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9224 
 
9225 
  def __eq__(self, other):
9226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9227 
 
9228 
  def __ne__(self, other):
9229 
    return not (self == other)
9230 
 
1398 varun.gupt 9231 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9232 
  """
9233 
  Attributes:
9234 
   - success
9235 
   - ex
9236 
  """
9237 
 
9238 
  thrift_spec = (
9239 
    (0, TType.BOOL, 'success', None, None, ), # 0
9240 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9241 
  )
9242 
 
9243 
  def __init__(self, success=None, ex=None,):
9244 
    self.success = success
9245 
    self.ex = ex
9246 
 
9247 
  def read(self, iprot):
9248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9250 
      return
9251 
    iprot.readStructBegin()
9252 
    while True:
9253 
      (fname, ftype, fid) = iprot.readFieldBegin()
9254 
      if ftype == TType.STOP:
9255 
        break
9256 
      if fid == 0:
9257 
        if ftype == TType.BOOL:
9258 
          self.success = iprot.readBool();
9259 
        else:
9260 
          iprot.skip(ftype)
9261 
      elif fid == 1:
9262 
        if ftype == TType.STRUCT:
9263 
          self.ex = TransactionServiceException()
9264 
          self.ex.read(iprot)
9265 
        else:
9266 
          iprot.skip(ftype)
9267 
      else:
9268 
        iprot.skip(ftype)
9269 
      iprot.readFieldEnd()
9270 
    iprot.readStructEnd()
9271 
 
9272 
  def write(self, oprot):
9273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9275 
      return
1398 varun.gupt 9276 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9277 
    if self.success is not None:
1382 varun.gupt 9278 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9279 
      oprot.writeBool(self.success)
9280 
      oprot.writeFieldEnd()
3431 rajveer 9281 
    if self.ex is not None:
1382 varun.gupt 9282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9283 
      self.ex.write(oprot)
9284 
      oprot.writeFieldEnd()
9285 
    oprot.writeFieldStop()
9286 
    oprot.writeStructEnd()
9287 
 
3431 rajveer 9288 
  def validate(self):
9289 
    return
9290 
 
9291 
 
1382 varun.gupt 9292 
  def __repr__(self):
9293 
    L = ['%s=%r' % (key, value)
9294 
      for key, value in self.__dict__.iteritems()]
9295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9296 
 
9297 
  def __eq__(self, other):
9298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9299 
 
9300 
  def __ne__(self, other):
9301 
    return not (self == other)
9302 
 
483 rajveer 9303 
class getAllOrders_args:
94 ashish 9304 
  """
9305 
  Attributes:
4801 anupam.sin 9306 
   - statuses
483 rajveer 9307 
   - from_date
9308 
   - to_date
9309 
   - warehouse_id
94 ashish 9310 
  """
9311 
 
9312 
  thrift_spec = (
9313 
    None, # 0
4801 anupam.sin 9314 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9315 
    (2, TType.I64, 'from_date', None, None, ), # 2
9316 
    (3, TType.I64, 'to_date', None, None, ), # 3
9317 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9318 
  )
9319 
 
4801 anupam.sin 9320 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9321 
    self.statuses = statuses
483 rajveer 9322 
    self.from_date = from_date
9323 
    self.to_date = to_date
9324 
    self.warehouse_id = warehouse_id
94 ashish 9325 
 
9326 
  def read(self, iprot):
9327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9329 
      return
9330 
    iprot.readStructBegin()
9331 
    while True:
9332 
      (fname, ftype, fid) = iprot.readFieldBegin()
9333 
      if ftype == TType.STOP:
9334 
        break
9335 
      if fid == 1:
4801 anupam.sin 9336 
        if ftype == TType.LIST:
9337 
          self.statuses = []
6031 rajveer 9338 
          (_etype80, _size77) = iprot.readListBegin()
9339 
          for _i81 in xrange(_size77):
9340 
            _elem82 = iprot.readI32();
9341 
            self.statuses.append(_elem82)
4801 anupam.sin 9342 
          iprot.readListEnd()
94 ashish 9343 
        else:
9344 
          iprot.skip(ftype)
483 rajveer 9345 
      elif fid == 2:
9346 
        if ftype == TType.I64:
9347 
          self.from_date = iprot.readI64();
94 ashish 9348 
        else:
9349 
          iprot.skip(ftype)
483 rajveer 9350 
      elif fid == 3:
9351 
        if ftype == TType.I64:
9352 
          self.to_date = iprot.readI64();
94 ashish 9353 
        else:
9354 
          iprot.skip(ftype)
483 rajveer 9355 
      elif fid == 4:
94 ashish 9356 
        if ftype == TType.I64:
483 rajveer 9357 
          self.warehouse_id = iprot.readI64();
94 ashish 9358 
        else:
9359 
          iprot.skip(ftype)
9360 
      else:
9361 
        iprot.skip(ftype)
9362 
      iprot.readFieldEnd()
9363 
    iprot.readStructEnd()
9364 
 
9365 
  def write(self, oprot):
9366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9368 
      return
483 rajveer 9369 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9370 
    if self.statuses is not None:
9371 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9372 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9373 
      for iter83 in self.statuses:
9374 
        oprot.writeI32(iter83)
4801 anupam.sin 9375 
      oprot.writeListEnd()
94 ashish 9376 
      oprot.writeFieldEnd()
3431 rajveer 9377 
    if self.from_date is not None:
483 rajveer 9378 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9379 
      oprot.writeI64(self.from_date)
94 ashish 9380 
      oprot.writeFieldEnd()
3431 rajveer 9381 
    if self.to_date is not None:
483 rajveer 9382 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9383 
      oprot.writeI64(self.to_date)
94 ashish 9384 
      oprot.writeFieldEnd()
3431 rajveer 9385 
    if self.warehouse_id is not None:
483 rajveer 9386 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9387 
      oprot.writeI64(self.warehouse_id)
94 ashish 9388 
      oprot.writeFieldEnd()
9389 
    oprot.writeFieldStop()
9390 
    oprot.writeStructEnd()
9391 
 
3431 rajveer 9392 
  def validate(self):
9393 
    return
9394 
 
9395 
 
94 ashish 9396 
  def __repr__(self):
9397 
    L = ['%s=%r' % (key, value)
9398 
      for key, value in self.__dict__.iteritems()]
9399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9400 
 
9401 
  def __eq__(self, other):
9402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9403 
 
9404 
  def __ne__(self, other):
9405 
    return not (self == other)
9406 
 
483 rajveer 9407 
class getAllOrders_result:
94 ashish 9408 
  """
9409 
  Attributes:
9410 
   - success
9411 
   - ex
9412 
  """
9413 
 
9414 
  thrift_spec = (
483 rajveer 9415 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9417 
  )
9418 
 
9419 
  def __init__(self, success=None, ex=None,):
9420 
    self.success = success
9421 
    self.ex = ex
9422 
 
9423 
  def read(self, iprot):
9424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9426 
      return
9427 
    iprot.readStructBegin()
9428 
    while True:
9429 
      (fname, ftype, fid) = iprot.readFieldBegin()
9430 
      if ftype == TType.STOP:
9431 
        break
9432 
      if fid == 0:
483 rajveer 9433 
        if ftype == TType.LIST:
9434 
          self.success = []
6031 rajveer 9435 
          (_etype87, _size84) = iprot.readListBegin()
9436 
          for _i88 in xrange(_size84):
9437 
            _elem89 = Order()
9438 
            _elem89.read(iprot)
9439 
            self.success.append(_elem89)
483 rajveer 9440 
          iprot.readListEnd()
94 ashish 9441 
        else:
9442 
          iprot.skip(ftype)
9443 
      elif fid == 1:
9444 
        if ftype == TType.STRUCT:
9445 
          self.ex = TransactionServiceException()
9446 
          self.ex.read(iprot)
9447 
        else:
9448 
          iprot.skip(ftype)
9449 
      else:
9450 
        iprot.skip(ftype)
9451 
      iprot.readFieldEnd()
9452 
    iprot.readStructEnd()
9453 
 
9454 
  def write(self, oprot):
9455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9457 
      return
483 rajveer 9458 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9459 
    if self.success is not None:
483 rajveer 9460 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9461 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9462 
      for iter90 in self.success:
9463 
        iter90.write(oprot)
483 rajveer 9464 
      oprot.writeListEnd()
94 ashish 9465 
      oprot.writeFieldEnd()
3431 rajveer 9466 
    if self.ex is not None:
94 ashish 9467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9468 
      self.ex.write(oprot)
9469 
      oprot.writeFieldEnd()
9470 
    oprot.writeFieldStop()
9471 
    oprot.writeStructEnd()
9472 
 
3431 rajveer 9473 
  def validate(self):
9474 
    return
9475 
 
9476 
 
94 ashish 9477 
  def __repr__(self):
9478 
    L = ['%s=%r' % (key, value)
9479 
      for key, value in self.__dict__.iteritems()]
9480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9481 
 
9482 
  def __eq__(self, other):
9483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9484 
 
9485 
  def __ne__(self, other):
9486 
    return not (self == other)
9487 
 
4133 chandransh 9488 
class getOrdersInBatch_args:
9489 
  """
9490 
  Attributes:
9491 
   - statuses
9492 
   - offset
9493 
   - limit
9494 
   - warehouse_id
9495 
  """
9496 
 
9497 
  thrift_spec = (
9498 
    None, # 0
9499 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9500 
    (2, TType.I64, 'offset', None, None, ), # 2
9501 
    (3, TType.I64, 'limit', None, None, ), # 3
9502 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9503 
  )
9504 
 
9505 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9506 
    self.statuses = statuses
9507 
    self.offset = offset
9508 
    self.limit = limit
9509 
    self.warehouse_id = warehouse_id
9510 
 
9511 
  def read(self, iprot):
9512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9514 
      return
9515 
    iprot.readStructBegin()
9516 
    while True:
9517 
      (fname, ftype, fid) = iprot.readFieldBegin()
9518 
      if ftype == TType.STOP:
9519 
        break
9520 
      if fid == 1:
9521 
        if ftype == TType.LIST:
9522 
          self.statuses = []
6031 rajveer 9523 
          (_etype94, _size91) = iprot.readListBegin()
9524 
          for _i95 in xrange(_size91):
9525 
            _elem96 = iprot.readI32();
9526 
            self.statuses.append(_elem96)
4133 chandransh 9527 
          iprot.readListEnd()
9528 
        else:
9529 
          iprot.skip(ftype)
9530 
      elif fid == 2:
9531 
        if ftype == TType.I64:
9532 
          self.offset = iprot.readI64();
9533 
        else:
9534 
          iprot.skip(ftype)
9535 
      elif fid == 3:
9536 
        if ftype == TType.I64:
9537 
          self.limit = iprot.readI64();
9538 
        else:
9539 
          iprot.skip(ftype)
9540 
      elif fid == 4:
9541 
        if ftype == TType.I64:
9542 
          self.warehouse_id = iprot.readI64();
9543 
        else:
9544 
          iprot.skip(ftype)
9545 
      else:
9546 
        iprot.skip(ftype)
9547 
      iprot.readFieldEnd()
9548 
    iprot.readStructEnd()
9549 
 
9550 
  def write(self, oprot):
9551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9553 
      return
9554 
    oprot.writeStructBegin('getOrdersInBatch_args')
9555 
    if self.statuses is not None:
9556 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9557 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9558 
      for iter97 in self.statuses:
9559 
        oprot.writeI32(iter97)
4133 chandransh 9560 
      oprot.writeListEnd()
9561 
      oprot.writeFieldEnd()
9562 
    if self.offset is not None:
9563 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9564 
      oprot.writeI64(self.offset)
9565 
      oprot.writeFieldEnd()
9566 
    if self.limit is not None:
9567 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9568 
      oprot.writeI64(self.limit)
9569 
      oprot.writeFieldEnd()
9570 
    if self.warehouse_id is not None:
9571 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9572 
      oprot.writeI64(self.warehouse_id)
9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
9577 
  def validate(self):
9578 
    return
9579 
 
9580 
 
9581 
  def __repr__(self):
9582 
    L = ['%s=%r' % (key, value)
9583 
      for key, value in self.__dict__.iteritems()]
9584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9585 
 
9586 
  def __eq__(self, other):
9587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9588 
 
9589 
  def __ne__(self, other):
9590 
    return not (self == other)
9591 
 
9592 
class getOrdersInBatch_result:
9593 
  """
9594 
  Attributes:
9595 
   - success
9596 
   - ex
9597 
  """
9598 
 
9599 
  thrift_spec = (
9600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9602 
  )
9603 
 
9604 
  def __init__(self, success=None, ex=None,):
9605 
    self.success = success
9606 
    self.ex = ex
9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      if fid == 0:
9618 
        if ftype == TType.LIST:
9619 
          self.success = []
6031 rajveer 9620 
          (_etype101, _size98) = iprot.readListBegin()
9621 
          for _i102 in xrange(_size98):
9622 
            _elem103 = Order()
9623 
            _elem103.read(iprot)
9624 
            self.success.append(_elem103)
4133 chandransh 9625 
          iprot.readListEnd()
9626 
        else:
9627 
          iprot.skip(ftype)
9628 
      elif fid == 1:
9629 
        if ftype == TType.STRUCT:
9630 
          self.ex = TransactionServiceException()
9631 
          self.ex.read(iprot)
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
9643 
    oprot.writeStructBegin('getOrdersInBatch_result')
9644 
    if self.success is not None:
9645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9647 
      for iter104 in self.success:
9648 
        iter104.write(oprot)
4133 chandransh 9649 
      oprot.writeListEnd()
9650 
      oprot.writeFieldEnd()
9651 
    if self.ex is not None:
9652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9653 
      self.ex.write(oprot)
9654 
      oprot.writeFieldEnd()
9655 
    oprot.writeFieldStop()
9656 
    oprot.writeStructEnd()
9657 
 
9658 
  def validate(self):
9659 
    return
9660 
 
9661 
 
9662 
  def __repr__(self):
9663 
    L = ['%s=%r' % (key, value)
9664 
      for key, value in self.__dict__.iteritems()]
9665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9666 
 
9667 
  def __eq__(self, other):
9668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9669 
 
9670 
  def __ne__(self, other):
9671 
    return not (self == other)
9672 
 
9673 
class getOrderCount_args:
9674 
  """
9675 
  Attributes:
9676 
   - statuses
9677 
   - warehouseId
9678 
  """
9679 
 
9680 
  thrift_spec = (
9681 
    None, # 0
9682 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9683 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9684 
  )
9685 
 
9686 
  def __init__(self, statuses=None, warehouseId=None,):
9687 
    self.statuses = statuses
9688 
    self.warehouseId = warehouseId
9689 
 
9690 
  def read(self, iprot):
9691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9693 
      return
9694 
    iprot.readStructBegin()
9695 
    while True:
9696 
      (fname, ftype, fid) = iprot.readFieldBegin()
9697 
      if ftype == TType.STOP:
9698 
        break
9699 
      if fid == 1:
9700 
        if ftype == TType.LIST:
9701 
          self.statuses = []
6031 rajveer 9702 
          (_etype108, _size105) = iprot.readListBegin()
9703 
          for _i109 in xrange(_size105):
9704 
            _elem110 = iprot.readI32();
9705 
            self.statuses.append(_elem110)
4133 chandransh 9706 
          iprot.readListEnd()
9707 
        else:
9708 
          iprot.skip(ftype)
9709 
      elif fid == 2:
9710 
        if ftype == TType.I64:
9711 
          self.warehouseId = iprot.readI64();
9712 
        else:
9713 
          iprot.skip(ftype)
9714 
      else:
9715 
        iprot.skip(ftype)
9716 
      iprot.readFieldEnd()
9717 
    iprot.readStructEnd()
9718 
 
9719 
  def write(self, oprot):
9720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9722 
      return
9723 
    oprot.writeStructBegin('getOrderCount_args')
9724 
    if self.statuses is not None:
9725 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9726 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9727 
      for iter111 in self.statuses:
9728 
        oprot.writeI32(iter111)
4133 chandransh 9729 
      oprot.writeListEnd()
9730 
      oprot.writeFieldEnd()
9731 
    if self.warehouseId is not None:
9732 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9733 
      oprot.writeI64(self.warehouseId)
9734 
      oprot.writeFieldEnd()
9735 
    oprot.writeFieldStop()
9736 
    oprot.writeStructEnd()
9737 
 
9738 
  def validate(self):
9739 
    return
9740 
 
9741 
 
9742 
  def __repr__(self):
9743 
    L = ['%s=%r' % (key, value)
9744 
      for key, value in self.__dict__.iteritems()]
9745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9746 
 
9747 
  def __eq__(self, other):
9748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9749 
 
9750 
  def __ne__(self, other):
9751 
    return not (self == other)
9752 
 
9753 
class getOrderCount_result:
9754 
  """
9755 
  Attributes:
9756 
   - success
9757 
   - ex
9758 
  """
9759 
 
9760 
  thrift_spec = (
9761 
    (0, TType.I32, 'success', None, None, ), # 0
9762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9763 
  )
9764 
 
9765 
  def __init__(self, success=None, ex=None,):
9766 
    self.success = success
9767 
    self.ex = ex
9768 
 
9769 
  def read(self, iprot):
9770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9772 
      return
9773 
    iprot.readStructBegin()
9774 
    while True:
9775 
      (fname, ftype, fid) = iprot.readFieldBegin()
9776 
      if ftype == TType.STOP:
9777 
        break
9778 
      if fid == 0:
9779 
        if ftype == TType.I32:
9780 
          self.success = iprot.readI32();
9781 
        else:
9782 
          iprot.skip(ftype)
9783 
      elif fid == 1:
9784 
        if ftype == TType.STRUCT:
9785 
          self.ex = TransactionServiceException()
9786 
          self.ex.read(iprot)
9787 
        else:
9788 
          iprot.skip(ftype)
9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
9798 
    oprot.writeStructBegin('getOrderCount_result')
9799 
    if self.success is not None:
9800 
      oprot.writeFieldBegin('success', TType.I32, 0)
9801 
      oprot.writeI32(self.success)
9802 
      oprot.writeFieldEnd()
9803 
    if self.ex is not None:
9804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9805 
      self.ex.write(oprot)
9806 
      oprot.writeFieldEnd()
9807 
    oprot.writeFieldStop()
9808 
    oprot.writeStructEnd()
9809 
 
9810 
  def validate(self):
9811 
    return
9812 
 
9813 
 
9814 
  def __repr__(self):
9815 
    L = ['%s=%r' % (key, value)
9816 
      for key, value in self.__dict__.iteritems()]
9817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9818 
 
9819 
  def __eq__(self, other):
9820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9821 
 
9822 
  def __ne__(self, other):
9823 
    return not (self == other)
9824 
 
999 varun.gupt 9825 
class getOrdersByBillingDate_args:
9826 
  """
9827 
  Attributes:
9828 
   - status
9829 
   - start_billing_date
9830 
   - end_billing_date
9831 
   - warehouse_id
9832 
  """
9833 
 
9834 
  thrift_spec = (
9835 
    None, # 0
9836 
    (1, TType.I32, 'status', None, None, ), # 1
9837 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9838 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9839 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9840 
  )
9841 
 
9842 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9843 
    self.status = status
9844 
    self.start_billing_date = start_billing_date
9845 
    self.end_billing_date = end_billing_date
9846 
    self.warehouse_id = warehouse_id
9847 
 
9848 
  def read(self, iprot):
9849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9851 
      return
9852 
    iprot.readStructBegin()
9853 
    while True:
9854 
      (fname, ftype, fid) = iprot.readFieldBegin()
9855 
      if ftype == TType.STOP:
9856 
        break
9857 
      if fid == 1:
9858 
        if ftype == TType.I32:
9859 
          self.status = iprot.readI32();
9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      elif fid == 2:
9863 
        if ftype == TType.I64:
9864 
          self.start_billing_date = iprot.readI64();
9865 
        else:
9866 
          iprot.skip(ftype)
9867 
      elif fid == 3:
9868 
        if ftype == TType.I64:
9869 
          self.end_billing_date = iprot.readI64();
9870 
        else:
9871 
          iprot.skip(ftype)
9872 
      elif fid == 4:
9873 
        if ftype == TType.I64:
9874 
          self.warehouse_id = iprot.readI64();
9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      else:
9878 
        iprot.skip(ftype)
9879 
      iprot.readFieldEnd()
9880 
    iprot.readStructEnd()
9881 
 
9882 
  def write(self, oprot):
9883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9885 
      return
9886 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9887 
    if self.status is not None:
999 varun.gupt 9888 
      oprot.writeFieldBegin('status', TType.I32, 1)
9889 
      oprot.writeI32(self.status)
9890 
      oprot.writeFieldEnd()
3431 rajveer 9891 
    if self.start_billing_date is not None:
999 varun.gupt 9892 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9893 
      oprot.writeI64(self.start_billing_date)
9894 
      oprot.writeFieldEnd()
3431 rajveer 9895 
    if self.end_billing_date is not None:
999 varun.gupt 9896 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9897 
      oprot.writeI64(self.end_billing_date)
9898 
      oprot.writeFieldEnd()
3431 rajveer 9899 
    if self.warehouse_id is not None:
999 varun.gupt 9900 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9901 
      oprot.writeI64(self.warehouse_id)
9902 
      oprot.writeFieldEnd()
9903 
    oprot.writeFieldStop()
9904 
    oprot.writeStructEnd()
9905 
 
3431 rajveer 9906 
  def validate(self):
9907 
    return
9908 
 
9909 
 
999 varun.gupt 9910 
  def __repr__(self):
9911 
    L = ['%s=%r' % (key, value)
9912 
      for key, value in self.__dict__.iteritems()]
9913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9914 
 
9915 
  def __eq__(self, other):
9916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9917 
 
9918 
  def __ne__(self, other):
9919 
    return not (self == other)
9920 
 
9921 
class getOrdersByBillingDate_result:
9922 
  """
9923 
  Attributes:
9924 
   - success
9925 
   - ex
9926 
  """
9927 
 
9928 
  thrift_spec = (
9929 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9931 
  )
9932 
 
9933 
  def __init__(self, success=None, ex=None,):
9934 
    self.success = success
9935 
    self.ex = ex
9936 
 
9937 
  def read(self, iprot):
9938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9940 
      return
9941 
    iprot.readStructBegin()
9942 
    while True:
9943 
      (fname, ftype, fid) = iprot.readFieldBegin()
9944 
      if ftype == TType.STOP:
9945 
        break
9946 
      if fid == 0:
9947 
        if ftype == TType.LIST:
9948 
          self.success = []
6031 rajveer 9949 
          (_etype115, _size112) = iprot.readListBegin()
9950 
          for _i116 in xrange(_size112):
9951 
            _elem117 = Order()
9952 
            _elem117.read(iprot)
9953 
            self.success.append(_elem117)
999 varun.gupt 9954 
          iprot.readListEnd()
9955 
        else:
9956 
          iprot.skip(ftype)
9957 
      elif fid == 1:
9958 
        if ftype == TType.STRUCT:
9959 
          self.ex = TransactionServiceException()
9960 
          self.ex.read(iprot)
9961 
        else:
9962 
          iprot.skip(ftype)
9963 
      else:
9964 
        iprot.skip(ftype)
9965 
      iprot.readFieldEnd()
9966 
    iprot.readStructEnd()
9967 
 
9968 
  def write(self, oprot):
9969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9971 
      return
9972 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9973 
    if self.success is not None:
999 varun.gupt 9974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9976 
      for iter118 in self.success:
9977 
        iter118.write(oprot)
999 varun.gupt 9978 
      oprot.writeListEnd()
9979 
      oprot.writeFieldEnd()
3431 rajveer 9980 
    if self.ex is not None:
999 varun.gupt 9981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9982 
      self.ex.write(oprot)
9983 
      oprot.writeFieldEnd()
9984 
    oprot.writeFieldStop()
9985 
    oprot.writeStructEnd()
9986 
 
3431 rajveer 9987 
  def validate(self):
9988 
    return
9989 
 
9990 
 
999 varun.gupt 9991 
  def __repr__(self):
9992 
    L = ['%s=%r' % (key, value)
9993 
      for key, value in self.__dict__.iteritems()]
9994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9995 
 
9996 
  def __eq__(self, other):
9997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9998 
 
9999 
  def __ne__(self, other):
10000 
    return not (self == other)
10001 
 
3427 chandransh 10002 
class getOrdersByShippingDate_args:
10003 
  """
10004 
  Attributes:
10005 
   - fromShippingDate
10006 
   - toShippingDate
10007 
   - providerId
10008 
   - warehouseId
3451 chandransh 10009 
   - cod
3427 chandransh 10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    None, # 0
10014 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10015 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10016 
    (3, TType.I64, 'providerId', None, None, ), # 3
10017 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10018 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10019 
  )
10020 
 
3451 chandransh 10021 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10022 
    self.fromShippingDate = fromShippingDate
10023 
    self.toShippingDate = toShippingDate
10024 
    self.providerId = providerId
10025 
    self.warehouseId = warehouseId
3451 chandransh 10026 
    self.cod = cod
3427 chandransh 10027 
 
10028 
  def read(self, iprot):
10029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10031 
      return
10032 
    iprot.readStructBegin()
10033 
    while True:
10034 
      (fname, ftype, fid) = iprot.readFieldBegin()
10035 
      if ftype == TType.STOP:
10036 
        break
10037 
      if fid == 1:
10038 
        if ftype == TType.I64:
10039 
          self.fromShippingDate = iprot.readI64();
10040 
        else:
10041 
          iprot.skip(ftype)
10042 
      elif fid == 2:
10043 
        if ftype == TType.I64:
10044 
          self.toShippingDate = iprot.readI64();
10045 
        else:
10046 
          iprot.skip(ftype)
10047 
      elif fid == 3:
10048 
        if ftype == TType.I64:
10049 
          self.providerId = iprot.readI64();
10050 
        else:
10051 
          iprot.skip(ftype)
10052 
      elif fid == 4:
10053 
        if ftype == TType.I64:
10054 
          self.warehouseId = iprot.readI64();
10055 
        else:
10056 
          iprot.skip(ftype)
3451 chandransh 10057 
      elif fid == 5:
10058 
        if ftype == TType.BOOL:
10059 
          self.cod = iprot.readBool();
10060 
        else:
10061 
          iprot.skip(ftype)
3427 chandransh 10062 
      else:
10063 
        iprot.skip(ftype)
10064 
      iprot.readFieldEnd()
10065 
    iprot.readStructEnd()
10066 
 
10067 
  def write(self, oprot):
10068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10070 
      return
10071 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10072 
    if self.fromShippingDate is not None:
3427 chandransh 10073 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10074 
      oprot.writeI64(self.fromShippingDate)
10075 
      oprot.writeFieldEnd()
3431 rajveer 10076 
    if self.toShippingDate is not None:
3427 chandransh 10077 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10078 
      oprot.writeI64(self.toShippingDate)
10079 
      oprot.writeFieldEnd()
3431 rajveer 10080 
    if self.providerId is not None:
3427 chandransh 10081 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10082 
      oprot.writeI64(self.providerId)
10083 
      oprot.writeFieldEnd()
3431 rajveer 10084 
    if self.warehouseId is not None:
3427 chandransh 10085 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10086 
      oprot.writeI64(self.warehouseId)
10087 
      oprot.writeFieldEnd()
3451 chandransh 10088 
    if self.cod is not None:
10089 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10090 
      oprot.writeBool(self.cod)
10091 
      oprot.writeFieldEnd()
3427 chandransh 10092 
    oprot.writeFieldStop()
10093 
    oprot.writeStructEnd()
10094 
 
3431 rajveer 10095 
  def validate(self):
10096 
    return
10097 
 
10098 
 
3427 chandransh 10099 
  def __repr__(self):
10100 
    L = ['%s=%r' % (key, value)
10101 
      for key, value in self.__dict__.iteritems()]
10102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10103 
 
10104 
  def __eq__(self, other):
10105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10106 
 
10107 
  def __ne__(self, other):
10108 
    return not (self == other)
10109 
 
10110 
class getOrdersByShippingDate_result:
10111 
  """
10112 
  Attributes:
10113 
   - success
10114 
   - ex
10115 
  """
10116 
 
10117 
  thrift_spec = (
10118 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10120 
  )
10121 
 
10122 
  def __init__(self, success=None, ex=None,):
10123 
    self.success = success
10124 
    self.ex = ex
10125 
 
10126 
  def read(self, iprot):
10127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10129 
      return
10130 
    iprot.readStructBegin()
10131 
    while True:
10132 
      (fname, ftype, fid) = iprot.readFieldBegin()
10133 
      if ftype == TType.STOP:
10134 
        break
10135 
      if fid == 0:
10136 
        if ftype == TType.LIST:
10137 
          self.success = []
6031 rajveer 10138 
          (_etype122, _size119) = iprot.readListBegin()
10139 
          for _i123 in xrange(_size119):
10140 
            _elem124 = Order()
10141 
            _elem124.read(iprot)
10142 
            self.success.append(_elem124)
3427 chandransh 10143 
          iprot.readListEnd()
10144 
        else:
10145 
          iprot.skip(ftype)
10146 
      elif fid == 1:
10147 
        if ftype == TType.STRUCT:
10148 
          self.ex = TransactionServiceException()
10149 
          self.ex.read(iprot)
10150 
        else:
10151 
          iprot.skip(ftype)
10152 
      else:
10153 
        iprot.skip(ftype)
10154 
      iprot.readFieldEnd()
10155 
    iprot.readStructEnd()
10156 
 
10157 
  def write(self, oprot):
10158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10160 
      return
10161 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10162 
    if self.success is not None:
3427 chandransh 10163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10165 
      for iter125 in self.success:
10166 
        iter125.write(oprot)
3427 chandransh 10167 
      oprot.writeListEnd()
10168 
      oprot.writeFieldEnd()
3431 rajveer 10169 
    if self.ex is not None:
3427 chandransh 10170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10171 
      self.ex.write(oprot)
10172 
      oprot.writeFieldEnd()
10173 
    oprot.writeFieldStop()
10174 
    oprot.writeStructEnd()
10175 
 
3431 rajveer 10176 
  def validate(self):
10177 
    return
10178 
 
10179 
 
3427 chandransh 10180 
  def __repr__(self):
10181 
    L = ['%s=%r' % (key, value)
10182 
      for key, value in self.__dict__.iteritems()]
10183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10184 
 
10185 
  def __eq__(self, other):
10186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10187 
 
10188 
  def __ne__(self, other):
10189 
    return not (self == other)
10190 
 
1382 varun.gupt 10191 
class getReturnableOrdersForCustomer_args:
10192 
  """
10193 
  Attributes:
10194 
   - customer_id
10195 
   - limit
10196 
  """
10197 
 
10198 
  thrift_spec = (
10199 
    None, # 0
10200 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10201 
    (2, TType.I64, 'limit', None, None, ), # 2
10202 
  )
10203 
 
10204 
  def __init__(self, customer_id=None, limit=None,):
10205 
    self.customer_id = customer_id
10206 
    self.limit = limit
10207 
 
10208 
  def read(self, iprot):
10209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10211 
      return
10212 
    iprot.readStructBegin()
10213 
    while True:
10214 
      (fname, ftype, fid) = iprot.readFieldBegin()
10215 
      if ftype == TType.STOP:
10216 
        break
10217 
      if fid == 1:
10218 
        if ftype == TType.I64:
10219 
          self.customer_id = iprot.readI64();
10220 
        else:
10221 
          iprot.skip(ftype)
10222 
      elif fid == 2:
10223 
        if ftype == TType.I64:
10224 
          self.limit = iprot.readI64();
10225 
        else:
10226 
          iprot.skip(ftype)
10227 
      else:
10228 
        iprot.skip(ftype)
10229 
      iprot.readFieldEnd()
10230 
    iprot.readStructEnd()
10231 
 
10232 
  def write(self, oprot):
10233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10235 
      return
10236 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10237 
    if self.customer_id is not None:
1382 varun.gupt 10238 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10239 
      oprot.writeI64(self.customer_id)
10240 
      oprot.writeFieldEnd()
3431 rajveer 10241 
    if self.limit is not None:
1382 varun.gupt 10242 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10243 
      oprot.writeI64(self.limit)
10244 
      oprot.writeFieldEnd()
10245 
    oprot.writeFieldStop()
10246 
    oprot.writeStructEnd()
10247 
 
3431 rajveer 10248 
  def validate(self):
10249 
    return
10250 
 
10251 
 
1382 varun.gupt 10252 
  def __repr__(self):
10253 
    L = ['%s=%r' % (key, value)
10254 
      for key, value in self.__dict__.iteritems()]
10255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10256 
 
10257 
  def __eq__(self, other):
10258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10259 
 
10260 
  def __ne__(self, other):
10261 
    return not (self == other)
10262 
 
10263 
class getReturnableOrdersForCustomer_result:
10264 
  """
10265 
  Attributes:
10266 
   - success
10267 
   - ex
10268 
  """
10269 
 
10270 
  thrift_spec = (
10271 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10273 
  )
10274 
 
10275 
  def __init__(self, success=None, ex=None,):
10276 
    self.success = success
10277 
    self.ex = ex
10278 
 
10279 
  def read(self, iprot):
10280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10282 
      return
10283 
    iprot.readStructBegin()
10284 
    while True:
10285 
      (fname, ftype, fid) = iprot.readFieldBegin()
10286 
      if ftype == TType.STOP:
10287 
        break
10288 
      if fid == 0:
10289 
        if ftype == TType.LIST:
10290 
          self.success = []
6031 rajveer 10291 
          (_etype129, _size126) = iprot.readListBegin()
10292 
          for _i130 in xrange(_size126):
10293 
            _elem131 = iprot.readI64();
10294 
            self.success.append(_elem131)
1382 varun.gupt 10295 
          iprot.readListEnd()
10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      elif fid == 1:
10299 
        if ftype == TType.STRUCT:
10300 
          self.ex = TransactionServiceException()
10301 
          self.ex.read(iprot)
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      else:
10305 
        iprot.skip(ftype)
10306 
      iprot.readFieldEnd()
10307 
    iprot.readStructEnd()
10308 
 
10309 
  def write(self, oprot):
10310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10312 
      return
10313 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10314 
    if self.success is not None:
1382 varun.gupt 10315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10316 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10317 
      for iter132 in self.success:
10318 
        oprot.writeI64(iter132)
1382 varun.gupt 10319 
      oprot.writeListEnd()
10320 
      oprot.writeFieldEnd()
3431 rajveer 10321 
    if self.ex is not None:
1382 varun.gupt 10322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10323 
      self.ex.write(oprot)
10324 
      oprot.writeFieldEnd()
10325 
    oprot.writeFieldStop()
10326 
    oprot.writeStructEnd()
10327 
 
3431 rajveer 10328 
  def validate(self):
10329 
    return
10330 
 
10331 
 
1382 varun.gupt 10332 
  def __repr__(self):
10333 
    L = ['%s=%r' % (key, value)
10334 
      for key, value in self.__dict__.iteritems()]
10335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10336 
 
10337 
  def __eq__(self, other):
10338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10339 
 
10340 
  def __ne__(self, other):
10341 
    return not (self == other)
10342 
 
10343 
class getCancellableOrdersForCustomer_args:
10344 
  """
10345 
  Attributes:
10346 
   - customer_id
10347 
   - limit
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    None, # 0
10352 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10353 
    (2, TType.I64, 'limit', None, None, ), # 2
10354 
  )
10355 
 
10356 
  def __init__(self, customer_id=None, limit=None,):
10357 
    self.customer_id = customer_id
10358 
    self.limit = limit
10359 
 
10360 
  def read(self, iprot):
10361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10363 
      return
10364 
    iprot.readStructBegin()
10365 
    while True:
10366 
      (fname, ftype, fid) = iprot.readFieldBegin()
10367 
      if ftype == TType.STOP:
10368 
        break
10369 
      if fid == 1:
10370 
        if ftype == TType.I64:
10371 
          self.customer_id = iprot.readI64();
10372 
        else:
10373 
          iprot.skip(ftype)
10374 
      elif fid == 2:
10375 
        if ftype == TType.I64:
10376 
          self.limit = iprot.readI64();
10377 
        else:
10378 
          iprot.skip(ftype)
10379 
      else:
10380 
        iprot.skip(ftype)
10381 
      iprot.readFieldEnd()
10382 
    iprot.readStructEnd()
10383 
 
10384 
  def write(self, oprot):
10385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10387 
      return
10388 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10389 
    if self.customer_id is not None:
1382 varun.gupt 10390 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10391 
      oprot.writeI64(self.customer_id)
10392 
      oprot.writeFieldEnd()
3431 rajveer 10393 
    if self.limit is not None:
1382 varun.gupt 10394 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10395 
      oprot.writeI64(self.limit)
10396 
      oprot.writeFieldEnd()
10397 
    oprot.writeFieldStop()
10398 
    oprot.writeStructEnd()
10399 
 
3431 rajveer 10400 
  def validate(self):
10401 
    return
10402 
 
10403 
 
1382 varun.gupt 10404 
  def __repr__(self):
10405 
    L = ['%s=%r' % (key, value)
10406 
      for key, value in self.__dict__.iteritems()]
10407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10408 
 
10409 
  def __eq__(self, other):
10410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10411 
 
10412 
  def __ne__(self, other):
10413 
    return not (self == other)
10414 
 
10415 
class getCancellableOrdersForCustomer_result:
10416 
  """
10417 
  Attributes:
10418 
   - success
10419 
   - ex
10420 
  """
10421 
 
10422 
  thrift_spec = (
10423 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10425 
  )
10426 
 
10427 
  def __init__(self, success=None, ex=None,):
10428 
    self.success = success
10429 
    self.ex = ex
10430 
 
10431 
  def read(self, iprot):
10432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10434 
      return
10435 
    iprot.readStructBegin()
10436 
    while True:
10437 
      (fname, ftype, fid) = iprot.readFieldBegin()
10438 
      if ftype == TType.STOP:
10439 
        break
10440 
      if fid == 0:
10441 
        if ftype == TType.LIST:
10442 
          self.success = []
6031 rajveer 10443 
          (_etype136, _size133) = iprot.readListBegin()
10444 
          for _i137 in xrange(_size133):
10445 
            _elem138 = iprot.readI64();
10446 
            self.success.append(_elem138)
1382 varun.gupt 10447 
          iprot.readListEnd()
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      elif fid == 1:
10451 
        if ftype == TType.STRUCT:
10452 
          self.ex = TransactionServiceException()
10453 
          self.ex.read(iprot)
10454 
        else:
10455 
          iprot.skip(ftype)
10456 
      else:
10457 
        iprot.skip(ftype)
10458 
      iprot.readFieldEnd()
10459 
    iprot.readStructEnd()
10460 
 
10461 
  def write(self, oprot):
10462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10464 
      return
10465 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10466 
    if self.success is not None:
1382 varun.gupt 10467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10468 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10469 
      for iter139 in self.success:
10470 
        oprot.writeI64(iter139)
1382 varun.gupt 10471 
      oprot.writeListEnd()
10472 
      oprot.writeFieldEnd()
3431 rajveer 10473 
    if self.ex is not None:
1382 varun.gupt 10474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10475 
      self.ex.write(oprot)
10476 
      oprot.writeFieldEnd()
10477 
    oprot.writeFieldStop()
10478 
    oprot.writeStructEnd()
10479 
 
3431 rajveer 10480 
  def validate(self):
10481 
    return
10482 
 
10483 
 
1382 varun.gupt 10484 
  def __repr__(self):
10485 
    L = ['%s=%r' % (key, value)
10486 
      for key, value in self.__dict__.iteritems()]
10487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10488 
 
10489 
  def __eq__(self, other):
10490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10491 
 
10492 
  def __ne__(self, other):
10493 
    return not (self == other)
10494 
 
483 rajveer 10495 
class changeOrderStatus_args:
94 ashish 10496 
  """
10497 
  Attributes:
483 rajveer 10498 
   - orderId
10499 
   - status
10500 
   - description
94 ashish 10501 
  """
10502 
 
10503 
  thrift_spec = (
10504 
    None, # 0
483 rajveer 10505 
    (1, TType.I64, 'orderId', None, None, ), # 1
10506 
    (2, TType.I32, 'status', None, None, ), # 2
10507 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10508 
  )
10509 
 
483 rajveer 10510 
  def __init__(self, orderId=None, status=None, description=None,):
10511 
    self.orderId = orderId
10512 
    self.status = status
10513 
    self.description = description
94 ashish 10514 
 
10515 
  def read(self, iprot):
10516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10518 
      return
10519 
    iprot.readStructBegin()
10520 
    while True:
10521 
      (fname, ftype, fid) = iprot.readFieldBegin()
10522 
      if ftype == TType.STOP:
10523 
        break
10524 
      if fid == 1:
10525 
        if ftype == TType.I64:
483 rajveer 10526 
          self.orderId = iprot.readI64();
94 ashish 10527 
        else:
10528 
          iprot.skip(ftype)
10529 
      elif fid == 2:
483 rajveer 10530 
        if ftype == TType.I32:
10531 
          self.status = iprot.readI32();
94 ashish 10532 
        else:
10533 
          iprot.skip(ftype)
483 rajveer 10534 
      elif fid == 3:
10535 
        if ftype == TType.STRING:
10536 
          self.description = iprot.readString();
10537 
        else:
10538 
          iprot.skip(ftype)
94 ashish 10539 
      else:
10540 
        iprot.skip(ftype)
10541 
      iprot.readFieldEnd()
10542 
    iprot.readStructEnd()
10543 
 
10544 
  def write(self, oprot):
10545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10547 
      return
483 rajveer 10548 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10549 
    if self.orderId is not None:
483 rajveer 10550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10551 
      oprot.writeI64(self.orderId)
94 ashish 10552 
      oprot.writeFieldEnd()
3431 rajveer 10553 
    if self.status is not None:
483 rajveer 10554 
      oprot.writeFieldBegin('status', TType.I32, 2)
10555 
      oprot.writeI32(self.status)
94 ashish 10556 
      oprot.writeFieldEnd()
3431 rajveer 10557 
    if self.description is not None:
483 rajveer 10558 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10559 
      oprot.writeString(self.description)
10560 
      oprot.writeFieldEnd()
94 ashish 10561 
    oprot.writeFieldStop()
10562 
    oprot.writeStructEnd()
10563 
 
3431 rajveer 10564 
  def validate(self):
10565 
    return
10566 
 
10567 
 
94 ashish 10568 
  def __repr__(self):
10569 
    L = ['%s=%r' % (key, value)
10570 
      for key, value in self.__dict__.iteritems()]
10571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10572 
 
10573 
  def __eq__(self, other):
10574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10575 
 
10576 
  def __ne__(self, other):
10577 
    return not (self == other)
10578 
 
483 rajveer 10579 
class changeOrderStatus_result:
94 ashish 10580 
  """
10581 
  Attributes:
10582 
   - success
10583 
   - ex
10584 
  """
10585 
 
10586 
  thrift_spec = (
10587 
    (0, TType.BOOL, 'success', None, None, ), # 0
10588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10589 
  )
10590 
 
10591 
  def __init__(self, success=None, ex=None,):
10592 
    self.success = success
10593 
    self.ex = ex
10594 
 
10595 
  def read(self, iprot):
10596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10598 
      return
10599 
    iprot.readStructBegin()
10600 
    while True:
10601 
      (fname, ftype, fid) = iprot.readFieldBegin()
10602 
      if ftype == TType.STOP:
10603 
        break
10604 
      if fid == 0:
10605 
        if ftype == TType.BOOL:
10606 
          self.success = iprot.readBool();
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
483 rajveer 10624 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10625 
    if self.success is not None:
94 ashish 10626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10627 
      oprot.writeBool(self.success)
10628 
      oprot.writeFieldEnd()
3431 rajveer 10629 
    if self.ex is not None:
94 ashish 10630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10631 
      self.ex.write(oprot)
10632 
      oprot.writeFieldEnd()
10633 
    oprot.writeFieldStop()
10634 
    oprot.writeStructEnd()
10635 
 
3431 rajveer 10636 
  def validate(self):
10637 
    return
10638 
 
10639 
 
94 ashish 10640 
  def __repr__(self):
10641 
    L = ['%s=%r' % (key, value)
10642 
      for key, value in self.__dict__.iteritems()]
10643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10644 
 
10645 
  def __eq__(self, other):
10646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10647 
 
10648 
  def __ne__(self, other):
10649 
    return not (self == other)
10650 
 
3064 chandransh 10651 
class getOrdersForTransaction_args:
494 rajveer 10652 
  """
10653 
  Attributes:
3064 chandransh 10654 
   - transactionId
10655 
   - customerId
494 rajveer 10656 
  """
10657 
 
10658 
  thrift_spec = (
10659 
    None, # 0
3064 chandransh 10660 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10661 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10662 
  )
10663 
 
3064 chandransh 10664 
  def __init__(self, transactionId=None, customerId=None,):
10665 
    self.transactionId = transactionId
10666 
    self.customerId = customerId
494 rajveer 10667 
 
10668 
  def read(self, iprot):
10669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10671 
      return
10672 
    iprot.readStructBegin()
10673 
    while True:
10674 
      (fname, ftype, fid) = iprot.readFieldBegin()
10675 
      if ftype == TType.STOP:
10676 
        break
10677 
      if fid == 1:
10678 
        if ftype == TType.I64:
3064 chandransh 10679 
          self.transactionId = iprot.readI64();
494 rajveer 10680 
        else:
10681 
          iprot.skip(ftype)
10682 
      elif fid == 2:
3064 chandransh 10683 
        if ftype == TType.I64:
10684 
          self.customerId = iprot.readI64();
494 rajveer 10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      else:
10688 
        iprot.skip(ftype)
10689 
      iprot.readFieldEnd()
10690 
    iprot.readStructEnd()
10691 
 
10692 
  def write(self, oprot):
10693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10695 
      return
3064 chandransh 10696 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10697 
    if self.transactionId is not None:
3064 chandransh 10698 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10699 
      oprot.writeI64(self.transactionId)
494 rajveer 10700 
      oprot.writeFieldEnd()
3431 rajveer 10701 
    if self.customerId is not None:
3064 chandransh 10702 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10703 
      oprot.writeI64(self.customerId)
494 rajveer 10704 
      oprot.writeFieldEnd()
10705 
    oprot.writeFieldStop()
10706 
    oprot.writeStructEnd()
10707 
 
3431 rajveer 10708 
  def validate(self):
10709 
    return
10710 
 
10711 
 
494 rajveer 10712 
  def __repr__(self):
10713 
    L = ['%s=%r' % (key, value)
10714 
      for key, value in self.__dict__.iteritems()]
10715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10716 
 
10717 
  def __eq__(self, other):
10718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10719 
 
10720 
  def __ne__(self, other):
10721 
    return not (self == other)
10722 
 
3064 chandransh 10723 
class getOrdersForTransaction_result:
494 rajveer 10724 
  """
10725 
  Attributes:
10726 
   - success
10727 
   - ex
10728 
  """
10729 
 
10730 
  thrift_spec = (
3064 chandransh 10731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10733 
  )
10734 
 
10735 
  def __init__(self, success=None, ex=None,):
10736 
    self.success = success
10737 
    self.ex = ex
10738 
 
10739 
  def read(self, iprot):
10740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10742 
      return
10743 
    iprot.readStructBegin()
10744 
    while True:
10745 
      (fname, ftype, fid) = iprot.readFieldBegin()
10746 
      if ftype == TType.STOP:
10747 
        break
10748 
      if fid == 0:
3064 chandransh 10749 
        if ftype == TType.LIST:
10750 
          self.success = []
6031 rajveer 10751 
          (_etype143, _size140) = iprot.readListBegin()
10752 
          for _i144 in xrange(_size140):
10753 
            _elem145 = Order()
10754 
            _elem145.read(iprot)
10755 
            self.success.append(_elem145)
3064 chandransh 10756 
          iprot.readListEnd()
494 rajveer 10757 
        else:
10758 
          iprot.skip(ftype)
10759 
      elif fid == 1:
10760 
        if ftype == TType.STRUCT:
10761 
          self.ex = TransactionServiceException()
10762 
          self.ex.read(iprot)
10763 
        else:
10764 
          iprot.skip(ftype)
10765 
      else:
10766 
        iprot.skip(ftype)
10767 
      iprot.readFieldEnd()
10768 
    iprot.readStructEnd()
10769 
 
10770 
  def write(self, oprot):
10771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10773 
      return
3064 chandransh 10774 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10775 
    if self.success is not None:
3064 chandransh 10776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10778 
      for iter146 in self.success:
10779 
        iter146.write(oprot)
3064 chandransh 10780 
      oprot.writeListEnd()
494 rajveer 10781 
      oprot.writeFieldEnd()
3431 rajveer 10782 
    if self.ex is not None:
494 rajveer 10783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10784 
      self.ex.write(oprot)
10785 
      oprot.writeFieldEnd()
10786 
    oprot.writeFieldStop()
10787 
    oprot.writeStructEnd()
10788 
 
3431 rajveer 10789 
  def validate(self):
10790 
    return
10791 
 
10792 
 
494 rajveer 10793 
  def __repr__(self):
10794 
    L = ['%s=%r' % (key, value)
10795 
      for key, value in self.__dict__.iteritems()]
10796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10797 
 
10798 
  def __eq__(self, other):
10799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10800 
 
10801 
  def __ne__(self, other):
10802 
    return not (self == other)
10803 
 
3064 chandransh 10804 
class getOrdersForCustomer_args:
1149 chandransh 10805 
  """
10806 
  Attributes:
3064 chandransh 10807 
   - customerId
10808 
   - from_date
10809 
   - to_date
10810 
   - statuses
1149 chandransh 10811 
  """
10812 
 
10813 
  thrift_spec = (
10814 
    None, # 0
3064 chandransh 10815 
    (1, TType.I64, 'customerId', None, None, ), # 1
10816 
    (2, TType.I64, 'from_date', None, None, ), # 2
10817 
    (3, TType.I64, 'to_date', None, None, ), # 3
10818 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10819 
  )
10820 
 
3064 chandransh 10821 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10822 
    self.customerId = customerId
10823 
    self.from_date = from_date
10824 
    self.to_date = to_date
10825 
    self.statuses = statuses
1149 chandransh 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.customerId = iprot.readI64();
1149 chandransh 10839 
        else:
10840 
          iprot.skip(ftype)
10841 
      elif fid == 2:
10842 
        if ftype == TType.I64:
3064 chandransh 10843 
          self.from_date = iprot.readI64();
1149 chandransh 10844 
        else:
10845 
          iprot.skip(ftype)
2783 chandransh 10846 
      elif fid == 3:
10847 
        if ftype == TType.I64:
3064 chandransh 10848 
          self.to_date = iprot.readI64();
2783 chandransh 10849 
        else:
10850 
          iprot.skip(ftype)
10851 
      elif fid == 4:
3064 chandransh 10852 
        if ftype == TType.LIST:
10853 
          self.statuses = []
6031 rajveer 10854 
          (_etype150, _size147) = iprot.readListBegin()
10855 
          for _i151 in xrange(_size147):
10856 
            _elem152 = iprot.readI32();
10857 
            self.statuses.append(_elem152)
3064 chandransh 10858 
          iprot.readListEnd()
2783 chandransh 10859 
        else:
10860 
          iprot.skip(ftype)
1149 chandransh 10861 
      else:
10862 
        iprot.skip(ftype)
10863 
      iprot.readFieldEnd()
10864 
    iprot.readStructEnd()
10865 
 
10866 
  def write(self, oprot):
10867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10869 
      return
3064 chandransh 10870 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10871 
    if self.customerId is not None:
3064 chandransh 10872 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10873 
      oprot.writeI64(self.customerId)
1149 chandransh 10874 
      oprot.writeFieldEnd()
3431 rajveer 10875 
    if self.from_date is not None:
3064 chandransh 10876 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10877 
      oprot.writeI64(self.from_date)
1149 chandransh 10878 
      oprot.writeFieldEnd()
3431 rajveer 10879 
    if self.to_date is not None:
3064 chandransh 10880 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10881 
      oprot.writeI64(self.to_date)
2783 chandransh 10882 
      oprot.writeFieldEnd()
3431 rajveer 10883 
    if self.statuses is not None:
3064 chandransh 10884 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10885 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10886 
      for iter153 in self.statuses:
10887 
        oprot.writeI32(iter153)
3064 chandransh 10888 
      oprot.writeListEnd()
2783 chandransh 10889 
      oprot.writeFieldEnd()
1149 chandransh 10890 
    oprot.writeFieldStop()
10891 
    oprot.writeStructEnd()
10892 
 
3431 rajveer 10893 
  def validate(self):
10894 
    return
10895 
 
10896 
 
1149 chandransh 10897 
  def __repr__(self):
10898 
    L = ['%s=%r' % (key, value)
10899 
      for key, value in self.__dict__.iteritems()]
10900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10901 
 
10902 
  def __eq__(self, other):
10903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10904 
 
10905 
  def __ne__(self, other):
10906 
    return not (self == other)
10907 
 
3064 chandransh 10908 
class getOrdersForCustomer_result:
1149 chandransh 10909 
  """
10910 
  Attributes:
10911 
   - success
10912 
   - ex
10913 
  """
10914 
 
10915 
  thrift_spec = (
3064 chandransh 10916 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10918 
  )
10919 
 
10920 
  def __init__(self, success=None, ex=None,):
10921 
    self.success = success
10922 
    self.ex = ex
10923 
 
10924 
  def read(self, iprot):
10925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10927 
      return
10928 
    iprot.readStructBegin()
10929 
    while True:
10930 
      (fname, ftype, fid) = iprot.readFieldBegin()
10931 
      if ftype == TType.STOP:
10932 
        break
10933 
      if fid == 0:
3064 chandransh 10934 
        if ftype == TType.LIST:
10935 
          self.success = []
6031 rajveer 10936 
          (_etype157, _size154) = iprot.readListBegin()
10937 
          for _i158 in xrange(_size154):
10938 
            _elem159 = Order()
10939 
            _elem159.read(iprot)
10940 
            self.success.append(_elem159)
3064 chandransh 10941 
          iprot.readListEnd()
1149 chandransh 10942 
        else:
10943 
          iprot.skip(ftype)
10944 
      elif fid == 1:
10945 
        if ftype == TType.STRUCT:
10946 
          self.ex = TransactionServiceException()
10947 
          self.ex.read(iprot)
10948 
        else:
10949 
          iprot.skip(ftype)
10950 
      else:
10951 
        iprot.skip(ftype)
10952 
      iprot.readFieldEnd()
10953 
    iprot.readStructEnd()
10954 
 
10955 
  def write(self, oprot):
10956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10958 
      return
3064 chandransh 10959 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10960 
    if self.success is not None:
3064 chandransh 10961 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10962 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10963 
      for iter160 in self.success:
10964 
        iter160.write(oprot)
3064 chandransh 10965 
      oprot.writeListEnd()
1149 chandransh 10966 
      oprot.writeFieldEnd()
3431 rajveer 10967 
    if self.ex is not None:
1149 chandransh 10968 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10969 
      self.ex.write(oprot)
10970 
      oprot.writeFieldEnd()
10971 
    oprot.writeFieldStop()
10972 
    oprot.writeStructEnd()
10973 
 
3431 rajveer 10974 
  def validate(self):
10975 
    return
10976 
 
10977 
 
1149 chandransh 10978 
  def __repr__(self):
10979 
    L = ['%s=%r' % (key, value)
10980 
      for key, value in self.__dict__.iteritems()]
10981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10982 
 
10983 
  def __eq__(self, other):
10984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10985 
 
10986 
  def __ne__(self, other):
10987 
    return not (self == other)
10988 
 
3064 chandransh 10989 
class createOrder_args:
921 rajveer 10990 
  """
10991 
  Attributes:
3064 chandransh 10992 
   - order
921 rajveer 10993 
  """
10994 
 
10995 
  thrift_spec = (
10996 
    None, # 0
3064 chandransh 10997 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10998 
  )
10999 
 
3064 chandransh 11000 
  def __init__(self, order=None,):
11001 
    self.order = order
921 rajveer 11002 
 
11003 
  def read(self, iprot):
11004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11006 
      return
11007 
    iprot.readStructBegin()
11008 
    while True:
11009 
      (fname, ftype, fid) = iprot.readFieldBegin()
11010 
      if ftype == TType.STOP:
11011 
        break
11012 
      if fid == 1:
3064 chandransh 11013 
        if ftype == TType.STRUCT:
11014 
          self.order = Order()
11015 
          self.order.read(iprot)
921 rajveer 11016 
        else:
11017 
          iprot.skip(ftype)
11018 
      else:
11019 
        iprot.skip(ftype)
11020 
      iprot.readFieldEnd()
11021 
    iprot.readStructEnd()
11022 
 
11023 
  def write(self, oprot):
11024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11026 
      return
3064 chandransh 11027 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11028 
    if self.order is not None:
3064 chandransh 11029 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11030 
      self.order.write(oprot)
921 rajveer 11031 
      oprot.writeFieldEnd()
11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
3431 rajveer 11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
921 rajveer 11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
3064 chandransh 11050 
class createOrder_result:
921 rajveer 11051 
  """
11052 
  Attributes:
11053 
   - success
11054 
   - ex
11055 
  """
11056 
 
11057 
  thrift_spec = (
3064 chandransh 11058 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11060 
  )
11061 
 
11062 
  def __init__(self, success=None, ex=None,):
11063 
    self.success = success
11064 
    self.ex = ex
11065 
 
11066 
  def read(self, iprot):
11067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11069 
      return
11070 
    iprot.readStructBegin()
11071 
    while True:
11072 
      (fname, ftype, fid) = iprot.readFieldBegin()
11073 
      if ftype == TType.STOP:
11074 
        break
11075 
      if fid == 0:
3064 chandransh 11076 
        if ftype == TType.I64:
11077 
          self.success = iprot.readI64();
921 rajveer 11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      elif fid == 1:
11081 
        if ftype == TType.STRUCT:
11082 
          self.ex = TransactionServiceException()
11083 
          self.ex.read(iprot)
11084 
        else:
11085 
          iprot.skip(ftype)
11086 
      else:
11087 
        iprot.skip(ftype)
11088 
      iprot.readFieldEnd()
11089 
    iprot.readStructEnd()
11090 
 
11091 
  def write(self, oprot):
11092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11094 
      return
3064 chandransh 11095 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11096 
    if self.success is not None:
3064 chandransh 11097 
      oprot.writeFieldBegin('success', TType.I64, 0)
11098 
      oprot.writeI64(self.success)
921 rajveer 11099 
      oprot.writeFieldEnd()
3431 rajveer 11100 
    if self.ex is not None:
921 rajveer 11101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11102 
      self.ex.write(oprot)
11103 
      oprot.writeFieldEnd()
11104 
    oprot.writeFieldStop()
11105 
    oprot.writeStructEnd()
11106 
 
3431 rajveer 11107 
  def validate(self):
11108 
    return
11109 
 
11110 
 
921 rajveer 11111 
  def __repr__(self):
11112 
    L = ['%s=%r' % (key, value)
11113 
      for key, value in self.__dict__.iteritems()]
11114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11115 
 
11116 
  def __eq__(self, other):
11117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11118 
 
11119 
  def __ne__(self, other):
11120 
    return not (self == other)
11121 
 
3064 chandransh 11122 
class getOrder_args:
921 rajveer 11123 
  """
11124 
  Attributes:
3064 chandransh 11125 
   - id
921 rajveer 11126 
  """
11127 
 
11128 
  thrift_spec = (
11129 
    None, # 0
3064 chandransh 11130 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11131 
  )
11132 
 
3064 chandransh 11133 
  def __init__(self, id=None,):
11134 
    self.id = id
921 rajveer 11135 
 
11136 
  def read(self, iprot):
11137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11139 
      return
11140 
    iprot.readStructBegin()
11141 
    while True:
11142 
      (fname, ftype, fid) = iprot.readFieldBegin()
11143 
      if ftype == TType.STOP:
11144 
        break
11145 
      if fid == 1:
11146 
        if ftype == TType.I64:
3064 chandransh 11147 
          self.id = iprot.readI64();
921 rajveer 11148 
        else:
11149 
          iprot.skip(ftype)
11150 
      else:
11151 
        iprot.skip(ftype)
11152 
      iprot.readFieldEnd()
11153 
    iprot.readStructEnd()
11154 
 
11155 
  def write(self, oprot):
11156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11158 
      return
3064 chandransh 11159 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11160 
    if self.id is not None:
3064 chandransh 11161 
      oprot.writeFieldBegin('id', TType.I64, 1)
11162 
      oprot.writeI64(self.id)
921 rajveer 11163 
      oprot.writeFieldEnd()
11164 
    oprot.writeFieldStop()
11165 
    oprot.writeStructEnd()
11166 
 
3431 rajveer 11167 
  def validate(self):
11168 
    return
11169 
 
11170 
 
921 rajveer 11171 
  def __repr__(self):
11172 
    L = ['%s=%r' % (key, value)
11173 
      for key, value in self.__dict__.iteritems()]
11174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11175 
 
11176 
  def __eq__(self, other):
11177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11178 
 
11179 
  def __ne__(self, other):
11180 
    return not (self == other)
11181 
 
3064 chandransh 11182 
class getOrder_result:
921 rajveer 11183 
  """
11184 
  Attributes:
11185 
   - success
11186 
   - ex
11187 
  """
11188 
 
11189 
  thrift_spec = (
3064 chandransh 11190 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11192 
  )
11193 
 
11194 
  def __init__(self, success=None, ex=None,):
11195 
    self.success = success
11196 
    self.ex = ex
11197 
 
11198 
  def read(self, iprot):
11199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11201 
      return
11202 
    iprot.readStructBegin()
11203 
    while True:
11204 
      (fname, ftype, fid) = iprot.readFieldBegin()
11205 
      if ftype == TType.STOP:
11206 
        break
11207 
      if fid == 0:
3064 chandransh 11208 
        if ftype == TType.STRUCT:
11209 
          self.success = Order()
11210 
          self.success.read(iprot)
921 rajveer 11211 
        else:
11212 
          iprot.skip(ftype)
11213 
      elif fid == 1:
11214 
        if ftype == TType.STRUCT:
11215 
          self.ex = TransactionServiceException()
11216 
          self.ex.read(iprot)
11217 
        else:
11218 
          iprot.skip(ftype)
11219 
      else:
11220 
        iprot.skip(ftype)
11221 
      iprot.readFieldEnd()
11222 
    iprot.readStructEnd()
11223 
 
11224 
  def write(self, oprot):
11225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11227 
      return
3064 chandransh 11228 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11229 
    if self.success is not None:
3064 chandransh 11230 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11231 
      self.success.write(oprot)
921 rajveer 11232 
      oprot.writeFieldEnd()
3431 rajveer 11233 
    if self.ex is not None:
921 rajveer 11234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11235 
      self.ex.write(oprot)
11236 
      oprot.writeFieldEnd()
11237 
    oprot.writeFieldStop()
11238 
    oprot.writeStructEnd()
11239 
 
3431 rajveer 11240 
  def validate(self):
11241 
    return
11242 
 
11243 
 
921 rajveer 11244 
  def __repr__(self):
11245 
    L = ['%s=%r' % (key, value)
11246 
      for key, value in self.__dict__.iteritems()]
11247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11248 
 
11249 
  def __eq__(self, other):
11250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11251 
 
11252 
  def __ne__(self, other):
11253 
    return not (self == other)
11254 
 
3064 chandransh 11255 
class getLineItemsForOrder_args:
94 ashish 11256 
  """
11257 
  Attributes:
3064 chandransh 11258 
   - orderId
94 ashish 11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    None, # 0
3064 chandransh 11263 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11264 
  )
11265 
 
3064 chandransh 11266 
  def __init__(self, orderId=None,):
11267 
    self.orderId = orderId
94 ashish 11268 
 
11269 
  def read(self, iprot):
11270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11272 
      return
11273 
    iprot.readStructBegin()
11274 
    while True:
11275 
      (fname, ftype, fid) = iprot.readFieldBegin()
11276 
      if ftype == TType.STOP:
11277 
        break
11278 
      if fid == 1:
11279 
        if ftype == TType.I64:
3064 chandransh 11280 
          self.orderId = iprot.readI64();
94 ashish 11281 
        else:
11282 
          iprot.skip(ftype)
11283 
      else:
11284 
        iprot.skip(ftype)
11285 
      iprot.readFieldEnd()
11286 
    iprot.readStructEnd()
11287 
 
11288 
  def write(self, oprot):
11289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11291 
      return
3064 chandransh 11292 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11293 
    if self.orderId is not None:
3064 chandransh 11294 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11295 
      oprot.writeI64(self.orderId)
94 ashish 11296 
      oprot.writeFieldEnd()
11297 
    oprot.writeFieldStop()
11298 
    oprot.writeStructEnd()
11299 
 
3431 rajveer 11300 
  def validate(self):
11301 
    return
11302 
 
11303 
 
94 ashish 11304 
  def __repr__(self):
11305 
    L = ['%s=%r' % (key, value)
11306 
      for key, value in self.__dict__.iteritems()]
11307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11308 
 
11309 
  def __eq__(self, other):
11310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11311 
 
11312 
  def __ne__(self, other):
11313 
    return not (self == other)
11314 
 
3064 chandransh 11315 
class getLineItemsForOrder_result:
94 ashish 11316 
  """
11317 
  Attributes:
11318 
   - success
11319 
   - ex
11320 
  """
11321 
 
11322 
  thrift_spec = (
3064 chandransh 11323 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11325 
  )
11326 
 
11327 
  def __init__(self, success=None, ex=None,):
11328 
    self.success = success
11329 
    self.ex = ex
11330 
 
11331 
  def read(self, iprot):
11332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11334 
      return
11335 
    iprot.readStructBegin()
11336 
    while True:
11337 
      (fname, ftype, fid) = iprot.readFieldBegin()
11338 
      if ftype == TType.STOP:
11339 
        break
11340 
      if fid == 0:
483 rajveer 11341 
        if ftype == TType.LIST:
11342 
          self.success = []
6031 rajveer 11343 
          (_etype164, _size161) = iprot.readListBegin()
11344 
          for _i165 in xrange(_size161):
11345 
            _elem166 = LineItem()
11346 
            _elem166.read(iprot)
11347 
            self.success.append(_elem166)
483 rajveer 11348 
          iprot.readListEnd()
94 ashish 11349 
        else:
11350 
          iprot.skip(ftype)
11351 
      elif fid == 1:
11352 
        if ftype == TType.STRUCT:
11353 
          self.ex = TransactionServiceException()
11354 
          self.ex.read(iprot)
11355 
        else:
11356 
          iprot.skip(ftype)
11357 
      else:
11358 
        iprot.skip(ftype)
11359 
      iprot.readFieldEnd()
11360 
    iprot.readStructEnd()
11361 
 
11362 
  def write(self, oprot):
11363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11365 
      return
3064 chandransh 11366 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11367 
    if self.success is not None:
483 rajveer 11368 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11369 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11370 
      for iter167 in self.success:
11371 
        iter167.write(oprot)
483 rajveer 11372 
      oprot.writeListEnd()
94 ashish 11373 
      oprot.writeFieldEnd()
3431 rajveer 11374 
    if self.ex is not None:
94 ashish 11375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11376 
      self.ex.write(oprot)
11377 
      oprot.writeFieldEnd()
11378 
    oprot.writeFieldStop()
11379 
    oprot.writeStructEnd()
11380 
 
3431 rajveer 11381 
  def validate(self):
11382 
    return
11383 
 
11384 
 
94 ashish 11385 
  def __repr__(self):
11386 
    L = ['%s=%r' % (key, value)
11387 
      for key, value in self.__dict__.iteritems()]
11388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11389 
 
11390 
  def __eq__(self, other):
11391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11392 
 
11393 
  def __ne__(self, other):
11394 
    return not (self == other)
11395 
 
4999 phani.kuma 11396 
class getOrderList_args:
11397 
  """
11398 
  Attributes:
11399 
   - order_ids
11400 
  """
11401 
 
11402 
  thrift_spec = (
11403 
    None, # 0
11404 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11405 
  )
11406 
 
11407 
  def __init__(self, order_ids=None,):
11408 
    self.order_ids = order_ids
11409 
 
11410 
  def read(self, iprot):
11411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11413 
      return
11414 
    iprot.readStructBegin()
11415 
    while True:
11416 
      (fname, ftype, fid) = iprot.readFieldBegin()
11417 
      if ftype == TType.STOP:
11418 
        break
11419 
      if fid == 1:
11420 
        if ftype == TType.LIST:
11421 
          self.order_ids = []
6031 rajveer 11422 
          (_etype171, _size168) = iprot.readListBegin()
11423 
          for _i172 in xrange(_size168):
11424 
            _elem173 = iprot.readI64();
11425 
            self.order_ids.append(_elem173)
4999 phani.kuma 11426 
          iprot.readListEnd()
11427 
        else:
11428 
          iprot.skip(ftype)
11429 
      else:
11430 
        iprot.skip(ftype)
11431 
      iprot.readFieldEnd()
11432 
    iprot.readStructEnd()
11433 
 
11434 
  def write(self, oprot):
11435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11437 
      return
11438 
    oprot.writeStructBegin('getOrderList_args')
11439 
    if self.order_ids is not None:
11440 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11441 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11442 
      for iter174 in self.order_ids:
11443 
        oprot.writeI64(iter174)
4999 phani.kuma 11444 
      oprot.writeListEnd()
11445 
      oprot.writeFieldEnd()
11446 
    oprot.writeFieldStop()
11447 
    oprot.writeStructEnd()
11448 
 
11449 
  def validate(self):
11450 
    return
11451 
 
11452 
 
11453 
  def __repr__(self):
11454 
    L = ['%s=%r' % (key, value)
11455 
      for key, value in self.__dict__.iteritems()]
11456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11457 
 
11458 
  def __eq__(self, other):
11459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11460 
 
11461 
  def __ne__(self, other):
11462 
    return not (self == other)
11463 
 
11464 
class getOrderList_result:
11465 
  """
11466 
  Attributes:
11467 
   - success
11468 
  """
11469 
 
11470 
  thrift_spec = (
11471 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11472 
  )
11473 
 
11474 
  def __init__(self, success=None,):
11475 
    self.success = success
11476 
 
11477 
  def read(self, iprot):
11478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11480 
      return
11481 
    iprot.readStructBegin()
11482 
    while True:
11483 
      (fname, ftype, fid) = iprot.readFieldBegin()
11484 
      if ftype == TType.STOP:
11485 
        break
11486 
      if fid == 0:
11487 
        if ftype == TType.LIST:
11488 
          self.success = []
6031 rajveer 11489 
          (_etype178, _size175) = iprot.readListBegin()
11490 
          for _i179 in xrange(_size175):
11491 
            _elem180 = Order()
11492 
            _elem180.read(iprot)
11493 
            self.success.append(_elem180)
4999 phani.kuma 11494 
          iprot.readListEnd()
11495 
        else:
11496 
          iprot.skip(ftype)
11497 
      else:
11498 
        iprot.skip(ftype)
11499 
      iprot.readFieldEnd()
11500 
    iprot.readStructEnd()
11501 
 
11502 
  def write(self, oprot):
11503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11505 
      return
11506 
    oprot.writeStructBegin('getOrderList_result')
11507 
    if self.success is not None:
11508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11510 
      for iter181 in self.success:
11511 
        iter181.write(oprot)
4999 phani.kuma 11512 
      oprot.writeListEnd()
11513 
      oprot.writeFieldEnd()
11514 
    oprot.writeFieldStop()
11515 
    oprot.writeStructEnd()
11516 
 
11517 
  def validate(self):
11518 
    return
11519 
 
11520 
 
11521 
  def __repr__(self):
11522 
    L = ['%s=%r' % (key, value)
11523 
      for key, value in self.__dict__.iteritems()]
11524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11525 
 
11526 
  def __eq__(self, other):
11527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11528 
 
11529 
  def __ne__(self, other):
11530 
    return not (self == other)
11531 
 
5386 phani.kuma 11532 
class getOrderListForVendor_args:
11533 
  """
11534 
  Attributes:
11535 
   - order_ids
11536 
   - vendorId
11537 
  """
11538 
 
11539 
  thrift_spec = (
11540 
    None, # 0
11541 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11542 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11543 
  )
11544 
 
11545 
  def __init__(self, order_ids=None, vendorId=None,):
11546 
    self.order_ids = order_ids
11547 
    self.vendorId = vendorId
11548 
 
11549 
  def read(self, iprot):
11550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11552 
      return
11553 
    iprot.readStructBegin()
11554 
    while True:
11555 
      (fname, ftype, fid) = iprot.readFieldBegin()
11556 
      if ftype == TType.STOP:
11557 
        break
11558 
      if fid == 1:
11559 
        if ftype == TType.LIST:
11560 
          self.order_ids = []
6031 rajveer 11561 
          (_etype185, _size182) = iprot.readListBegin()
11562 
          for _i186 in xrange(_size182):
11563 
            _elem187 = iprot.readI64();
11564 
            self.order_ids.append(_elem187)
5386 phani.kuma 11565 
          iprot.readListEnd()
11566 
        else:
11567 
          iprot.skip(ftype)
11568 
      elif fid == 2:
11569 
        if ftype == TType.I64:
11570 
          self.vendorId = iprot.readI64();
11571 
        else:
11572 
          iprot.skip(ftype)
11573 
      else:
11574 
        iprot.skip(ftype)
11575 
      iprot.readFieldEnd()
11576 
    iprot.readStructEnd()
11577 
 
11578 
  def write(self, oprot):
11579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11581 
      return
11582 
    oprot.writeStructBegin('getOrderListForVendor_args')
11583 
    if self.order_ids is not None:
11584 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11585 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11586 
      for iter188 in self.order_ids:
11587 
        oprot.writeI64(iter188)
5386 phani.kuma 11588 
      oprot.writeListEnd()
11589 
      oprot.writeFieldEnd()
11590 
    if self.vendorId is not None:
11591 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11592 
      oprot.writeI64(self.vendorId)
11593 
      oprot.writeFieldEnd()
11594 
    oprot.writeFieldStop()
11595 
    oprot.writeStructEnd()
11596 
 
11597 
  def validate(self):
11598 
    return
11599 
 
11600 
 
11601 
  def __repr__(self):
11602 
    L = ['%s=%r' % (key, value)
11603 
      for key, value in self.__dict__.iteritems()]
11604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11605 
 
11606 
  def __eq__(self, other):
11607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11608 
 
11609 
  def __ne__(self, other):
11610 
    return not (self == other)
11611 
 
11612 
class getOrderListForVendor_result:
11613 
  """
11614 
  Attributes:
11615 
   - success
11616 
  """
11617 
 
11618 
  thrift_spec = (
11619 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11620 
  )
11621 
 
11622 
  def __init__(self, success=None,):
11623 
    self.success = success
11624 
 
11625 
  def read(self, iprot):
11626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11628 
      return
11629 
    iprot.readStructBegin()
11630 
    while True:
11631 
      (fname, ftype, fid) = iprot.readFieldBegin()
11632 
      if ftype == TType.STOP:
11633 
        break
11634 
      if fid == 0:
11635 
        if ftype == TType.LIST:
11636 
          self.success = []
6031 rajveer 11637 
          (_etype192, _size189) = iprot.readListBegin()
11638 
          for _i193 in xrange(_size189):
11639 
            _elem194 = Order()
11640 
            _elem194.read(iprot)
11641 
            self.success.append(_elem194)
5386 phani.kuma 11642 
          iprot.readListEnd()
11643 
        else:
11644 
          iprot.skip(ftype)
11645 
      else:
11646 
        iprot.skip(ftype)
11647 
      iprot.readFieldEnd()
11648 
    iprot.readStructEnd()
11649 
 
11650 
  def write(self, oprot):
11651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11653 
      return
11654 
    oprot.writeStructBegin('getOrderListForVendor_result')
11655 
    if self.success is not None:
11656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11658 
      for iter195 in self.success:
11659 
        iter195.write(oprot)
5386 phani.kuma 11660 
      oprot.writeListEnd()
11661 
      oprot.writeFieldEnd()
11662 
    oprot.writeFieldStop()
11663 
    oprot.writeStructEnd()
11664 
 
11665 
  def validate(self):
11666 
    return
11667 
 
11668 
 
11669 
  def __repr__(self):
11670 
    L = ['%s=%r' % (key, value)
11671 
      for key, value in self.__dict__.iteritems()]
11672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11673 
 
11674 
  def __eq__(self, other):
11675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11676 
 
11677 
  def __ne__(self, other):
11678 
    return not (self == other)
11679 
 
3064 chandransh 11680 
class getOrderForCustomer_args:
94 ashish 11681 
  """
11682 
  Attributes:
3064 chandransh 11683 
   - orderId
483 rajveer 11684 
   - customerId
94 ashish 11685 
  """
11686 
 
11687 
  thrift_spec = (
11688 
    None, # 0
3064 chandransh 11689 
    (1, TType.I64, 'orderId', None, None, ), # 1
11690 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11691 
  )
11692 
 
3064 chandransh 11693 
  def __init__(self, orderId=None, customerId=None,):
11694 
    self.orderId = orderId
483 rajveer 11695 
    self.customerId = customerId
94 ashish 11696 
 
11697 
  def read(self, iprot):
11698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11700 
      return
11701 
    iprot.readStructBegin()
11702 
    while True:
11703 
      (fname, ftype, fid) = iprot.readFieldBegin()
11704 
      if ftype == TType.STOP:
11705 
        break
11706 
      if fid == 1:
11707 
        if ftype == TType.I64:
3064 chandransh 11708 
          self.orderId = iprot.readI64();
94 ashish 11709 
        else:
11710 
          iprot.skip(ftype)
11711 
      elif fid == 2:
11712 
        if ftype == TType.I64:
3064 chandransh 11713 
          self.customerId = iprot.readI64();
94 ashish 11714 
        else:
11715 
          iprot.skip(ftype)
11716 
      else:
11717 
        iprot.skip(ftype)
11718 
      iprot.readFieldEnd()
11719 
    iprot.readStructEnd()
11720 
 
11721 
  def write(self, oprot):
11722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11724 
      return
3064 chandransh 11725 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11726 
    if self.orderId is not None:
3064 chandransh 11727 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11728 
      oprot.writeI64(self.orderId)
11729 
      oprot.writeFieldEnd()
3431 rajveer 11730 
    if self.customerId is not None:
3064 chandransh 11731 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11732 
      oprot.writeI64(self.customerId)
94 ashish 11733 
      oprot.writeFieldEnd()
11734 
    oprot.writeFieldStop()
11735 
    oprot.writeStructEnd()
11736 
 
3431 rajveer 11737 
  def validate(self):
11738 
    return
11739 
 
11740 
 
94 ashish 11741 
  def __repr__(self):
11742 
    L = ['%s=%r' % (key, value)
11743 
      for key, value in self.__dict__.iteritems()]
11744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11745 
 
11746 
  def __eq__(self, other):
11747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11748 
 
11749 
  def __ne__(self, other):
11750 
    return not (self == other)
11751 
 
3064 chandransh 11752 
class getOrderForCustomer_result:
94 ashish 11753 
  """
11754 
  Attributes:
11755 
   - success
11756 
   - ex
11757 
  """
11758 
 
11759 
  thrift_spec = (
3064 chandransh 11760 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11762 
  )
11763 
 
11764 
  def __init__(self, success=None, ex=None,):
11765 
    self.success = success
11766 
    self.ex = ex
11767 
 
11768 
  def read(self, iprot):
11769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11771 
      return
11772 
    iprot.readStructBegin()
11773 
    while True:
11774 
      (fname, ftype, fid) = iprot.readFieldBegin()
11775 
      if ftype == TType.STOP:
11776 
        break
11777 
      if fid == 0:
3064 chandransh 11778 
        if ftype == TType.STRUCT:
11779 
          self.success = Order()
11780 
          self.success.read(iprot)
94 ashish 11781 
        else:
11782 
          iprot.skip(ftype)
11783 
      elif fid == 1:
11784 
        if ftype == TType.STRUCT:
11785 
          self.ex = TransactionServiceException()
11786 
          self.ex.read(iprot)
11787 
        else:
11788 
          iprot.skip(ftype)
11789 
      else:
11790 
        iprot.skip(ftype)
11791 
      iprot.readFieldEnd()
11792 
    iprot.readStructEnd()
11793 
 
11794 
  def write(self, oprot):
11795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11797 
      return
3064 chandransh 11798 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11799 
    if self.success is not None:
3064 chandransh 11800 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11801 
      self.success.write(oprot)
94 ashish 11802 
      oprot.writeFieldEnd()
3431 rajveer 11803 
    if self.ex is not None:
94 ashish 11804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11805 
      self.ex.write(oprot)
11806 
      oprot.writeFieldEnd()
11807 
    oprot.writeFieldStop()
11808 
    oprot.writeStructEnd()
11809 
 
3431 rajveer 11810 
  def validate(self):
11811 
    return
11812 
 
11813 
 
94 ashish 11814 
  def __repr__(self):
11815 
    L = ['%s=%r' % (key, value)
11816 
      for key, value in self.__dict__.iteritems()]
11817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11818 
 
11819 
  def __eq__(self, other):
11820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11821 
 
11822 
  def __ne__(self, other):
11823 
    return not (self == other)
11824 
 
3064 chandransh 11825 
class getAlerts_args:
94 ashish 11826 
  """
11827 
  Attributes:
4394 rajveer 11828 
   - type
4444 rajveer 11829 
   - warehouseId
4394 rajveer 11830 
   - status
11831 
   - timestamp
94 ashish 11832 
  """
11833 
 
11834 
  thrift_spec = (
11835 
    None, # 0
4394 rajveer 11836 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11837 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11838 
    (3, TType.I64, 'status', None, None, ), # 3
11839 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11840 
  )
11841 
 
4444 rajveer 11842 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11843 
    self.type = type
4444 rajveer 11844 
    self.warehouseId = warehouseId
4394 rajveer 11845 
    self.status = status
11846 
    self.timestamp = timestamp
94 ashish 11847 
 
11848 
  def read(self, iprot):
11849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11851 
      return
11852 
    iprot.readStructBegin()
11853 
    while True:
11854 
      (fname, ftype, fid) = iprot.readFieldBegin()
11855 
      if ftype == TType.STOP:
11856 
        break
11857 
      if fid == 1:
3064 chandransh 11858 
        if ftype == TType.I64:
4394 rajveer 11859 
          self.type = iprot.readI64();
94 ashish 11860 
        else:
11861 
          iprot.skip(ftype)
3064 chandransh 11862 
      elif fid == 2:
4394 rajveer 11863 
        if ftype == TType.I64:
4444 rajveer 11864 
          self.warehouseId = iprot.readI64();
3064 chandransh 11865 
        else:
11866 
          iprot.skip(ftype)
4394 rajveer 11867 
      elif fid == 3:
11868 
        if ftype == TType.I64:
4444 rajveer 11869 
          self.status = iprot.readI64();
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      elif fid == 4:
11873 
        if ftype == TType.I64:
4394 rajveer 11874 
          self.timestamp = iprot.readI64();
11875 
        else:
11876 
          iprot.skip(ftype)
94 ashish 11877 
      else:
11878 
        iprot.skip(ftype)
11879 
      iprot.readFieldEnd()
11880 
    iprot.readStructEnd()
11881 
 
11882 
  def write(self, oprot):
11883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11885 
      return
3064 chandransh 11886 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11887 
    if self.type is not None:
11888 
      oprot.writeFieldBegin('type', TType.I64, 1)
11889 
      oprot.writeI64(self.type)
94 ashish 11890 
      oprot.writeFieldEnd()
4444 rajveer 11891 
    if self.warehouseId is not None:
11892 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11893 
      oprot.writeI64(self.warehouseId)
11894 
      oprot.writeFieldEnd()
4394 rajveer 11895 
    if self.status is not None:
4444 rajveer 11896 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11897 
      oprot.writeI64(self.status)
3064 chandransh 11898 
      oprot.writeFieldEnd()
4394 rajveer 11899 
    if self.timestamp is not None:
4444 rajveer 11900 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11901 
      oprot.writeI64(self.timestamp)
11902 
      oprot.writeFieldEnd()
94 ashish 11903 
    oprot.writeFieldStop()
11904 
    oprot.writeStructEnd()
11905 
 
3431 rajveer 11906 
  def validate(self):
11907 
    return
11908 
 
11909 
 
94 ashish 11910 
  def __repr__(self):
11911 
    L = ['%s=%r' % (key, value)
11912 
      for key, value in self.__dict__.iteritems()]
11913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11914 
 
11915 
  def __eq__(self, other):
11916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11917 
 
11918 
  def __ne__(self, other):
11919 
    return not (self == other)
11920 
 
3064 chandransh 11921 
class getAlerts_result:
94 ashish 11922 
  """
11923 
  Attributes:
11924 
   - success
11925 
  """
11926 
 
11927 
  thrift_spec = (
3064 chandransh 11928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11929 
  )
11930 
 
3064 chandransh 11931 
  def __init__(self, success=None,):
94 ashish 11932 
    self.success = success
11933 
 
11934 
  def read(self, iprot):
11935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11937 
      return
11938 
    iprot.readStructBegin()
11939 
    while True:
11940 
      (fname, ftype, fid) = iprot.readFieldBegin()
11941 
      if ftype == TType.STOP:
11942 
        break
11943 
      if fid == 0:
3064 chandransh 11944 
        if ftype == TType.LIST:
11945 
          self.success = []
6031 rajveer 11946 
          (_etype199, _size196) = iprot.readListBegin()
11947 
          for _i200 in xrange(_size196):
11948 
            _elem201 = Alert()
11949 
            _elem201.read(iprot)
11950 
            self.success.append(_elem201)
3064 chandransh 11951 
          iprot.readListEnd()
94 ashish 11952 
        else:
11953 
          iprot.skip(ftype)
11954 
      else:
11955 
        iprot.skip(ftype)
11956 
      iprot.readFieldEnd()
11957 
    iprot.readStructEnd()
11958 
 
11959 
  def write(self, oprot):
11960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11962 
      return
3064 chandransh 11963 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11964 
    if self.success is not None:
3064 chandransh 11965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11967 
      for iter202 in self.success:
11968 
        iter202.write(oprot)
3064 chandransh 11969 
      oprot.writeListEnd()
94 ashish 11970 
      oprot.writeFieldEnd()
11971 
    oprot.writeFieldStop()
11972 
    oprot.writeStructEnd()
11973 
 
3431 rajveer 11974 
  def validate(self):
11975 
    return
11976 
 
11977 
 
94 ashish 11978 
  def __repr__(self):
11979 
    L = ['%s=%r' % (key, value)
11980 
      for key, value in self.__dict__.iteritems()]
11981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11982 
 
11983 
  def __eq__(self, other):
11984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11985 
 
11986 
  def __ne__(self, other):
11987 
    return not (self == other)
11988 
 
4394 rajveer 11989 
class addAlert_args:
94 ashish 11990 
  """
11991 
  Attributes:
3064 chandransh 11992 
   - type
4444 rajveer 11993 
   - warehouseId
4394 rajveer 11994 
   - description
94 ashish 11995 
  """
11996 
 
11997 
  thrift_spec = (
11998 
    None, # 0
4394 rajveer 11999 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12000 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12001 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12002 
  )
12003 
 
4444 rajveer 12004 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12005 
    self.type = type
4444 rajveer 12006 
    self.warehouseId = warehouseId
4394 rajveer 12007 
    self.description = description
94 ashish 12008 
 
12009 
  def read(self, iprot):
12010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12012 
      return
12013 
    iprot.readStructBegin()
12014 
    while True:
12015 
      (fname, ftype, fid) = iprot.readFieldBegin()
12016 
      if ftype == TType.STOP:
12017 
        break
12018 
      if fid == 1:
12019 
        if ftype == TType.I64:
4394 rajveer 12020 
          self.type = iprot.readI64();
94 ashish 12021 
        else:
12022 
          iprot.skip(ftype)
3064 chandransh 12023 
      elif fid == 2:
4444 rajveer 12024 
        if ftype == TType.I64:
12025 
          self.warehouseId = iprot.readI64();
12026 
        else:
12027 
          iprot.skip(ftype)
12028 
      elif fid == 3:
3064 chandransh 12029 
        if ftype == TType.STRING:
4394 rajveer 12030 
          self.description = iprot.readString();
3064 chandransh 12031 
        else:
12032 
          iprot.skip(ftype)
94 ashish 12033 
      else:
12034 
        iprot.skip(ftype)
12035 
      iprot.readFieldEnd()
12036 
    iprot.readStructEnd()
12037 
 
12038 
  def write(self, oprot):
12039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12041 
      return
4394 rajveer 12042 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12043 
    if self.type is not None:
4394 rajveer 12044 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12045 
      oprot.writeI64(self.type)
12046 
      oprot.writeFieldEnd()
4444 rajveer 12047 
    if self.warehouseId is not None:
12048 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12049 
      oprot.writeI64(self.warehouseId)
12050 
      oprot.writeFieldEnd()
4394 rajveer 12051 
    if self.description is not None:
4444 rajveer 12052 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12053 
      oprot.writeString(self.description)
3064 chandransh 12054 
      oprot.writeFieldEnd()
94 ashish 12055 
    oprot.writeFieldStop()
12056 
    oprot.writeStructEnd()
12057 
 
3431 rajveer 12058 
  def validate(self):
12059 
    return
12060 
 
12061 
 
94 ashish 12062 
  def __repr__(self):
12063 
    L = ['%s=%r' % (key, value)
12064 
      for key, value in self.__dict__.iteritems()]
12065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12066 
 
12067 
  def __eq__(self, other):
12068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12069 
 
12070 
  def __ne__(self, other):
12071 
    return not (self == other)
12072 
 
4394 rajveer 12073 
class addAlert_result:
3064 chandransh 12074 
 
12075 
  thrift_spec = (
12076 
  )
12077 
 
12078 
  def read(self, iprot):
12079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12081 
      return
12082 
    iprot.readStructBegin()
12083 
    while True:
12084 
      (fname, ftype, fid) = iprot.readFieldBegin()
12085 
      if ftype == TType.STOP:
12086 
        break
12087 
      else:
12088 
        iprot.skip(ftype)
12089 
      iprot.readFieldEnd()
12090 
    iprot.readStructEnd()
12091 
 
12092 
  def write(self, oprot):
12093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12095 
      return
4394 rajveer 12096 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12097 
    oprot.writeFieldStop()
12098 
    oprot.writeStructEnd()
12099 
 
3431 rajveer 12100 
  def validate(self):
12101 
    return
12102 
 
12103 
 
3064 chandransh 12104 
  def __repr__(self):
12105 
    L = ['%s=%r' % (key, value)
12106 
      for key, value in self.__dict__.iteritems()]
12107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12108 
 
12109 
  def __eq__(self, other):
12110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12111 
 
12112 
  def __ne__(self, other):
12113 
    return not (self == other)
12114 
 
4444 rajveer 12115 
class markAlertsAsSeen_args:
12116 
  """
12117 
  Attributes:
12118 
   - warehouseId
12119 
  """
12120 
 
12121 
  thrift_spec = (
12122 
    None, # 0
12123 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12124 
  )
12125 
 
12126 
  def __init__(self, warehouseId=None,):
12127 
    self.warehouseId = warehouseId
12128 
 
12129 
  def read(self, iprot):
12130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12132 
      return
12133 
    iprot.readStructBegin()
12134 
    while True:
12135 
      (fname, ftype, fid) = iprot.readFieldBegin()
12136 
      if ftype == TType.STOP:
12137 
        break
12138 
      if fid == 1:
12139 
        if ftype == TType.I64:
12140 
          self.warehouseId = iprot.readI64();
12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
12152 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12153 
    if self.warehouseId is not None:
12154 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12155 
      oprot.writeI64(self.warehouseId)
12156 
      oprot.writeFieldEnd()
12157 
    oprot.writeFieldStop()
12158 
    oprot.writeStructEnd()
12159 
 
12160 
  def validate(self):
12161 
    return
12162 
 
12163 
 
12164 
  def __repr__(self):
12165 
    L = ['%s=%r' % (key, value)
12166 
      for key, value in self.__dict__.iteritems()]
12167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12168 
 
12169 
  def __eq__(self, other):
12170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12171 
 
12172 
  def __ne__(self, other):
12173 
    return not (self == other)
12174 
 
12175 
class markAlertsAsSeen_result:
12176 
 
12177 
  thrift_spec = (
12178 
  )
12179 
 
12180 
  def read(self, iprot):
12181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12183 
      return
12184 
    iprot.readStructBegin()
12185 
    while True:
12186 
      (fname, ftype, fid) = iprot.readFieldBegin()
12187 
      if ftype == TType.STOP:
12188 
        break
12189 
      else:
12190 
        iprot.skip(ftype)
12191 
      iprot.readFieldEnd()
12192 
    iprot.readStructEnd()
12193 
 
12194 
  def write(self, oprot):
12195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12197 
      return
12198 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12199 
    oprot.writeFieldStop()
12200 
    oprot.writeStructEnd()
12201 
 
12202 
  def validate(self):
12203 
    return
12204 
 
12205 
 
12206 
  def __repr__(self):
12207 
    L = ['%s=%r' % (key, value)
12208 
      for key, value in self.__dict__.iteritems()]
12209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12210 
 
12211 
  def __eq__(self, other):
12212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12213 
 
12214 
  def __ne__(self, other):
12215 
    return not (self == other)
12216 
 
3064 chandransh 12217 
class getValidOrderCount_args:
12218 
 
12219 
  thrift_spec = (
12220 
  )
12221 
 
12222 
  def read(self, iprot):
12223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12225 
      return
12226 
    iprot.readStructBegin()
12227 
    while True:
12228 
      (fname, ftype, fid) = iprot.readFieldBegin()
12229 
      if ftype == TType.STOP:
12230 
        break
12231 
      else:
12232 
        iprot.skip(ftype)
12233 
      iprot.readFieldEnd()
12234 
    iprot.readStructEnd()
12235 
 
12236 
  def write(self, oprot):
12237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12239 
      return
12240 
    oprot.writeStructBegin('getValidOrderCount_args')
12241 
    oprot.writeFieldStop()
12242 
    oprot.writeStructEnd()
12243 
 
3431 rajveer 12244 
  def validate(self):
12245 
    return
12246 
 
12247 
 
3064 chandransh 12248 
  def __repr__(self):
12249 
    L = ['%s=%r' % (key, value)
12250 
      for key, value in self.__dict__.iteritems()]
12251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12252 
 
12253 
  def __eq__(self, other):
12254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12255 
 
12256 
  def __ne__(self, other):
12257 
    return not (self == other)
12258 
 
12259 
class getValidOrderCount_result:
94 ashish 12260 
  """
12261 
  Attributes:
12262 
   - success
12263 
  """
12264 
 
12265 
  thrift_spec = (
3064 chandransh 12266 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12267 
  )
12268 
 
3064 chandransh 12269 
  def __init__(self, success=None,):
94 ashish 12270 
    self.success = success
12271 
 
12272 
  def read(self, iprot):
12273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12275 
      return
12276 
    iprot.readStructBegin()
12277 
    while True:
12278 
      (fname, ftype, fid) = iprot.readFieldBegin()
12279 
      if ftype == TType.STOP:
12280 
        break
12281 
      if fid == 0:
3064 chandransh 12282 
        if ftype == TType.I64:
12283 
          self.success = iprot.readI64();
94 ashish 12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      else:
12287 
        iprot.skip(ftype)
12288 
      iprot.readFieldEnd()
12289 
    iprot.readStructEnd()
12290 
 
12291 
  def write(self, oprot):
12292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12294 
      return
3064 chandransh 12295 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12296 
    if self.success is not None:
3064 chandransh 12297 
      oprot.writeFieldBegin('success', TType.I64, 0)
12298 
      oprot.writeI64(self.success)
94 ashish 12299 
      oprot.writeFieldEnd()
12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
3431 rajveer 12303 
  def validate(self):
12304 
    return
12305 
 
12306 
 
94 ashish 12307 
  def __repr__(self):
12308 
    L = ['%s=%r' % (key, value)
12309 
      for key, value in self.__dict__.iteritems()]
12310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12311 
 
12312 
  def __eq__(self, other):
12313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12314 
 
12315 
  def __ne__(self, other):
12316 
    return not (self == other)
12317 
 
3064 chandransh 12318 
class getNoOfCustomersWithSuccessfulTransaction_args:
12319 
 
12320 
  thrift_spec = (
12321 
  )
12322 
 
12323 
  def read(self, iprot):
12324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12326 
      return
12327 
    iprot.readStructBegin()
12328 
    while True:
12329 
      (fname, ftype, fid) = iprot.readFieldBegin()
12330 
      if ftype == TType.STOP:
12331 
        break
12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
12341 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12342 
    oprot.writeFieldStop()
12343 
    oprot.writeStructEnd()
12344 
 
3431 rajveer 12345 
  def validate(self):
12346 
    return
12347 
 
12348 
 
3064 chandransh 12349 
  def __repr__(self):
12350 
    L = ['%s=%r' % (key, value)
12351 
      for key, value in self.__dict__.iteritems()]
12352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12353 
 
12354 
  def __eq__(self, other):
12355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12356 
 
12357 
  def __ne__(self, other):
12358 
    return not (self == other)
12359 
 
12360 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12361 
  """
12362 
  Attributes:
3064 chandransh 12363 
   - success
94 ashish 12364 
  """
12365 
 
12366 
  thrift_spec = (
3064 chandransh 12367 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12368 
  )
12369 
 
3064 chandransh 12370 
  def __init__(self, success=None,):
12371 
    self.success = success
94 ashish 12372 
 
12373 
  def read(self, iprot):
12374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12376 
      return
12377 
    iprot.readStructBegin()
12378 
    while True:
12379 
      (fname, ftype, fid) = iprot.readFieldBegin()
12380 
      if ftype == TType.STOP:
12381 
        break
3064 chandransh 12382 
      if fid == 0:
94 ashish 12383 
        if ftype == TType.I64:
3064 chandransh 12384 
          self.success = iprot.readI64();
94 ashish 12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      else:
12388 
        iprot.skip(ftype)
12389 
      iprot.readFieldEnd()
12390 
    iprot.readStructEnd()
12391 
 
12392 
  def write(self, oprot):
12393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12395 
      return
3064 chandransh 12396 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12397 
    if self.success is not None:
3064 chandransh 12398 
      oprot.writeFieldBegin('success', TType.I64, 0)
12399 
      oprot.writeI64(self.success)
94 ashish 12400 
      oprot.writeFieldEnd()
12401 
    oprot.writeFieldStop()
12402 
    oprot.writeStructEnd()
12403 
 
3431 rajveer 12404 
  def validate(self):
12405 
    return
12406 
 
12407 
 
94 ashish 12408 
  def __repr__(self):
12409 
    L = ['%s=%r' % (key, value)
12410 
      for key, value in self.__dict__.iteritems()]
12411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12412 
 
12413 
  def __eq__(self, other):
12414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12415 
 
12416 
  def __ne__(self, other):
12417 
    return not (self == other)
12418 
 
3064 chandransh 12419 
class getValidOrdersAmountRange_args:
12420 
 
12421 
  thrift_spec = (
12422 
  )
12423 
 
12424 
  def read(self, iprot):
12425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12427 
      return
12428 
    iprot.readStructBegin()
12429 
    while True:
12430 
      (fname, ftype, fid) = iprot.readFieldBegin()
12431 
      if ftype == TType.STOP:
12432 
        break
12433 
      else:
12434 
        iprot.skip(ftype)
12435 
      iprot.readFieldEnd()
12436 
    iprot.readStructEnd()
12437 
 
12438 
  def write(self, oprot):
12439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12441 
      return
12442 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12443 
    oprot.writeFieldStop()
12444 
    oprot.writeStructEnd()
12445 
 
3431 rajveer 12446 
  def validate(self):
12447 
    return
12448 
 
12449 
 
3064 chandransh 12450 
  def __repr__(self):
12451 
    L = ['%s=%r' % (key, value)
12452 
      for key, value in self.__dict__.iteritems()]
12453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12454 
 
12455 
  def __eq__(self, other):
12456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12457 
 
12458 
  def __ne__(self, other):
12459 
    return not (self == other)
12460 
 
12461 
class getValidOrdersAmountRange_result:
94 ashish 12462 
  """
12463 
  Attributes:
12464 
   - success
12465 
  """
12466 
 
12467 
  thrift_spec = (
3064 chandransh 12468 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12469 
  )
12470 
 
3064 chandransh 12471 
  def __init__(self, success=None,):
94 ashish 12472 
    self.success = success
12473 
 
12474 
  def read(self, iprot):
12475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12477 
      return
12478 
    iprot.readStructBegin()
12479 
    while True:
12480 
      (fname, ftype, fid) = iprot.readFieldBegin()
12481 
      if ftype == TType.STOP:
12482 
        break
12483 
      if fid == 0:
483 rajveer 12484 
        if ftype == TType.LIST:
12485 
          self.success = []
6031 rajveer 12486 
          (_etype206, _size203) = iprot.readListBegin()
12487 
          for _i207 in xrange(_size203):
12488 
            _elem208 = iprot.readDouble();
12489 
            self.success.append(_elem208)
483 rajveer 12490 
          iprot.readListEnd()
94 ashish 12491 
        else:
12492 
          iprot.skip(ftype)
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
3064 chandransh 12502 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12503 
    if self.success is not None:
483 rajveer 12504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12505 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12506 
      for iter209 in self.success:
12507 
        oprot.writeDouble(iter209)
483 rajveer 12508 
      oprot.writeListEnd()
94 ashish 12509 
      oprot.writeFieldEnd()
12510 
    oprot.writeFieldStop()
12511 
    oprot.writeStructEnd()
12512 
 
3431 rajveer 12513 
  def validate(self):
12514 
    return
12515 
 
12516 
 
94 ashish 12517 
  def __repr__(self):
12518 
    L = ['%s=%r' % (key, value)
12519 
      for key, value in self.__dict__.iteritems()]
12520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12521 
 
12522 
  def __eq__(self, other):
12523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12524 
 
12525 
  def __ne__(self, other):
12526 
    return not (self == other)
12527 
 
3064 chandransh 12528 
class getValidOrders_args:
1528 ankur.sing 12529 
  """
12530 
  Attributes:
3064 chandransh 12531 
   - limit
5874 rajveer 12532 
   - onlyStore
1528 ankur.sing 12533 
  """
12534 
 
12535 
  thrift_spec = (
12536 
    None, # 0
3064 chandransh 12537 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12538 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12539 
  )
12540 
 
5874 rajveer 12541 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12542 
    self.limit = limit
5874 rajveer 12543 
    self.onlyStore = onlyStore
1528 ankur.sing 12544 
 
12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
12554 
      if fid == 1:
12555 
        if ftype == TType.I64:
3064 chandransh 12556 
          self.limit = iprot.readI64();
1528 ankur.sing 12557 
        else:
12558 
          iprot.skip(ftype)
5874 rajveer 12559 
      elif fid == 2:
12560 
        if ftype == TType.BOOL:
12561 
          self.onlyStore = iprot.readBool();
12562 
        else:
12563 
          iprot.skip(ftype)
1528 ankur.sing 12564 
      else:
12565 
        iprot.skip(ftype)
12566 
      iprot.readFieldEnd()
12567 
    iprot.readStructEnd()
12568 
 
12569 
  def write(self, oprot):
12570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12572 
      return
3064 chandransh 12573 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12574 
    if self.limit is not None:
3064 chandransh 12575 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12576 
      oprot.writeI64(self.limit)
1528 ankur.sing 12577 
      oprot.writeFieldEnd()
5874 rajveer 12578 
    if self.onlyStore is not None:
12579 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12580 
      oprot.writeBool(self.onlyStore)
12581 
      oprot.writeFieldEnd()
1528 ankur.sing 12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
3431 rajveer 12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
1528 ankur.sing 12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
3064 chandransh 12600 
class getValidOrders_result:
1528 ankur.sing 12601 
  """
12602 
  Attributes:
12603 
   - success
12604 
  """
12605 
 
12606 
  thrift_spec = (
3064 chandransh 12607 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12608 
  )
12609 
 
3064 chandransh 12610 
  def __init__(self, success=None,):
1528 ankur.sing 12611 
    self.success = success
12612 
 
12613 
  def read(self, iprot):
12614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12616 
      return
12617 
    iprot.readStructBegin()
12618 
    while True:
12619 
      (fname, ftype, fid) = iprot.readFieldBegin()
12620 
      if ftype == TType.STOP:
12621 
        break
12622 
      if fid == 0:
3064 chandransh 12623 
        if ftype == TType.LIST:
12624 
          self.success = []
6031 rajveer 12625 
          (_etype213, _size210) = iprot.readListBegin()
12626 
          for _i214 in xrange(_size210):
12627 
            _elem215 = Order()
12628 
            _elem215.read(iprot)
12629 
            self.success.append(_elem215)
3064 chandransh 12630 
          iprot.readListEnd()
1528 ankur.sing 12631 
        else:
12632 
          iprot.skip(ftype)
12633 
      else:
12634 
        iprot.skip(ftype)
12635 
      iprot.readFieldEnd()
12636 
    iprot.readStructEnd()
12637 
 
12638 
  def write(self, oprot):
12639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12641 
      return
3064 chandransh 12642 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12643 
    if self.success is not None:
3064 chandransh 12644 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12645 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12646 
      for iter216 in self.success:
12647 
        iter216.write(oprot)
3064 chandransh 12648 
      oprot.writeListEnd()
1528 ankur.sing 12649 
      oprot.writeFieldEnd()
12650 
    oprot.writeFieldStop()
12651 
    oprot.writeStructEnd()
12652 
 
3431 rajveer 12653 
  def validate(self):
12654 
    return
12655 
 
12656 
 
1528 ankur.sing 12657 
  def __repr__(self):
12658 
    L = ['%s=%r' % (key, value)
12659 
      for key, value in self.__dict__.iteritems()]
12660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12661 
 
12662 
  def __eq__(self, other):
12663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12664 
 
12665 
  def __ne__(self, other):
12666 
    return not (self == other)
12667 
 
1220 chandransh 12668 
class batchOrders_args:
12669 
  """
12670 
  Attributes:
12671 
   - warehouseId
12672 
  """
12673 
 
12674 
  thrift_spec = (
12675 
    None, # 0
12676 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12677 
  )
12678 
 
12679 
  def __init__(self, warehouseId=None,):
12680 
    self.warehouseId = warehouseId
12681 
 
12682 
  def read(self, iprot):
12683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12685 
      return
12686 
    iprot.readStructBegin()
12687 
    while True:
12688 
      (fname, ftype, fid) = iprot.readFieldBegin()
12689 
      if ftype == TType.STOP:
12690 
        break
12691 
      if fid == 1:
12692 
        if ftype == TType.I64:
12693 
          self.warehouseId = iprot.readI64();
12694 
        else:
12695 
          iprot.skip(ftype)
12696 
      else:
12697 
        iprot.skip(ftype)
12698 
      iprot.readFieldEnd()
12699 
    iprot.readStructEnd()
12700 
 
12701 
  def write(self, oprot):
12702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12704 
      return
12705 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12706 
    if self.warehouseId is not None:
1220 chandransh 12707 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12708 
      oprot.writeI64(self.warehouseId)
12709 
      oprot.writeFieldEnd()
12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
3431 rajveer 12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
1220 chandransh 12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class batchOrders_result:
12729 
  """
12730 
  Attributes:
12731 
   - success
12732 
   - ex
12733 
  """
12734 
 
12735 
  thrift_spec = (
12736 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12738 
  )
12739 
 
12740 
  def __init__(self, success=None, ex=None,):
12741 
    self.success = success
12742 
    self.ex = ex
12743 
 
12744 
  def read(self, iprot):
12745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12747 
      return
12748 
    iprot.readStructBegin()
12749 
    while True:
12750 
      (fname, ftype, fid) = iprot.readFieldBegin()
12751 
      if ftype == TType.STOP:
12752 
        break
12753 
      if fid == 0:
12754 
        if ftype == TType.LIST:
12755 
          self.success = []
6031 rajveer 12756 
          (_etype220, _size217) = iprot.readListBegin()
12757 
          for _i221 in xrange(_size217):
12758 
            _elem222 = Order()
12759 
            _elem222.read(iprot)
12760 
            self.success.append(_elem222)
1220 chandransh 12761 
          iprot.readListEnd()
12762 
        else:
12763 
          iprot.skip(ftype)
12764 
      elif fid == 1:
12765 
        if ftype == TType.STRUCT:
12766 
          self.ex = TransactionServiceException()
12767 
          self.ex.read(iprot)
12768 
        else:
12769 
          iprot.skip(ftype)
12770 
      else:
12771 
        iprot.skip(ftype)
12772 
      iprot.readFieldEnd()
12773 
    iprot.readStructEnd()
12774 
 
12775 
  def write(self, oprot):
12776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12778 
      return
12779 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12780 
    if self.success is not None:
1220 chandransh 12781 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12782 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12783 
      for iter223 in self.success:
12784 
        iter223.write(oprot)
1220 chandransh 12785 
      oprot.writeListEnd()
12786 
      oprot.writeFieldEnd()
3431 rajveer 12787 
    if self.ex is not None:
1220 chandransh 12788 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12789 
      self.ex.write(oprot)
12790 
      oprot.writeFieldEnd()
12791 
    oprot.writeFieldStop()
12792 
    oprot.writeStructEnd()
12793 
 
3431 rajveer 12794 
  def validate(self):
12795 
    return
12796 
 
12797 
 
1220 chandransh 12798 
  def __repr__(self):
12799 
    L = ['%s=%r' % (key, value)
12800 
      for key, value in self.__dict__.iteritems()]
12801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12802 
 
12803 
  def __eq__(self, other):
12804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12805 
 
12806 
  def __ne__(self, other):
12807 
    return not (self == other)
12808 
 
1208 chandransh 12809 
class markOrderAsOutOfStock_args:
12810 
  """
12811 
  Attributes:
12812 
   - orderId
12813 
  """
12814 
 
12815 
  thrift_spec = (
12816 
    None, # 0
12817 
    (1, TType.I64, 'orderId', None, None, ), # 1
12818 
  )
12819 
 
12820 
  def __init__(self, orderId=None,):
12821 
    self.orderId = orderId
12822 
 
12823 
  def read(self, iprot):
12824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12826 
      return
12827 
    iprot.readStructBegin()
12828 
    while True:
12829 
      (fname, ftype, fid) = iprot.readFieldBegin()
12830 
      if ftype == TType.STOP:
12831 
        break
12832 
      if fid == 1:
12833 
        if ftype == TType.I64:
12834 
          self.orderId = iprot.readI64();
12835 
        else:
12836 
          iprot.skip(ftype)
12837 
      else:
12838 
        iprot.skip(ftype)
12839 
      iprot.readFieldEnd()
12840 
    iprot.readStructEnd()
12841 
 
12842 
  def write(self, oprot):
12843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12845 
      return
12846 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12847 
    if self.orderId is not None:
1208 chandransh 12848 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12849 
      oprot.writeI64(self.orderId)
12850 
      oprot.writeFieldEnd()
12851 
    oprot.writeFieldStop()
12852 
    oprot.writeStructEnd()
12853 
 
3431 rajveer 12854 
  def validate(self):
12855 
    return
12856 
 
12857 
 
1208 chandransh 12858 
  def __repr__(self):
12859 
    L = ['%s=%r' % (key, value)
12860 
      for key, value in self.__dict__.iteritems()]
12861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12862 
 
12863 
  def __eq__(self, other):
12864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12865 
 
12866 
  def __ne__(self, other):
12867 
    return not (self == other)
12868 
 
12869 
class markOrderAsOutOfStock_result:
12870 
  """
12871 
  Attributes:
12872 
   - success
12873 
   - ex
12874 
  """
12875 
 
12876 
  thrift_spec = (
12877 
    (0, TType.BOOL, 'success', None, None, ), # 0
12878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12879 
  )
12880 
 
12881 
  def __init__(self, success=None, ex=None,):
12882 
    self.success = success
12883 
    self.ex = ex
12884 
 
12885 
  def read(self, iprot):
12886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12888 
      return
12889 
    iprot.readStructBegin()
12890 
    while True:
12891 
      (fname, ftype, fid) = iprot.readFieldBegin()
12892 
      if ftype == TType.STOP:
12893 
        break
12894 
      if fid == 0:
12895 
        if ftype == TType.BOOL:
12896 
          self.success = iprot.readBool();
12897 
        else:
12898 
          iprot.skip(ftype)
12899 
      elif fid == 1:
12900 
        if ftype == TType.STRUCT:
12901 
          self.ex = TransactionServiceException()
12902 
          self.ex.read(iprot)
12903 
        else:
12904 
          iprot.skip(ftype)
12905 
      else:
12906 
        iprot.skip(ftype)
12907 
      iprot.readFieldEnd()
12908 
    iprot.readStructEnd()
12909 
 
12910 
  def write(self, oprot):
12911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12913 
      return
12914 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12915 
    if self.success is not None:
1208 chandransh 12916 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12917 
      oprot.writeBool(self.success)
12918 
      oprot.writeFieldEnd()
3431 rajveer 12919 
    if self.ex is not None:
1208 chandransh 12920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12921 
      self.ex.write(oprot)
12922 
      oprot.writeFieldEnd()
12923 
    oprot.writeFieldStop()
12924 
    oprot.writeStructEnd()
12925 
 
3431 rajveer 12926 
  def validate(self):
12927 
    return
12928 
 
12929 
 
1208 chandransh 12930 
  def __repr__(self):
12931 
    L = ['%s=%r' % (key, value)
12932 
      for key, value in self.__dict__.iteritems()]
12933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12934 
 
12935 
  def __eq__(self, other):
12936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12937 
 
12938 
  def __ne__(self, other):
12939 
    return not (self == other)
12940 
 
3064 chandransh 12941 
class verifyOrder_args:
759 chandransh 12942 
  """
12943 
  Attributes:
3064 chandransh 12944 
   - orderId
759 chandransh 12945 
  """
12946 
 
12947 
  thrift_spec = (
12948 
    None, # 0
3064 chandransh 12949 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12950 
  )
12951 
 
3064 chandransh 12952 
  def __init__(self, orderId=None,):
12953 
    self.orderId = orderId
759 chandransh 12954 
 
12955 
  def read(self, iprot):
12956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12958 
      return
12959 
    iprot.readStructBegin()
12960 
    while True:
12961 
      (fname, ftype, fid) = iprot.readFieldBegin()
12962 
      if ftype == TType.STOP:
12963 
        break
12964 
      if fid == 1:
12965 
        if ftype == TType.I64:
3064 chandransh 12966 
          self.orderId = iprot.readI64();
759 chandransh 12967 
        else:
12968 
          iprot.skip(ftype)
12969 
      else:
12970 
        iprot.skip(ftype)
12971 
      iprot.readFieldEnd()
12972 
    iprot.readStructEnd()
12973 
 
12974 
  def write(self, oprot):
12975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12977 
      return
3064 chandransh 12978 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12979 
    if self.orderId is not None:
3064 chandransh 12980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12981 
      oprot.writeI64(self.orderId)
759 chandransh 12982 
      oprot.writeFieldEnd()
12983 
    oprot.writeFieldStop()
12984 
    oprot.writeStructEnd()
12985 
 
3431 rajveer 12986 
  def validate(self):
12987 
    return
12988 
 
12989 
 
759 chandransh 12990 
  def __repr__(self):
12991 
    L = ['%s=%r' % (key, value)
12992 
      for key, value in self.__dict__.iteritems()]
12993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12994 
 
12995 
  def __eq__(self, other):
12996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12997 
 
12998 
  def __ne__(self, other):
12999 
    return not (self == other)
13000 
 
3064 chandransh 13001 
class verifyOrder_result:
759 chandransh 13002 
  """
13003 
  Attributes:
13004 
   - success
13005 
   - ex
13006 
  """
13007 
 
13008 
  thrift_spec = (
13009 
    (0, TType.BOOL, 'success', None, None, ), # 0
13010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13011 
  )
13012 
 
13013 
  def __init__(self, success=None, ex=None,):
13014 
    self.success = success
13015 
    self.ex = ex
13016 
 
13017 
  def read(self, iprot):
13018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13020 
      return
13021 
    iprot.readStructBegin()
13022 
    while True:
13023 
      (fname, ftype, fid) = iprot.readFieldBegin()
13024 
      if ftype == TType.STOP:
13025 
        break
13026 
      if fid == 0:
13027 
        if ftype == TType.BOOL:
13028 
          self.success = iprot.readBool();
13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      elif fid == 1:
13032 
        if ftype == TType.STRUCT:
13033 
          self.ex = TransactionServiceException()
13034 
          self.ex.read(iprot)
13035 
        else:
13036 
          iprot.skip(ftype)
13037 
      else:
13038 
        iprot.skip(ftype)
13039 
      iprot.readFieldEnd()
13040 
    iprot.readStructEnd()
13041 
 
13042 
  def write(self, oprot):
13043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13045 
      return
3064 chandransh 13046 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13047 
    if self.success is not None:
759 chandransh 13048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13049 
      oprot.writeBool(self.success)
13050 
      oprot.writeFieldEnd()
3431 rajveer 13051 
    if self.ex is not None:
759 chandransh 13052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13053 
      self.ex.write(oprot)
13054 
      oprot.writeFieldEnd()
13055 
    oprot.writeFieldStop()
13056 
    oprot.writeStructEnd()
13057 
 
3431 rajveer 13058 
  def validate(self):
13059 
    return
13060 
 
13061 
 
759 chandransh 13062 
  def __repr__(self):
13063 
    L = ['%s=%r' % (key, value)
13064 
      for key, value in self.__dict__.iteritems()]
13065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13066 
 
13067 
  def __eq__(self, other):
13068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13069 
 
13070 
  def __ne__(self, other):
13071 
    return not (self == other)
13072 
 
3064 chandransh 13073 
class acceptOrder_args:
1113 chandransh 13074 
  """
13075 
  Attributes:
3064 chandransh 13076 
   - orderId
1113 chandransh 13077 
  """
13078 
 
13079 
  thrift_spec = (
13080 
    None, # 0
3064 chandransh 13081 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13082 
  )
13083 
 
3064 chandransh 13084 
  def __init__(self, orderId=None,):
13085 
    self.orderId = orderId
1113 chandransh 13086 
 
13087 
  def read(self, iprot):
13088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13090 
      return
13091 
    iprot.readStructBegin()
13092 
    while True:
13093 
      (fname, ftype, fid) = iprot.readFieldBegin()
13094 
      if ftype == TType.STOP:
13095 
        break
13096 
      if fid == 1:
13097 
        if ftype == TType.I64:
3064 chandransh 13098 
          self.orderId = iprot.readI64();
1113 chandransh 13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      else:
13102 
        iprot.skip(ftype)
13103 
      iprot.readFieldEnd()
13104 
    iprot.readStructEnd()
13105 
 
13106 
  def write(self, oprot):
13107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13109 
      return
3064 chandransh 13110 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13111 
    if self.orderId is not None:
3064 chandransh 13112 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13113 
      oprot.writeI64(self.orderId)
1113 chandransh 13114 
      oprot.writeFieldEnd()
13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
3431 rajveer 13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
1113 chandransh 13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
3064 chandransh 13133 
class acceptOrder_result:
1113 chandransh 13134 
  """
13135 
  Attributes:
13136 
   - success
13137 
   - ex
13138 
  """
13139 
 
13140 
  thrift_spec = (
3064 chandransh 13141 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13143 
  )
13144 
 
13145 
  def __init__(self, success=None, ex=None,):
13146 
    self.success = success
13147 
    self.ex = ex
13148 
 
13149 
  def read(self, iprot):
13150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13152 
      return
13153 
    iprot.readStructBegin()
13154 
    while True:
13155 
      (fname, ftype, fid) = iprot.readFieldBegin()
13156 
      if ftype == TType.STOP:
13157 
        break
13158 
      if fid == 0:
3064 chandransh 13159 
        if ftype == TType.BOOL:
13160 
          self.success = iprot.readBool();
1113 chandransh 13161 
        else:
13162 
          iprot.skip(ftype)
13163 
      elif fid == 1:
13164 
        if ftype == TType.STRUCT:
13165 
          self.ex = TransactionServiceException()
13166 
          self.ex.read(iprot)
13167 
        else:
13168 
          iprot.skip(ftype)
13169 
      else:
13170 
        iprot.skip(ftype)
13171 
      iprot.readFieldEnd()
13172 
    iprot.readStructEnd()
13173 
 
13174 
  def write(self, oprot):
13175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13177 
      return
3064 chandransh 13178 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13179 
    if self.success is not None:
3064 chandransh 13180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13181 
      oprot.writeBool(self.success)
1113 chandransh 13182 
      oprot.writeFieldEnd()
3431 rajveer 13183 
    if self.ex is not None:
1113 chandransh 13184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13185 
      self.ex.write(oprot)
13186 
      oprot.writeFieldEnd()
13187 
    oprot.writeFieldStop()
13188 
    oprot.writeStructEnd()
13189 
 
3431 rajveer 13190 
  def validate(self):
13191 
    return
13192 
 
13193 
 
1113 chandransh 13194 
  def __repr__(self):
13195 
    L = ['%s=%r' % (key, value)
13196 
      for key, value in self.__dict__.iteritems()]
13197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13198 
 
13199 
  def __eq__(self, other):
13200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13201 
 
13202 
  def __ne__(self, other):
13203 
    return not (self == other)
13204 
 
3064 chandransh 13205 
class addBillingDetails_args:
1135 chandransh 13206 
  """
13207 
  Attributes:
3064 chandransh 13208 
   - orderId
13209 
   - invoice_number
4658 mandeep.dh 13210 
   - serialNumber
4283 anupam.sin 13211 
   - itemNumber
3064 chandransh 13212 
   - billed_by
4264 rajveer 13213 
   - jacketNumber
4283 anupam.sin 13214 
   - billingType
5110 mandeep.dh 13215 
   - fulfilmentWarehouseId
4763 rajveer 13216 
   - authorize
1135 chandransh 13217 
  """
13218 
 
13219 
  thrift_spec = (
13220 
    None, # 0
3064 chandransh 13221 
    (1, TType.I64, 'orderId', None, None, ), # 1
13222 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13223 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13224 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13225 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13226 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13227 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13228 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13229 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13230 
  )
13231 
 
5110 mandeep.dh 13232 
  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 13233 
    self.orderId = orderId
13234 
    self.invoice_number = invoice_number
4658 mandeep.dh 13235 
    self.serialNumber = serialNumber
4283 anupam.sin 13236 
    self.itemNumber = itemNumber
3064 chandransh 13237 
    self.billed_by = billed_by
4264 rajveer 13238 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13239 
    self.billingType = billingType
5110 mandeep.dh 13240 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13241 
    self.authorize = authorize
1135 chandransh 13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 1:
13253 
        if ftype == TType.I64:
3064 chandransh 13254 
          self.orderId = iprot.readI64();
1135 chandransh 13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      elif fid == 2:
3064 chandransh 13258 
        if ftype == TType.STRING:
13259 
          self.invoice_number = iprot.readString();
1135 chandransh 13260 
        else:
13261 
          iprot.skip(ftype)
3064 chandransh 13262 
      elif fid == 3:
5411 rajveer 13263 
        if ftype == TType.LIST:
13264 
          self.serialNumber = []
6031 rajveer 13265 
          (_etype227, _size224) = iprot.readListBegin()
13266 
          for _i228 in xrange(_size224):
13267 
            _elem229 = iprot.readString();
13268 
            self.serialNumber.append(_elem229)
5411 rajveer 13269 
          iprot.readListEnd()
3064 chandransh 13270 
        else:
13271 
          iprot.skip(ftype)
13272 
      elif fid == 4:
5411 rajveer 13273 
        if ftype == TType.LIST:
13274 
          self.itemNumber = []
6031 rajveer 13275 
          (_etype233, _size230) = iprot.readListBegin()
13276 
          for _i234 in xrange(_size230):
13277 
            _elem235 = iprot.readString();
13278 
            self.itemNumber.append(_elem235)
5411 rajveer 13279 
          iprot.readListEnd()
3064 chandransh 13280 
        else:
13281 
          iprot.skip(ftype)
13282 
      elif fid == 5:
13283 
        if ftype == TType.STRING:
4283 anupam.sin 13284 
          self.billed_by = iprot.readString();
3064 chandransh 13285 
        else:
13286 
          iprot.skip(ftype)
13287 
      elif fid == 6:
13288 
        if ftype == TType.I64:
4283 anupam.sin 13289 
          self.jacketNumber = iprot.readI64();
13290 
        else:
13291 
          iprot.skip(ftype)
13292 
      elif fid == 7:
13293 
        if ftype == TType.I64:
3064 chandransh 13294 
          self.billingType = iprot.readI64();
13295 
        else:
13296 
          iprot.skip(ftype)
4283 anupam.sin 13297 
      elif fid == 8:
13298 
        if ftype == TType.I64:
5110 mandeep.dh 13299 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13300 
        else:
13301 
          iprot.skip(ftype)
4763 rajveer 13302 
      elif fid == 9:
13303 
        if ftype == TType.BOOL:
13304 
          self.authorize = iprot.readBool();
13305 
        else:
13306 
          iprot.skip(ftype)
1246 chandransh 13307 
      else:
13308 
        iprot.skip(ftype)
13309 
      iprot.readFieldEnd()
13310 
    iprot.readStructEnd()
13311 
 
13312 
  def write(self, oprot):
13313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13315 
      return
4283 anupam.sin 13316 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13317 
    if self.orderId is not None:
3064 chandransh 13318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13319 
      oprot.writeI64(self.orderId)
1246 chandransh 13320 
      oprot.writeFieldEnd()
4283 anupam.sin 13321 
    if self.invoice_number is not None:
13322 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13323 
      oprot.writeString(self.invoice_number)
1246 chandransh 13324 
      oprot.writeFieldEnd()
4658 mandeep.dh 13325 
    if self.serialNumber is not None:
5411 rajveer 13326 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13327 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 13328 
      for iter236 in self.serialNumber:
13329 
        oprot.writeString(iter236)
5411 rajveer 13330 
      oprot.writeListEnd()
3064 chandransh 13331 
      oprot.writeFieldEnd()
3431 rajveer 13332 
    if self.itemNumber is not None:
5411 rajveer 13333 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13334 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 13335 
      for iter237 in self.itemNumber:
13336 
        oprot.writeString(iter237)
5411 rajveer 13337 
      oprot.writeListEnd()
3064 chandransh 13338 
      oprot.writeFieldEnd()
4283 anupam.sin 13339 
    if self.billed_by is not None:
13340 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13341 
      oprot.writeString(self.billed_by)
3064 chandransh 13342 
      oprot.writeFieldEnd()
4283 anupam.sin 13343 
    if self.jacketNumber is not None:
13344 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13345 
      oprot.writeI64(self.jacketNumber)
13346 
      oprot.writeFieldEnd()
3431 rajveer 13347 
    if self.billingType is not None:
4283 anupam.sin 13348 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13349 
      oprot.writeI64(self.billingType)
13350 
      oprot.writeFieldEnd()
5110 mandeep.dh 13351 
    if self.fulfilmentWarehouseId is not None:
13352 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13353 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13354 
      oprot.writeFieldEnd()
4763 rajveer 13355 
    if self.authorize is not None:
13356 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13357 
      oprot.writeBool(self.authorize)
13358 
      oprot.writeFieldEnd()
1246 chandransh 13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
3431 rajveer 13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
1246 chandransh 13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
13376 
 
4283 anupam.sin 13377 
class addBillingDetails_result:
1246 chandransh 13378 
  """
13379 
  Attributes:
3064 chandransh 13380 
   - success
1246 chandransh 13381 
   - ex
13382 
  """
13383 
 
13384 
  thrift_spec = (
3064 chandransh 13385 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13387 
  )
13388 
 
3064 chandransh 13389 
  def __init__(self, success=None, ex=None,):
13390 
    self.success = success
1246 chandransh 13391 
    self.ex = ex
13392 
 
13393 
  def read(self, iprot):
13394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13396 
      return
13397 
    iprot.readStructBegin()
13398 
    while True:
13399 
      (fname, ftype, fid) = iprot.readFieldBegin()
13400 
      if ftype == TType.STOP:
13401 
        break
3064 chandransh 13402 
      if fid == 0:
13403 
        if ftype == TType.BOOL:
13404 
          self.success = iprot.readBool();
13405 
        else:
13406 
          iprot.skip(ftype)
13407 
      elif fid == 1:
1246 chandransh 13408 
        if ftype == TType.STRUCT:
13409 
          self.ex = TransactionServiceException()
13410 
          self.ex.read(iprot)
13411 
        else:
13412 
          iprot.skip(ftype)
13413 
      else:
13414 
        iprot.skip(ftype)
13415 
      iprot.readFieldEnd()
13416 
    iprot.readStructEnd()
13417 
 
13418 
  def write(self, oprot):
13419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13421 
      return
4283 anupam.sin 13422 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13423 
    if self.success is not None:
3064 chandransh 13424 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13425 
      oprot.writeBool(self.success)
13426 
      oprot.writeFieldEnd()
3431 rajveer 13427 
    if self.ex is not None:
1246 chandransh 13428 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13429 
      self.ex.write(oprot)
13430 
      oprot.writeFieldEnd()
13431 
    oprot.writeFieldStop()
13432 
    oprot.writeStructEnd()
13433 
 
3431 rajveer 13434 
  def validate(self):
13435 
    return
13436 
 
13437 
 
1246 chandransh 13438 
  def __repr__(self):
13439 
    L = ['%s=%r' % (key, value)
13440 
      for key, value in self.__dict__.iteritems()]
13441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13442 
 
13443 
  def __eq__(self, other):
13444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13445 
 
13446 
  def __ne__(self, other):
13447 
    return not (self == other)
13448 
 
4579 rajveer 13449 
class addInvoiceNumber_args:
13450 
  """
13451 
  Attributes:
13452 
   - orderId
13453 
   - invoiceNumber
4763 rajveer 13454 
   - color
4579 rajveer 13455 
  """
13456 
 
13457 
  thrift_spec = (
13458 
    None, # 0
13459 
    (1, TType.I64, 'orderId', None, None, ), # 1
13460 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13461 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13462 
  )
13463 
 
4763 rajveer 13464 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13465 
    self.orderId = orderId
13466 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13467 
    self.color = color
4579 rajveer 13468 
 
13469 
  def read(self, iprot):
13470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13472 
      return
13473 
    iprot.readStructBegin()
13474 
    while True:
13475 
      (fname, ftype, fid) = iprot.readFieldBegin()
13476 
      if ftype == TType.STOP:
13477 
        break
13478 
      if fid == 1:
13479 
        if ftype == TType.I64:
13480 
          self.orderId = iprot.readI64();
13481 
        else:
13482 
          iprot.skip(ftype)
13483 
      elif fid == 2:
13484 
        if ftype == TType.STRING:
13485 
          self.invoiceNumber = iprot.readString();
13486 
        else:
13487 
          iprot.skip(ftype)
4763 rajveer 13488 
      elif fid == 3:
13489 
        if ftype == TType.STRING:
13490 
          self.color = iprot.readString();
13491 
        else:
13492 
          iprot.skip(ftype)
4579 rajveer 13493 
      else:
13494 
        iprot.skip(ftype)
13495 
      iprot.readFieldEnd()
13496 
    iprot.readStructEnd()
13497 
 
13498 
  def write(self, oprot):
13499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13501 
      return
13502 
    oprot.writeStructBegin('addInvoiceNumber_args')
13503 
    if self.orderId is not None:
13504 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13505 
      oprot.writeI64(self.orderId)
13506 
      oprot.writeFieldEnd()
13507 
    if self.invoiceNumber is not None:
13508 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13509 
      oprot.writeString(self.invoiceNumber)
13510 
      oprot.writeFieldEnd()
4763 rajveer 13511 
    if self.color is not None:
13512 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13513 
      oprot.writeString(self.color)
13514 
      oprot.writeFieldEnd()
4579 rajveer 13515 
    oprot.writeFieldStop()
13516 
    oprot.writeStructEnd()
13517 
 
13518 
  def validate(self):
13519 
    return
13520 
 
13521 
 
13522 
  def __repr__(self):
13523 
    L = ['%s=%r' % (key, value)
13524 
      for key, value in self.__dict__.iteritems()]
13525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13526 
 
13527 
  def __eq__(self, other):
13528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13529 
 
13530 
  def __ne__(self, other):
13531 
    return not (self == other)
13532 
 
13533 
class addInvoiceNumber_result:
13534 
  """
13535 
  Attributes:
13536 
   - ex
13537 
  """
13538 
 
13539 
  thrift_spec = (
13540 
    None, # 0
13541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13542 
  )
13543 
 
13544 
  def __init__(self, ex=None,):
13545 
    self.ex = ex
13546 
 
13547 
  def read(self, iprot):
13548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13550 
      return
13551 
    iprot.readStructBegin()
13552 
    while True:
13553 
      (fname, ftype, fid) = iprot.readFieldBegin()
13554 
      if ftype == TType.STOP:
13555 
        break
13556 
      if fid == 1:
13557 
        if ftype == TType.STRUCT:
13558 
          self.ex = TransactionServiceException()
13559 
          self.ex.read(iprot)
13560 
        else:
13561 
          iprot.skip(ftype)
13562 
      else:
13563 
        iprot.skip(ftype)
13564 
      iprot.readFieldEnd()
13565 
    iprot.readStructEnd()
13566 
 
13567 
  def write(self, oprot):
13568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13570 
      return
13571 
    oprot.writeStructBegin('addInvoiceNumber_result')
13572 
    if self.ex is not None:
13573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13574 
      self.ex.write(oprot)
13575 
      oprot.writeFieldEnd()
13576 
    oprot.writeFieldStop()
13577 
    oprot.writeStructEnd()
13578 
 
13579 
  def validate(self):
13580 
    return
13581 
 
13582 
 
13583 
  def __repr__(self):
13584 
    L = ['%s=%r' % (key, value)
13585 
      for key, value in self.__dict__.iteritems()]
13586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13587 
 
13588 
  def __eq__(self, other):
13589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13590 
 
13591 
  def __ne__(self, other):
13592 
    return not (self == other)
13593 
 
4910 phani.kuma 13594 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13595 
  """
13596 
  Attributes:
3064 chandransh 13597 
   - warehouseId
1408 ankur.sing 13598 
   - providerId
3064 chandransh 13599 
   - cod
4910 phani.kuma 13600 
   - orderIds
1408 ankur.sing 13601 
  """
13602 
 
13603 
  thrift_spec = (
13604 
    None, # 0
3064 chandransh 13605 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13606 
    (2, TType.I64, 'providerId', None, None, ), # 2
13607 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13608 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13609 
  )
13610 
 
4910 phani.kuma 13611 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13612 
    self.warehouseId = warehouseId
1408 ankur.sing 13613 
    self.providerId = providerId
3064 chandransh 13614 
    self.cod = cod
4910 phani.kuma 13615 
    self.orderIds = orderIds
1408 ankur.sing 13616 
 
13617 
  def read(self, iprot):
13618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13620 
      return
13621 
    iprot.readStructBegin()
13622 
    while True:
13623 
      (fname, ftype, fid) = iprot.readFieldBegin()
13624 
      if ftype == TType.STOP:
13625 
        break
13626 
      if fid == 1:
13627 
        if ftype == TType.I64:
3064 chandransh 13628 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13629 
        else:
13630 
          iprot.skip(ftype)
13631 
      elif fid == 2:
13632 
        if ftype == TType.I64:
3064 chandransh 13633 
          self.providerId = iprot.readI64();
1408 ankur.sing 13634 
        else:
13635 
          iprot.skip(ftype)
3064 chandransh 13636 
      elif fid == 3:
13637 
        if ftype == TType.BOOL:
13638 
          self.cod = iprot.readBool();
13639 
        else:
13640 
          iprot.skip(ftype)
4910 phani.kuma 13641 
      elif fid == 4:
13642 
        if ftype == TType.LIST:
13643 
          self.orderIds = []
6031 rajveer 13644 
          (_etype241, _size238) = iprot.readListBegin()
13645 
          for _i242 in xrange(_size238):
13646 
            _elem243 = iprot.readI64();
13647 
            self.orderIds.append(_elem243)
4910 phani.kuma 13648 
          iprot.readListEnd()
13649 
        else:
13650 
          iprot.skip(ftype)
1408 ankur.sing 13651 
      else:
13652 
        iprot.skip(ftype)
13653 
      iprot.readFieldEnd()
13654 
    iprot.readStructEnd()
13655 
 
13656 
  def write(self, oprot):
13657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13659 
      return
4910 phani.kuma 13660 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13661 
    if self.warehouseId is not None:
3064 chandransh 13662 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13663 
      oprot.writeI64(self.warehouseId)
13664 
      oprot.writeFieldEnd()
3431 rajveer 13665 
    if self.providerId is not None:
3064 chandransh 13666 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13667 
      oprot.writeI64(self.providerId)
13668 
      oprot.writeFieldEnd()
3431 rajveer 13669 
    if self.cod is not None:
3064 chandransh 13670 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13671 
      oprot.writeBool(self.cod)
1408 ankur.sing 13672 
      oprot.writeFieldEnd()
4910 phani.kuma 13673 
    if self.orderIds is not None:
13674 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13675 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13676 
      for iter244 in self.orderIds:
13677 
        oprot.writeI64(iter244)
4910 phani.kuma 13678 
      oprot.writeListEnd()
13679 
      oprot.writeFieldEnd()
1408 ankur.sing 13680 
    oprot.writeFieldStop()
13681 
    oprot.writeStructEnd()
13682 
 
3431 rajveer 13683 
  def validate(self):
13684 
    return
13685 
 
13686 
 
1408 ankur.sing 13687 
  def __repr__(self):
13688 
    L = ['%s=%r' % (key, value)
13689 
      for key, value in self.__dict__.iteritems()]
13690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13691 
 
13692 
  def __eq__(self, other):
13693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13694 
 
13695 
  def __ne__(self, other):
13696 
    return not (self == other)
13697 
 
4910 phani.kuma 13698 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13699 
  """
13700 
  Attributes:
13701 
   - success
3064 chandransh 13702 
   - ex
1408 ankur.sing 13703 
  """
13704 
 
13705 
  thrift_spec = (
3064 chandransh 13706 
    (0, TType.BOOL, 'success', None, None, ), # 0
13707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13708 
  )
13709 
 
3064 chandransh 13710 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13711 
    self.success = success
3064 chandransh 13712 
    self.ex = ex
1408 ankur.sing 13713 
 
13714 
  def read(self, iprot):
13715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13717 
      return
13718 
    iprot.readStructBegin()
13719 
    while True:
13720 
      (fname, ftype, fid) = iprot.readFieldBegin()
13721 
      if ftype == TType.STOP:
13722 
        break
13723 
      if fid == 0:
3064 chandransh 13724 
        if ftype == TType.BOOL:
13725 
          self.success = iprot.readBool();
1408 ankur.sing 13726 
        else:
13727 
          iprot.skip(ftype)
3064 chandransh 13728 
      elif fid == 1:
13729 
        if ftype == TType.STRUCT:
13730 
          self.ex = TransactionServiceException()
13731 
          self.ex.read(iprot)
13732 
        else:
13733 
          iprot.skip(ftype)
1408 ankur.sing 13734 
      else:
13735 
        iprot.skip(ftype)
13736 
      iprot.readFieldEnd()
13737 
    iprot.readStructEnd()
13738 
 
13739 
  def write(self, oprot):
13740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13742 
      return
4910 phani.kuma 13743 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13744 
    if self.success is not None:
3064 chandransh 13745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13746 
      oprot.writeBool(self.success)
1408 ankur.sing 13747 
      oprot.writeFieldEnd()
3431 rajveer 13748 
    if self.ex is not None:
3064 chandransh 13749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13750 
      self.ex.write(oprot)
13751 
      oprot.writeFieldEnd()
1408 ankur.sing 13752 
    oprot.writeFieldStop()
13753 
    oprot.writeStructEnd()
13754 
 
3431 rajveer 13755 
  def validate(self):
13756 
    return
13757 
 
13758 
 
1408 ankur.sing 13759 
  def __repr__(self):
13760 
    L = ['%s=%r' % (key, value)
13761 
      for key, value in self.__dict__.iteritems()]
13762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13763 
 
13764 
  def __eq__(self, other):
13765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13766 
 
13767 
  def __ne__(self, other):
13768 
    return not (self == other)
13769 
 
5676 rajveer 13770 
class markOrdersAsReturnedFromStore_args:
13771 
  """
13772 
  Attributes:
13773 
   - providerId
13774 
   - orderIds
5713 rajveer 13775 
   - awbs
5676 rajveer 13776 
  """
13777 
 
13778 
  thrift_spec = (
13779 
    None, # 0
13780 
    (1, TType.I64, 'providerId', None, None, ), # 1
13781 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13782 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13783 
  )
13784 
 
5713 rajveer 13785 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13786 
    self.providerId = providerId
13787 
    self.orderIds = orderIds
5713 rajveer 13788 
    self.awbs = awbs
5676 rajveer 13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      if fid == 1:
13800 
        if ftype == TType.I64:
13801 
          self.providerId = iprot.readI64();
13802 
        else:
13803 
          iprot.skip(ftype)
13804 
      elif fid == 2:
13805 
        if ftype == TType.LIST:
13806 
          self.orderIds = []
6031 rajveer 13807 
          (_etype248, _size245) = iprot.readListBegin()
13808 
          for _i249 in xrange(_size245):
13809 
            _elem250 = iprot.readI64();
13810 
            self.orderIds.append(_elem250)
5676 rajveer 13811 
          iprot.readListEnd()
13812 
        else:
13813 
          iprot.skip(ftype)
5713 rajveer 13814 
      elif fid == 3:
13815 
        if ftype == TType.LIST:
13816 
          self.awbs = []
6031 rajveer 13817 
          (_etype254, _size251) = iprot.readListBegin()
13818 
          for _i255 in xrange(_size251):
13819 
            _elem256 = iprot.readString();
13820 
            self.awbs.append(_elem256)
5713 rajveer 13821 
          iprot.readListEnd()
13822 
        else:
13823 
          iprot.skip(ftype)
5676 rajveer 13824 
      else:
13825 
        iprot.skip(ftype)
13826 
      iprot.readFieldEnd()
13827 
    iprot.readStructEnd()
13828 
 
13829 
  def write(self, oprot):
13830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13832 
      return
13833 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13834 
    if self.providerId is not None:
13835 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13836 
      oprot.writeI64(self.providerId)
13837 
      oprot.writeFieldEnd()
13838 
    if self.orderIds is not None:
13839 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13840 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13841 
      for iter257 in self.orderIds:
13842 
        oprot.writeI64(iter257)
5676 rajveer 13843 
      oprot.writeListEnd()
13844 
      oprot.writeFieldEnd()
5713 rajveer 13845 
    if self.awbs is not None:
13846 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13847 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13848 
      for iter258 in self.awbs:
13849 
        oprot.writeString(iter258)
5713 rajveer 13850 
      oprot.writeListEnd()
13851 
      oprot.writeFieldEnd()
5676 rajveer 13852 
    oprot.writeFieldStop()
13853 
    oprot.writeStructEnd()
13854 
 
13855 
  def validate(self):
13856 
    return
13857 
 
13858 
 
13859 
  def __repr__(self):
13860 
    L = ['%s=%r' % (key, value)
13861 
      for key, value in self.__dict__.iteritems()]
13862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13863 
 
13864 
  def __eq__(self, other):
13865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13866 
 
13867 
  def __ne__(self, other):
13868 
    return not (self == other)
13869 
 
13870 
class markOrdersAsReturnedFromStore_result:
13871 
  """
13872 
  Attributes:
13873 
   - success
13874 
   - ex
13875 
  """
13876 
 
13877 
  thrift_spec = (
13878 
    (0, TType.BOOL, 'success', None, None, ), # 0
13879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13880 
  )
13881 
 
13882 
  def __init__(self, success=None, ex=None,):
13883 
    self.success = success
13884 
    self.ex = ex
13885 
 
13886 
  def read(self, iprot):
13887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13889 
      return
13890 
    iprot.readStructBegin()
13891 
    while True:
13892 
      (fname, ftype, fid) = iprot.readFieldBegin()
13893 
      if ftype == TType.STOP:
13894 
        break
13895 
      if fid == 0:
13896 
        if ftype == TType.BOOL:
13897 
          self.success = iprot.readBool();
13898 
        else:
13899 
          iprot.skip(ftype)
13900 
      elif fid == 1:
13901 
        if ftype == TType.STRUCT:
13902 
          self.ex = TransactionServiceException()
13903 
          self.ex.read(iprot)
13904 
        else:
13905 
          iprot.skip(ftype)
13906 
      else:
13907 
        iprot.skip(ftype)
13908 
      iprot.readFieldEnd()
13909 
    iprot.readStructEnd()
13910 
 
13911 
  def write(self, oprot):
13912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13914 
      return
13915 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13916 
    if self.success is not None:
13917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13918 
      oprot.writeBool(self.success)
13919 
      oprot.writeFieldEnd()
13920 
    if self.ex is not None:
13921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13922 
      self.ex.write(oprot)
13923 
      oprot.writeFieldEnd()
13924 
    oprot.writeFieldStop()
13925 
    oprot.writeStructEnd()
13926 
 
13927 
  def validate(self):
13928 
    return
13929 
 
13930 
 
13931 
  def __repr__(self):
13932 
    L = ['%s=%r' % (key, value)
13933 
      for key, value in self.__dict__.iteritems()]
13934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13935 
 
13936 
  def __eq__(self, other):
13937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13938 
 
13939 
  def __ne__(self, other):
13940 
    return not (self == other)
13941 
 
4910 phani.kuma 13942 
class markOrdersAsPickedUp_args:
4410 rajveer 13943 
  """
13944 
  Attributes:
13945 
   - providerId
4910 phani.kuma 13946 
   - pickupDetails
4410 rajveer 13947 
  """
13948 
 
13949 
  thrift_spec = (
13950 
    None, # 0
4910 phani.kuma 13951 
    (1, TType.I64, 'providerId', None, None, ), # 1
13952 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13953 
  )
13954 
 
4910 phani.kuma 13955 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13956 
    self.providerId = providerId
4910 phani.kuma 13957 
    self.pickupDetails = pickupDetails
4410 rajveer 13958 
 
13959 
  def read(self, iprot):
13960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13962 
      return
13963 
    iprot.readStructBegin()
13964 
    while True:
13965 
      (fname, ftype, fid) = iprot.readFieldBegin()
13966 
      if ftype == TType.STOP:
13967 
        break
13968 
      if fid == 1:
13969 
        if ftype == TType.I64:
4910 phani.kuma 13970 
          self.providerId = iprot.readI64();
4410 rajveer 13971 
        else:
13972 
          iprot.skip(ftype)
13973 
      elif fid == 2:
4910 phani.kuma 13974 
        if ftype == TType.MAP:
13975 
          self.pickupDetails = {}
6031 rajveer 13976 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13977 
          for _i263 in xrange(_size259):
13978 
            _key264 = iprot.readString();
13979 
            _val265 = iprot.readString();
13980 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13981 
          iprot.readMapEnd()
4410 rajveer 13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      else:
13985 
        iprot.skip(ftype)
13986 
      iprot.readFieldEnd()
13987 
    iprot.readStructEnd()
13988 
 
13989 
  def write(self, oprot):
13990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13992 
      return
4910 phani.kuma 13993 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13994 
    if self.providerId is not None:
4910 phani.kuma 13995 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13996 
      oprot.writeI64(self.providerId)
13997 
      oprot.writeFieldEnd()
4910 phani.kuma 13998 
    if self.pickupDetails is not None:
13999 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14000 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 14001 
      for kiter266,viter267 in self.pickupDetails.items():
14002 
        oprot.writeString(kiter266)
14003 
        oprot.writeString(viter267)
4910 phani.kuma 14004 
      oprot.writeMapEnd()
4410 rajveer 14005 
      oprot.writeFieldEnd()
14006 
    oprot.writeFieldStop()
14007 
    oprot.writeStructEnd()
14008 
 
14009 
  def validate(self):
14010 
    return
14011 
 
14012 
 
14013 
  def __repr__(self):
14014 
    L = ['%s=%r' % (key, value)
14015 
      for key, value in self.__dict__.iteritems()]
14016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14017 
 
14018 
  def __eq__(self, other):
14019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14020 
 
14021 
  def __ne__(self, other):
14022 
    return not (self == other)
14023 
 
4910 phani.kuma 14024 
class markOrdersAsPickedUp_result:
4410 rajveer 14025 
  """
14026 
  Attributes:
14027 
   - ex
14028 
  """
14029 
 
14030 
  thrift_spec = (
4910 phani.kuma 14031 
    None, # 0
4410 rajveer 14032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14033 
  )
14034 
 
4910 phani.kuma 14035 
  def __init__(self, ex=None,):
4410 rajveer 14036 
    self.ex = ex
14037 
 
14038 
  def read(self, iprot):
14039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14041 
      return
14042 
    iprot.readStructBegin()
14043 
    while True:
14044 
      (fname, ftype, fid) = iprot.readFieldBegin()
14045 
      if ftype == TType.STOP:
14046 
        break
4910 phani.kuma 14047 
      if fid == 1:
4410 rajveer 14048 
        if ftype == TType.STRUCT:
14049 
          self.ex = TransactionServiceException()
14050 
          self.ex.read(iprot)
14051 
        else:
14052 
          iprot.skip(ftype)
14053 
      else:
14054 
        iprot.skip(ftype)
14055 
      iprot.readFieldEnd()
14056 
    iprot.readStructEnd()
14057 
 
14058 
  def write(self, oprot):
14059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14061 
      return
4910 phani.kuma 14062 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14063 
    if self.ex is not None:
14064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14065 
      self.ex.write(oprot)
14066 
      oprot.writeFieldEnd()
14067 
    oprot.writeFieldStop()
14068 
    oprot.writeStructEnd()
14069 
 
14070 
  def validate(self):
14071 
    return
14072 
 
14073 
 
14074 
  def __repr__(self):
14075 
    L = ['%s=%r' % (key, value)
14076 
      for key, value in self.__dict__.iteritems()]
14077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14078 
 
14079 
  def __eq__(self, other):
14080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14081 
 
14082 
  def __ne__(self, other):
14083 
    return not (self == other)
14084 
 
4910 phani.kuma 14085 
class getOrdersNotPickedUp_args:
304 ashish 14086 
  """
14087 
  Attributes:
3064 chandransh 14088 
   - providerId
304 ashish 14089 
  """
94 ashish 14090 
 
304 ashish 14091 
  thrift_spec = (
14092 
    None, # 0
3064 chandransh 14093 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14094 
  )
14095 
 
4910 phani.kuma 14096 
  def __init__(self, providerId=None,):
3064 chandransh 14097 
    self.providerId = providerId
304 ashish 14098 
 
14099 
  def read(self, iprot):
14100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14102 
      return
14103 
    iprot.readStructBegin()
14104 
    while True:
14105 
      (fname, ftype, fid) = iprot.readFieldBegin()
14106 
      if ftype == TType.STOP:
14107 
        break
14108 
      if fid == 1:
14109 
        if ftype == TType.I64:
3064 chandransh 14110 
          self.providerId = iprot.readI64();
304 ashish 14111 
        else:
14112 
          iprot.skip(ftype)
14113 
      else:
14114 
        iprot.skip(ftype)
14115 
      iprot.readFieldEnd()
14116 
    iprot.readStructEnd()
14117 
 
14118 
  def write(self, oprot):
14119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14121 
      return
4910 phani.kuma 14122 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14123 
    if self.providerId is not None:
3064 chandransh 14124 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14125 
      oprot.writeI64(self.providerId)
304 ashish 14126 
      oprot.writeFieldEnd()
14127 
    oprot.writeFieldStop()
14128 
    oprot.writeStructEnd()
14129 
 
3431 rajveer 14130 
  def validate(self):
14131 
    return
14132 
 
14133 
 
304 ashish 14134 
  def __repr__(self):
14135 
    L = ['%s=%r' % (key, value)
14136 
      for key, value in self.__dict__.iteritems()]
14137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14138 
 
14139 
  def __eq__(self, other):
14140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14141 
 
14142 
  def __ne__(self, other):
14143 
    return not (self == other)
14144 
 
4910 phani.kuma 14145 
class getOrdersNotPickedUp_result:
304 ashish 14146 
  """
14147 
  Attributes:
14148 
   - success
14149 
  """
14150 
 
14151 
  thrift_spec = (
3064 chandransh 14152 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14153 
  )
14154 
 
4910 phani.kuma 14155 
  def __init__(self, success=None,):
304 ashish 14156 
    self.success = success
14157 
 
14158 
  def read(self, iprot):
14159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14161 
      return
14162 
    iprot.readStructBegin()
14163 
    while True:
14164 
      (fname, ftype, fid) = iprot.readFieldBegin()
14165 
      if ftype == TType.STOP:
14166 
        break
14167 
      if fid == 0:
14168 
        if ftype == TType.LIST:
14169 
          self.success = []
6031 rajveer 14170 
          (_etype271, _size268) = iprot.readListBegin()
14171 
          for _i272 in xrange(_size268):
14172 
            _elem273 = Order()
14173 
            _elem273.read(iprot)
14174 
            self.success.append(_elem273)
304 ashish 14175 
          iprot.readListEnd()
14176 
        else:
14177 
          iprot.skip(ftype)
14178 
      else:
14179 
        iprot.skip(ftype)
14180 
      iprot.readFieldEnd()
14181 
    iprot.readStructEnd()
14182 
 
14183 
  def write(self, oprot):
14184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14186 
      return
4910 phani.kuma 14187 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14188 
    if self.success is not None:
304 ashish 14189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14191 
      for iter274 in self.success:
14192 
        iter274.write(oprot)
304 ashish 14193 
      oprot.writeListEnd()
14194 
      oprot.writeFieldEnd()
14195 
    oprot.writeFieldStop()
14196 
    oprot.writeStructEnd()
14197 
 
3431 rajveer 14198 
  def validate(self):
14199 
    return
14200 
 
14201 
 
304 ashish 14202 
  def __repr__(self):
14203 
    L = ['%s=%r' % (key, value)
14204 
      for key, value in self.__dict__.iteritems()]
14205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14206 
 
14207 
  def __eq__(self, other):
14208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14209 
 
14210 
  def __ne__(self, other):
14211 
    return not (self == other)
14212 
 
3064 chandransh 14213 
class markOrdersAsDelivered_args:
304 ashish 14214 
  """
14215 
  Attributes:
3064 chandransh 14216 
   - providerId
14217 
   - deliveredOrders
304 ashish 14218 
  """
14219 
 
14220 
  thrift_spec = (
14221 
    None, # 0
3064 chandransh 14222 
    (1, TType.I64, 'providerId', None, None, ), # 1
14223 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14224 
  )
14225 
 
3064 chandransh 14226 
  def __init__(self, providerId=None, deliveredOrders=None,):
14227 
    self.providerId = providerId
14228 
    self.deliveredOrders = deliveredOrders
304 ashish 14229 
 
14230 
  def read(self, iprot):
14231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14233 
      return
14234 
    iprot.readStructBegin()
14235 
    while True:
14236 
      (fname, ftype, fid) = iprot.readFieldBegin()
14237 
      if ftype == TType.STOP:
14238 
        break
14239 
      if fid == 1:
14240 
        if ftype == TType.I64:
3064 chandransh 14241 
          self.providerId = iprot.readI64();
304 ashish 14242 
        else:
14243 
          iprot.skip(ftype)
14244 
      elif fid == 2:
3064 chandransh 14245 
        if ftype == TType.MAP:
14246 
          self.deliveredOrders = {}
6031 rajveer 14247 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
14248 
          for _i279 in xrange(_size275):
14249 
            _key280 = iprot.readString();
14250 
            _val281 = iprot.readString();
14251 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 14252 
          iprot.readMapEnd()
304 ashish 14253 
        else:
14254 
          iprot.skip(ftype)
14255 
      else:
14256 
        iprot.skip(ftype)
14257 
      iprot.readFieldEnd()
14258 
    iprot.readStructEnd()
14259 
 
14260 
  def write(self, oprot):
14261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14263 
      return
3064 chandransh 14264 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14265 
    if self.providerId is not None:
3064 chandransh 14266 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14267 
      oprot.writeI64(self.providerId)
304 ashish 14268 
      oprot.writeFieldEnd()
3431 rajveer 14269 
    if self.deliveredOrders is not None:
3064 chandransh 14270 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14271 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 14272 
      for kiter282,viter283 in self.deliveredOrders.items():
14273 
        oprot.writeString(kiter282)
14274 
        oprot.writeString(viter283)
3064 chandransh 14275 
      oprot.writeMapEnd()
304 ashish 14276 
      oprot.writeFieldEnd()
14277 
    oprot.writeFieldStop()
14278 
    oprot.writeStructEnd()
14279 
 
3431 rajveer 14280 
  def validate(self):
14281 
    return
14282 
 
14283 
 
304 ashish 14284 
  def __repr__(self):
14285 
    L = ['%s=%r' % (key, value)
14286 
      for key, value in self.__dict__.iteritems()]
14287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14288 
 
14289 
  def __eq__(self, other):
14290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14291 
 
14292 
  def __ne__(self, other):
14293 
    return not (self == other)
14294 
 
3064 chandransh 14295 
class markOrdersAsDelivered_result:
14296 
  """
14297 
  Attributes:
14298 
   - ex
14299 
  """
304 ashish 14300 
 
14301 
  thrift_spec = (
3064 chandransh 14302 
    None, # 0
14303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14304 
  )
14305 
 
3064 chandransh 14306 
  def __init__(self, ex=None,):
14307 
    self.ex = ex
304 ashish 14308 
 
1596 ankur.sing 14309 
  def read(self, iprot):
14310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14312 
      return
14313 
    iprot.readStructBegin()
14314 
    while True:
14315 
      (fname, ftype, fid) = iprot.readFieldBegin()
14316 
      if ftype == TType.STOP:
14317 
        break
3064 chandransh 14318 
      if fid == 1:
14319 
        if ftype == TType.STRUCT:
14320 
          self.ex = TransactionServiceException()
14321 
          self.ex.read(iprot)
14322 
        else:
14323 
          iprot.skip(ftype)
1596 ankur.sing 14324 
      else:
14325 
        iprot.skip(ftype)
14326 
      iprot.readFieldEnd()
14327 
    iprot.readStructEnd()
14328 
 
14329 
  def write(self, oprot):
14330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14332 
      return
3064 chandransh 14333 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14334 
    if self.ex is not None:
3064 chandransh 14335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14336 
      self.ex.write(oprot)
14337 
      oprot.writeFieldEnd()
1596 ankur.sing 14338 
    oprot.writeFieldStop()
14339 
    oprot.writeStructEnd()
14340 
 
3431 rajveer 14341 
  def validate(self):
14342 
    return
14343 
 
14344 
 
1596 ankur.sing 14345 
  def __repr__(self):
14346 
    L = ['%s=%r' % (key, value)
14347 
      for key, value in self.__dict__.iteritems()]
14348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14349 
 
14350 
  def __eq__(self, other):
14351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14352 
 
14353 
  def __ne__(self, other):
14354 
    return not (self == other)
14355 
 
4910 phani.kuma 14356 
class markAsRTOrders_args:
1596 ankur.sing 14357 
  """
14358 
  Attributes:
3064 chandransh 14359 
   - providerId
14360 
   - returnedOrders
1596 ankur.sing 14361 
  """
14362 
 
14363 
  thrift_spec = (
3064 chandransh 14364 
    None, # 0
14365 
    (1, TType.I64, 'providerId', None, None, ), # 1
14366 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14367 
  )
14368 
 
3064 chandransh 14369 
  def __init__(self, providerId=None, returnedOrders=None,):
14370 
    self.providerId = providerId
14371 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14372 
 
14373 
  def read(self, iprot):
14374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14376 
      return
14377 
    iprot.readStructBegin()
14378 
    while True:
14379 
      (fname, ftype, fid) = iprot.readFieldBegin()
14380 
      if ftype == TType.STOP:
14381 
        break
3064 chandransh 14382 
      if fid == 1:
1596 ankur.sing 14383 
        if ftype == TType.I64:
3064 chandransh 14384 
          self.providerId = iprot.readI64();
1596 ankur.sing 14385 
        else:
14386 
          iprot.skip(ftype)
3064 chandransh 14387 
      elif fid == 2:
14388 
        if ftype == TType.MAP:
14389 
          self.returnedOrders = {}
6031 rajveer 14390 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14391 
          for _i288 in xrange(_size284):
14392 
            _key289 = iprot.readString();
14393 
            _val290 = iprot.readString();
14394 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14395 
          iprot.readMapEnd()
14396 
        else:
14397 
          iprot.skip(ftype)
1596 ankur.sing 14398 
      else:
14399 
        iprot.skip(ftype)
14400 
      iprot.readFieldEnd()
14401 
    iprot.readStructEnd()
14402 
 
14403 
  def write(self, oprot):
14404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14406 
      return
4910 phani.kuma 14407 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14408 
    if self.providerId is not None:
3064 chandransh 14409 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14410 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14411 
      oprot.writeFieldEnd()
3431 rajveer 14412 
    if self.returnedOrders is not None:
3064 chandransh 14413 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14414 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14415 
      for kiter291,viter292 in self.returnedOrders.items():
14416 
        oprot.writeString(kiter291)
14417 
        oprot.writeString(viter292)
3064 chandransh 14418 
      oprot.writeMapEnd()
14419 
      oprot.writeFieldEnd()
1596 ankur.sing 14420 
    oprot.writeFieldStop()
14421 
    oprot.writeStructEnd()
14422 
 
3431 rajveer 14423 
  def validate(self):
14424 
    return
14425 
 
14426 
 
1596 ankur.sing 14427 
  def __repr__(self):
14428 
    L = ['%s=%r' % (key, value)
14429 
      for key, value in self.__dict__.iteritems()]
14430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14431 
 
14432 
  def __eq__(self, other):
14433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14434 
 
14435 
  def __ne__(self, other):
14436 
    return not (self == other)
14437 
 
4910 phani.kuma 14438 
class markAsRTOrders_result:
3064 chandransh 14439 
  """
14440 
  Attributes:
14441 
   - ex
14442 
  """
1596 ankur.sing 14443 
 
1627 ankur.sing 14444 
  thrift_spec = (
3064 chandransh 14445 
    None, # 0
14446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14447 
  )
14448 
 
3064 chandransh 14449 
  def __init__(self, ex=None,):
14450 
    self.ex = ex
14451 
 
1627 ankur.sing 14452 
  def read(self, iprot):
14453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14455 
      return
14456 
    iprot.readStructBegin()
14457 
    while True:
14458 
      (fname, ftype, fid) = iprot.readFieldBegin()
14459 
      if ftype == TType.STOP:
14460 
        break
3064 chandransh 14461 
      if fid == 1:
14462 
        if ftype == TType.STRUCT:
14463 
          self.ex = TransactionServiceException()
14464 
          self.ex.read(iprot)
14465 
        else:
14466 
          iprot.skip(ftype)
1627 ankur.sing 14467 
      else:
14468 
        iprot.skip(ftype)
14469 
      iprot.readFieldEnd()
14470 
    iprot.readStructEnd()
14471 
 
14472 
  def write(self, oprot):
14473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14475 
      return
4910 phani.kuma 14476 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14477 
    if self.ex is not None:
3064 chandransh 14478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14479 
      self.ex.write(oprot)
14480 
      oprot.writeFieldEnd()
1627 ankur.sing 14481 
    oprot.writeFieldStop()
14482 
    oprot.writeStructEnd()
14483 
 
3431 rajveer 14484 
  def validate(self):
14485 
    return
14486 
 
14487 
 
1627 ankur.sing 14488 
  def __repr__(self):
14489 
    L = ['%s=%r' % (key, value)
14490 
      for key, value in self.__dict__.iteritems()]
14491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14492 
 
14493 
  def __eq__(self, other):
14494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14495 
 
14496 
  def __ne__(self, other):
14497 
    return not (self == other)
14498 
 
4910 phani.kuma 14499 
class getRTOrders_args:
14500 
  """
14501 
  Attributes:
14502 
   - providerId
14503 
  """
14504 
 
14505 
  thrift_spec = (
14506 
    None, # 0
14507 
    (1, TType.I64, 'providerId', None, None, ), # 1
14508 
  )
14509 
 
14510 
  def __init__(self, providerId=None,):
14511 
    self.providerId = providerId
14512 
 
14513 
  def read(self, iprot):
14514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14516 
      return
14517 
    iprot.readStructBegin()
14518 
    while True:
14519 
      (fname, ftype, fid) = iprot.readFieldBegin()
14520 
      if ftype == TType.STOP:
14521 
        break
14522 
      if fid == 1:
14523 
        if ftype == TType.I64:
14524 
          self.providerId = iprot.readI64();
14525 
        else:
14526 
          iprot.skip(ftype)
14527 
      else:
14528 
        iprot.skip(ftype)
14529 
      iprot.readFieldEnd()
14530 
    iprot.readStructEnd()
14531 
 
14532 
  def write(self, oprot):
14533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14535 
      return
14536 
    oprot.writeStructBegin('getRTOrders_args')
14537 
    if self.providerId is not None:
14538 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14539 
      oprot.writeI64(self.providerId)
14540 
      oprot.writeFieldEnd()
14541 
    oprot.writeFieldStop()
14542 
    oprot.writeStructEnd()
14543 
 
14544 
  def validate(self):
14545 
    return
14546 
 
14547 
 
14548 
  def __repr__(self):
14549 
    L = ['%s=%r' % (key, value)
14550 
      for key, value in self.__dict__.iteritems()]
14551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14552 
 
14553 
  def __eq__(self, other):
14554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14555 
 
14556 
  def __ne__(self, other):
14557 
    return not (self == other)
14558 
 
14559 
class getRTOrders_result:
14560 
  """
14561 
  Attributes:
14562 
   - success
14563 
  """
14564 
 
14565 
  thrift_spec = (
14566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14567 
  )
14568 
 
14569 
  def __init__(self, success=None,):
14570 
    self.success = success
14571 
 
14572 
  def read(self, iprot):
14573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14575 
      return
14576 
    iprot.readStructBegin()
14577 
    while True:
14578 
      (fname, ftype, fid) = iprot.readFieldBegin()
14579 
      if ftype == TType.STOP:
14580 
        break
14581 
      if fid == 0:
14582 
        if ftype == TType.LIST:
14583 
          self.success = []
6031 rajveer 14584 
          (_etype296, _size293) = iprot.readListBegin()
14585 
          for _i297 in xrange(_size293):
14586 
            _elem298 = Order()
14587 
            _elem298.read(iprot)
14588 
            self.success.append(_elem298)
4910 phani.kuma 14589 
          iprot.readListEnd()
14590 
        else:
14591 
          iprot.skip(ftype)
14592 
      else:
14593 
        iprot.skip(ftype)
14594 
      iprot.readFieldEnd()
14595 
    iprot.readStructEnd()
14596 
 
14597 
  def write(self, oprot):
14598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14600 
      return
14601 
    oprot.writeStructBegin('getRTOrders_result')
14602 
    if self.success is not None:
14603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14605 
      for iter299 in self.success:
14606 
        iter299.write(oprot)
4910 phani.kuma 14607 
      oprot.writeListEnd()
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
14626 
 
3064 chandransh 14627 
class updateNonDeliveryReason_args:
1627 ankur.sing 14628 
  """
14629 
  Attributes:
3064 chandransh 14630 
   - providerId
14631 
   - undeliveredOrders
1627 ankur.sing 14632 
  """
14633 
 
14634 
  thrift_spec = (
3064 chandransh 14635 
    None, # 0
14636 
    (1, TType.I64, 'providerId', None, None, ), # 1
14637 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14638 
  )
14639 
 
3064 chandransh 14640 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14641 
    self.providerId = providerId
14642 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14643 
 
14644 
  def read(self, iprot):
14645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14647 
      return
14648 
    iprot.readStructBegin()
14649 
    while True:
14650 
      (fname, ftype, fid) = iprot.readFieldBegin()
14651 
      if ftype == TType.STOP:
14652 
        break
3064 chandransh 14653 
      if fid == 1:
1627 ankur.sing 14654 
        if ftype == TType.I64:
3064 chandransh 14655 
          self.providerId = iprot.readI64();
1627 ankur.sing 14656 
        else:
14657 
          iprot.skip(ftype)
3064 chandransh 14658 
      elif fid == 2:
14659 
        if ftype == TType.MAP:
14660 
          self.undeliveredOrders = {}
6031 rajveer 14661 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14662 
          for _i304 in xrange(_size300):
14663 
            _key305 = iprot.readString();
14664 
            _val306 = iprot.readString();
14665 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14666 
          iprot.readMapEnd()
14667 
        else:
14668 
          iprot.skip(ftype)
1627 ankur.sing 14669 
      else:
14670 
        iprot.skip(ftype)
14671 
      iprot.readFieldEnd()
14672 
    iprot.readStructEnd()
14673 
 
14674 
  def write(self, oprot):
14675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14677 
      return
3064 chandransh 14678 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14679 
    if self.providerId is not None:
3064 chandransh 14680 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14681 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14682 
      oprot.writeFieldEnd()
3431 rajveer 14683 
    if self.undeliveredOrders is not None:
3064 chandransh 14684 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14685 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14686 
      for kiter307,viter308 in self.undeliveredOrders.items():
14687 
        oprot.writeString(kiter307)
14688 
        oprot.writeString(viter308)
3064 chandransh 14689 
      oprot.writeMapEnd()
14690 
      oprot.writeFieldEnd()
1627 ankur.sing 14691 
    oprot.writeFieldStop()
14692 
    oprot.writeStructEnd()
14693 
 
3431 rajveer 14694 
  def validate(self):
14695 
    return
14696 
 
14697 
 
1627 ankur.sing 14698 
  def __repr__(self):
14699 
    L = ['%s=%r' % (key, value)
14700 
      for key, value in self.__dict__.iteritems()]
14701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14702 
 
14703 
  def __eq__(self, other):
14704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14705 
 
14706 
  def __ne__(self, other):
14707 
    return not (self == other)
14708 
 
3064 chandransh 14709 
class updateNonDeliveryReason_result:
1627 ankur.sing 14710 
  """
14711 
  Attributes:
3064 chandransh 14712 
   - ex
1627 ankur.sing 14713 
  """
14714 
 
14715 
  thrift_spec = (
4910 phani.kuma 14716 
    None, # 0
3064 chandransh 14717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14718 
  )
14719 
 
4910 phani.kuma 14720 
  def __init__(self, ex=None,):
3064 chandransh 14721 
    self.ex = ex
1627 ankur.sing 14722 
 
14723 
  def read(self, iprot):
14724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14726 
      return
14727 
    iprot.readStructBegin()
14728 
    while True:
14729 
      (fname, ftype, fid) = iprot.readFieldBegin()
14730 
      if ftype == TType.STOP:
14731 
        break
4910 phani.kuma 14732 
      if fid == 1:
14733 
        if ftype == TType.STRUCT:
14734 
          self.ex = TransactionServiceException()
14735 
          self.ex.read(iprot)
14736 
        else:
14737 
          iprot.skip(ftype)
14738 
      else:
14739 
        iprot.skip(ftype)
14740 
      iprot.readFieldEnd()
14741 
    iprot.readStructEnd()
14742 
 
14743 
  def write(self, oprot):
14744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14746 
      return
14747 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14748 
    if self.ex is not None:
14749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14750 
      self.ex.write(oprot)
14751 
      oprot.writeFieldEnd()
14752 
    oprot.writeFieldStop()
14753 
    oprot.writeStructEnd()
14754 
 
14755 
  def validate(self):
14756 
    return
14757 
 
14758 
 
14759 
  def __repr__(self):
14760 
    L = ['%s=%r' % (key, value)
14761 
      for key, value in self.__dict__.iteritems()]
14762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14763 
 
14764 
  def __eq__(self, other):
14765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14766 
 
14767 
  def __ne__(self, other):
14768 
    return not (self == other)
14769 
 
14770 
class getNonDeliveredOrdersbyCourier_args:
14771 
  """
14772 
  Attributes:
14773 
   - providerId
14774 
  """
14775 
 
14776 
  thrift_spec = (
14777 
    None, # 0
14778 
    (1, TType.I64, 'providerId', None, None, ), # 1
14779 
  )
14780 
 
14781 
  def __init__(self, providerId=None,):
14782 
    self.providerId = providerId
14783 
 
14784 
  def read(self, iprot):
14785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14787 
      return
14788 
    iprot.readStructBegin()
14789 
    while True:
14790 
      (fname, ftype, fid) = iprot.readFieldBegin()
14791 
      if ftype == TType.STOP:
14792 
        break
14793 
      if fid == 1:
14794 
        if ftype == TType.I64:
14795 
          self.providerId = iprot.readI64();
14796 
        else:
14797 
          iprot.skip(ftype)
14798 
      else:
14799 
        iprot.skip(ftype)
14800 
      iprot.readFieldEnd()
14801 
    iprot.readStructEnd()
14802 
 
14803 
  def write(self, oprot):
14804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14806 
      return
14807 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14808 
    if self.providerId is not None:
14809 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14810 
      oprot.writeI64(self.providerId)
14811 
      oprot.writeFieldEnd()
14812 
    oprot.writeFieldStop()
14813 
    oprot.writeStructEnd()
14814 
 
14815 
  def validate(self):
14816 
    return
14817 
 
14818 
 
14819 
  def __repr__(self):
14820 
    L = ['%s=%r' % (key, value)
14821 
      for key, value in self.__dict__.iteritems()]
14822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14823 
 
14824 
  def __eq__(self, other):
14825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14826 
 
14827 
  def __ne__(self, other):
14828 
    return not (self == other)
14829 
 
14830 
class getNonDeliveredOrdersbyCourier_result:
14831 
  """
14832 
  Attributes:
14833 
   - success
14834 
  """
14835 
 
14836 
  thrift_spec = (
14837 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14838 
  )
14839 
 
14840 
  def __init__(self, success=None,):
14841 
    self.success = success
14842 
 
14843 
  def read(self, iprot):
14844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14846 
      return
14847 
    iprot.readStructBegin()
14848 
    while True:
14849 
      (fname, ftype, fid) = iprot.readFieldBegin()
14850 
      if ftype == TType.STOP:
14851 
        break
4581 phani.kuma 14852 
      if fid == 0:
14853 
        if ftype == TType.LIST:
14854 
          self.success = []
6031 rajveer 14855 
          (_etype312, _size309) = iprot.readListBegin()
14856 
          for _i313 in xrange(_size309):
14857 
            _elem314 = Order()
14858 
            _elem314.read(iprot)
14859 
            self.success.append(_elem314)
4581 phani.kuma 14860 
          iprot.readListEnd()
14861 
        else:
14862 
          iprot.skip(ftype)
4910 phani.kuma 14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
14872 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14873 
    if self.success is not None:
14874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14876 
      for iter315 in self.success:
14877 
        iter315.write(oprot)
4910 phani.kuma 14878 
      oprot.writeListEnd()
14879 
      oprot.writeFieldEnd()
14880 
    oprot.writeFieldStop()
14881 
    oprot.writeStructEnd()
14882 
 
14883 
  def validate(self):
14884 
    return
14885 
 
14886 
 
14887 
  def __repr__(self):
14888 
    L = ['%s=%r' % (key, value)
14889 
      for key, value in self.__dict__.iteritems()]
14890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14891 
 
14892 
  def __eq__(self, other):
14893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14894 
 
14895 
  def __ne__(self, other):
14896 
    return not (self == other)
14897 
 
14898 
class markOrdersAsLocalConnected_args:
14899 
  """
14900 
  Attributes:
14901 
   - providerId
14902 
   - local_connected_orders
14903 
  """
14904 
 
14905 
  thrift_spec = (
14906 
    None, # 0
14907 
    (1, TType.I64, 'providerId', None, None, ), # 1
14908 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14909 
  )
14910 
 
14911 
  def __init__(self, providerId=None, local_connected_orders=None,):
14912 
    self.providerId = providerId
14913 
    self.local_connected_orders = local_connected_orders
14914 
 
14915 
  def read(self, iprot):
14916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14918 
      return
14919 
    iprot.readStructBegin()
14920 
    while True:
14921 
      (fname, ftype, fid) = iprot.readFieldBegin()
14922 
      if ftype == TType.STOP:
14923 
        break
14924 
      if fid == 1:
14925 
        if ftype == TType.I64:
14926 
          self.providerId = iprot.readI64();
14927 
        else:
14928 
          iprot.skip(ftype)
14929 
      elif fid == 2:
14930 
        if ftype == TType.MAP:
14931 
          self.local_connected_orders = {}
6031 rajveer 14932 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14933 
          for _i320 in xrange(_size316):
14934 
            _key321 = iprot.readString();
14935 
            _val322 = iprot.readString();
14936 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14937 
          iprot.readMapEnd()
14938 
        else:
14939 
          iprot.skip(ftype)
14940 
      else:
14941 
        iprot.skip(ftype)
14942 
      iprot.readFieldEnd()
14943 
    iprot.readStructEnd()
14944 
 
14945 
  def write(self, oprot):
14946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14948 
      return
14949 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14950 
    if self.providerId is not None:
14951 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14952 
      oprot.writeI64(self.providerId)
14953 
      oprot.writeFieldEnd()
14954 
    if self.local_connected_orders is not None:
14955 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14956 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14957 
      for kiter323,viter324 in self.local_connected_orders.items():
14958 
        oprot.writeString(kiter323)
14959 
        oprot.writeString(viter324)
4910 phani.kuma 14960 
      oprot.writeMapEnd()
14961 
      oprot.writeFieldEnd()
14962 
    oprot.writeFieldStop()
14963 
    oprot.writeStructEnd()
14964 
 
14965 
  def validate(self):
14966 
    return
14967 
 
14968 
 
14969 
  def __repr__(self):
14970 
    L = ['%s=%r' % (key, value)
14971 
      for key, value in self.__dict__.iteritems()]
14972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14973 
 
14974 
  def __eq__(self, other):
14975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14976 
 
14977 
  def __ne__(self, other):
14978 
    return not (self == other)
14979 
 
14980 
class markOrdersAsLocalConnected_result:
14981 
  """
14982 
  Attributes:
14983 
   - ex
14984 
  """
14985 
 
14986 
  thrift_spec = (
14987 
    None, # 0
14988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14989 
  )
14990 
 
14991 
  def __init__(self, ex=None,):
14992 
    self.ex = ex
14993 
 
14994 
  def read(self, iprot):
14995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14997 
      return
14998 
    iprot.readStructBegin()
14999 
    while True:
15000 
      (fname, ftype, fid) = iprot.readFieldBegin()
15001 
      if ftype == TType.STOP:
15002 
        break
15003 
      if fid == 1:
3064 chandransh 15004 
        if ftype == TType.STRUCT:
15005 
          self.ex = TransactionServiceException()
15006 
          self.ex.read(iprot)
1627 ankur.sing 15007 
        else:
15008 
          iprot.skip(ftype)
15009 
      else:
15010 
        iprot.skip(ftype)
15011 
      iprot.readFieldEnd()
15012 
    iprot.readStructEnd()
15013 
 
15014 
  def write(self, oprot):
15015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15017 
      return
4910 phani.kuma 15018 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15019 
    if self.ex is not None:
15020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15021 
      self.ex.write(oprot)
15022 
      oprot.writeFieldEnd()
15023 
    oprot.writeFieldStop()
15024 
    oprot.writeStructEnd()
15025 
 
15026 
  def validate(self):
15027 
    return
15028 
 
15029 
 
15030 
  def __repr__(self):
15031 
    L = ['%s=%r' % (key, value)
15032 
      for key, value in self.__dict__.iteritems()]
15033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15034 
 
15035 
  def __eq__(self, other):
15036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15037 
 
15038 
  def __ne__(self, other):
15039 
    return not (self == other)
15040 
 
15041 
class getOrdersNotLocalConnected_args:
15042 
  """
15043 
  Attributes:
15044 
   - providerId
15045 
  """
15046 
 
15047 
  thrift_spec = (
15048 
    None, # 0
15049 
    (1, TType.I64, 'providerId', None, None, ), # 1
15050 
  )
15051 
 
15052 
  def __init__(self, providerId=None,):
15053 
    self.providerId = providerId
15054 
 
15055 
  def read(self, iprot):
15056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15058 
      return
15059 
    iprot.readStructBegin()
15060 
    while True:
15061 
      (fname, ftype, fid) = iprot.readFieldBegin()
15062 
      if ftype == TType.STOP:
15063 
        break
15064 
      if fid == 1:
15065 
        if ftype == TType.I64:
15066 
          self.providerId = iprot.readI64();
15067 
        else:
15068 
          iprot.skip(ftype)
15069 
      else:
15070 
        iprot.skip(ftype)
15071 
      iprot.readFieldEnd()
15072 
    iprot.readStructEnd()
15073 
 
15074 
  def write(self, oprot):
15075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15077 
      return
15078 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15079 
    if self.providerId is not None:
15080 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15081 
      oprot.writeI64(self.providerId)
15082 
      oprot.writeFieldEnd()
15083 
    oprot.writeFieldStop()
15084 
    oprot.writeStructEnd()
15085 
 
15086 
  def validate(self):
15087 
    return
15088 
 
15089 
 
15090 
  def __repr__(self):
15091 
    L = ['%s=%r' % (key, value)
15092 
      for key, value in self.__dict__.iteritems()]
15093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15094 
 
15095 
  def __eq__(self, other):
15096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15097 
 
15098 
  def __ne__(self, other):
15099 
    return not (self == other)
15100 
 
15101 
class getOrdersNotLocalConnected_result:
15102 
  """
15103 
  Attributes:
15104 
   - success
15105 
  """
15106 
 
15107 
  thrift_spec = (
15108 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15109 
  )
15110 
 
15111 
  def __init__(self, success=None,):
15112 
    self.success = success
15113 
 
15114 
  def read(self, iprot):
15115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15117 
      return
15118 
    iprot.readStructBegin()
15119 
    while True:
15120 
      (fname, ftype, fid) = iprot.readFieldBegin()
15121 
      if ftype == TType.STOP:
15122 
        break
15123 
      if fid == 0:
15124 
        if ftype == TType.LIST:
15125 
          self.success = []
6031 rajveer 15126 
          (_etype328, _size325) = iprot.readListBegin()
15127 
          for _i329 in xrange(_size325):
15128 
            _elem330 = Order()
15129 
            _elem330.read(iprot)
15130 
            self.success.append(_elem330)
4910 phani.kuma 15131 
          iprot.readListEnd()
15132 
        else:
15133 
          iprot.skip(ftype)
15134 
      else:
15135 
        iprot.skip(ftype)
15136 
      iprot.readFieldEnd()
15137 
    iprot.readStructEnd()
15138 
 
15139 
  def write(self, oprot):
15140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15142 
      return
15143 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15144 
    if self.success is not None:
15145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15146 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15147 
      for iter331 in self.success:
15148 
        iter331.write(oprot)
4581 phani.kuma 15149 
      oprot.writeListEnd()
15150 
      oprot.writeFieldEnd()
4910 phani.kuma 15151 
    oprot.writeFieldStop()
15152 
    oprot.writeStructEnd()
15153 
 
15154 
  def validate(self):
15155 
    return
15156 
 
15157 
 
15158 
  def __repr__(self):
15159 
    L = ['%s=%r' % (key, value)
15160 
      for key, value in self.__dict__.iteritems()]
15161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15162 
 
15163 
  def __eq__(self, other):
15164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15165 
 
15166 
  def __ne__(self, other):
15167 
    return not (self == other)
15168 
 
15169 
class markOrdersAsDestinationCityReached_args:
15170 
  """
15171 
  Attributes:
15172 
   - providerId
15173 
   - destination_city_reached_orders
15174 
  """
15175 
 
15176 
  thrift_spec = (
15177 
    None, # 0
15178 
    (1, TType.I64, 'providerId', None, None, ), # 1
15179 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15180 
  )
15181 
 
15182 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15183 
    self.providerId = providerId
15184 
    self.destination_city_reached_orders = destination_city_reached_orders
15185 
 
15186 
  def read(self, iprot):
15187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15189 
      return
15190 
    iprot.readStructBegin()
15191 
    while True:
15192 
      (fname, ftype, fid) = iprot.readFieldBegin()
15193 
      if ftype == TType.STOP:
15194 
        break
15195 
      if fid == 1:
15196 
        if ftype == TType.I64:
15197 
          self.providerId = iprot.readI64();
15198 
        else:
15199 
          iprot.skip(ftype)
15200 
      elif fid == 2:
15201 
        if ftype == TType.MAP:
15202 
          self.destination_city_reached_orders = {}
6031 rajveer 15203 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
15204 
          for _i336 in xrange(_size332):
15205 
            _key337 = iprot.readString();
15206 
            _val338 = iprot.readString();
15207 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 15208 
          iprot.readMapEnd()
15209 
        else:
15210 
          iprot.skip(ftype)
15211 
      else:
15212 
        iprot.skip(ftype)
15213 
      iprot.readFieldEnd()
15214 
    iprot.readStructEnd()
15215 
 
15216 
  def write(self, oprot):
15217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15219 
      return
15220 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15221 
    if self.providerId is not None:
15222 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15223 
      oprot.writeI64(self.providerId)
15224 
      oprot.writeFieldEnd()
15225 
    if self.destination_city_reached_orders is not None:
15226 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15227 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 15228 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
15229 
        oprot.writeString(kiter339)
15230 
        oprot.writeString(viter340)
4910 phani.kuma 15231 
      oprot.writeMapEnd()
15232 
      oprot.writeFieldEnd()
15233 
    oprot.writeFieldStop()
15234 
    oprot.writeStructEnd()
15235 
 
15236 
  def validate(self):
15237 
    return
15238 
 
15239 
 
15240 
  def __repr__(self):
15241 
    L = ['%s=%r' % (key, value)
15242 
      for key, value in self.__dict__.iteritems()]
15243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15244 
 
15245 
  def __eq__(self, other):
15246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15247 
 
15248 
  def __ne__(self, other):
15249 
    return not (self == other)
15250 
 
15251 
class markOrdersAsDestinationCityReached_result:
15252 
  """
15253 
  Attributes:
15254 
   - ex
15255 
  """
15256 
 
15257 
  thrift_spec = (
15258 
    None, # 0
15259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15260 
  )
15261 
 
15262 
  def __init__(self, ex=None,):
15263 
    self.ex = ex
15264 
 
15265 
  def read(self, iprot):
15266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15268 
      return
15269 
    iprot.readStructBegin()
15270 
    while True:
15271 
      (fname, ftype, fid) = iprot.readFieldBegin()
15272 
      if ftype == TType.STOP:
15273 
        break
15274 
      if fid == 1:
15275 
        if ftype == TType.STRUCT:
15276 
          self.ex = TransactionServiceException()
15277 
          self.ex.read(iprot)
15278 
        else:
15279 
          iprot.skip(ftype)
15280 
      else:
15281 
        iprot.skip(ftype)
15282 
      iprot.readFieldEnd()
15283 
    iprot.readStructEnd()
15284 
 
15285 
  def write(self, oprot):
15286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15288 
      return
15289 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15290 
    if self.ex is not None:
3064 chandransh 15291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15292 
      self.ex.write(oprot)
1627 ankur.sing 15293 
      oprot.writeFieldEnd()
15294 
    oprot.writeFieldStop()
15295 
    oprot.writeStructEnd()
15296 
 
3431 rajveer 15297 
  def validate(self):
15298 
    return
15299 
 
15300 
 
1627 ankur.sing 15301 
  def __repr__(self):
15302 
    L = ['%s=%r' % (key, value)
15303 
      for key, value in self.__dict__.iteritems()]
15304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15305 
 
15306 
  def __eq__(self, other):
15307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15308 
 
15309 
  def __ne__(self, other):
15310 
    return not (self == other)
15311 
 
4910 phani.kuma 15312 
class markOrdersAsFirstDeliveryAttempted_args:
15313 
  """
15314 
  Attributes:
15315 
   - providerId
15316 
   - first_atdl_orders
15317 
  """
15318 
 
15319 
  thrift_spec = (
15320 
    None, # 0
15321 
    (1, TType.I64, 'providerId', None, None, ), # 1
15322 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15323 
  )
15324 
 
15325 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15326 
    self.providerId = providerId
15327 
    self.first_atdl_orders = first_atdl_orders
15328 
 
15329 
  def read(self, iprot):
15330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15332 
      return
15333 
    iprot.readStructBegin()
15334 
    while True:
15335 
      (fname, ftype, fid) = iprot.readFieldBegin()
15336 
      if ftype == TType.STOP:
15337 
        break
15338 
      if fid == 1:
15339 
        if ftype == TType.I64:
15340 
          self.providerId = iprot.readI64();
15341 
        else:
15342 
          iprot.skip(ftype)
15343 
      elif fid == 2:
15344 
        if ftype == TType.MAP:
15345 
          self.first_atdl_orders = {}
6031 rajveer 15346 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
15347 
          for _i345 in xrange(_size341):
15348 
            _key346 = iprot.readString();
15349 
            _val347 = iprot.readString();
15350 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 15351 
          iprot.readMapEnd()
15352 
        else:
15353 
          iprot.skip(ftype)
15354 
      else:
15355 
        iprot.skip(ftype)
15356 
      iprot.readFieldEnd()
15357 
    iprot.readStructEnd()
15358 
 
15359 
  def write(self, oprot):
15360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15362 
      return
15363 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15364 
    if self.providerId is not None:
15365 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15366 
      oprot.writeI64(self.providerId)
15367 
      oprot.writeFieldEnd()
15368 
    if self.first_atdl_orders is not None:
15369 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15370 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15371 
      for kiter348,viter349 in self.first_atdl_orders.items():
15372 
        oprot.writeString(kiter348)
15373 
        oprot.writeString(viter349)
4910 phani.kuma 15374 
      oprot.writeMapEnd()
15375 
      oprot.writeFieldEnd()
15376 
    oprot.writeFieldStop()
15377 
    oprot.writeStructEnd()
15378 
 
15379 
  def validate(self):
15380 
    return
15381 
 
15382 
 
15383 
  def __repr__(self):
15384 
    L = ['%s=%r' % (key, value)
15385 
      for key, value in self.__dict__.iteritems()]
15386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15387 
 
15388 
  def __eq__(self, other):
15389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15390 
 
15391 
  def __ne__(self, other):
15392 
    return not (self == other)
15393 
 
15394 
class markOrdersAsFirstDeliveryAttempted_result:
15395 
  """
15396 
  Attributes:
15397 
   - ex
15398 
  """
15399 
 
15400 
  thrift_spec = (
15401 
    None, # 0
15402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15403 
  )
15404 
 
15405 
  def __init__(self, ex=None,):
15406 
    self.ex = ex
15407 
 
15408 
  def read(self, iprot):
15409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15411 
      return
15412 
    iprot.readStructBegin()
15413 
    while True:
15414 
      (fname, ftype, fid) = iprot.readFieldBegin()
15415 
      if ftype == TType.STOP:
15416 
        break
15417 
      if fid == 1:
15418 
        if ftype == TType.STRUCT:
15419 
          self.ex = TransactionServiceException()
15420 
          self.ex.read(iprot)
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      else:
15424 
        iprot.skip(ftype)
15425 
      iprot.readFieldEnd()
15426 
    iprot.readStructEnd()
15427 
 
15428 
  def write(self, oprot):
15429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15431 
      return
15432 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15433 
    if self.ex is not None:
15434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15435 
      self.ex.write(oprot)
15436 
      oprot.writeFieldEnd()
15437 
    oprot.writeFieldStop()
15438 
    oprot.writeStructEnd()
15439 
 
15440 
  def validate(self):
15441 
    return
15442 
 
15443 
 
15444 
  def __repr__(self):
15445 
    L = ['%s=%r' % (key, value)
15446 
      for key, value in self.__dict__.iteritems()]
15447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15448 
 
15449 
  def __eq__(self, other):
15450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15451 
 
15452 
  def __ne__(self, other):
15453 
    return not (self == other)
15454 
 
3064 chandransh 15455 
class getUndeliveredOrders_args:
1886 ankur.sing 15456 
  """
15457 
  Attributes:
3064 chandransh 15458 
   - providerId
15459 
   - warehouseId
1886 ankur.sing 15460 
  """
1627 ankur.sing 15461 
 
1886 ankur.sing 15462 
  thrift_spec = (
15463 
    None, # 0
3064 chandransh 15464 
    (1, TType.I64, 'providerId', None, None, ), # 1
15465 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15466 
  )
15467 
 
3064 chandransh 15468 
  def __init__(self, providerId=None, warehouseId=None,):
15469 
    self.providerId = providerId
15470 
    self.warehouseId = warehouseId
1886 ankur.sing 15471 
 
15472 
  def read(self, iprot):
15473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15475 
      return
15476 
    iprot.readStructBegin()
15477 
    while True:
15478 
      (fname, ftype, fid) = iprot.readFieldBegin()
15479 
      if ftype == TType.STOP:
15480 
        break
15481 
      if fid == 1:
15482 
        if ftype == TType.I64:
3064 chandransh 15483 
          self.providerId = iprot.readI64();
1886 ankur.sing 15484 
        else:
15485 
          iprot.skip(ftype)
3064 chandransh 15486 
      elif fid == 2:
15487 
        if ftype == TType.I64:
15488 
          self.warehouseId = iprot.readI64();
15489 
        else:
15490 
          iprot.skip(ftype)
1886 ankur.sing 15491 
      else:
15492 
        iprot.skip(ftype)
15493 
      iprot.readFieldEnd()
15494 
    iprot.readStructEnd()
15495 
 
15496 
  def write(self, oprot):
15497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15499 
      return
3064 chandransh 15500 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15501 
    if self.providerId is not None:
3064 chandransh 15502 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15503 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15504 
      oprot.writeFieldEnd()
3431 rajveer 15505 
    if self.warehouseId is not None:
3064 chandransh 15506 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15507 
      oprot.writeI64(self.warehouseId)
15508 
      oprot.writeFieldEnd()
1886 ankur.sing 15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
3431 rajveer 15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
1886 ankur.sing 15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
15526 
 
3064 chandransh 15527 
class getUndeliveredOrders_result:
1886 ankur.sing 15528 
  """
15529 
  Attributes:
15530 
   - success
15531 
  """
15532 
 
15533 
  thrift_spec = (
15534 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15535 
  )
15536 
 
15537 
  def __init__(self, success=None,):
15538 
    self.success = success
15539 
 
15540 
  def read(self, iprot):
15541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15543 
      return
15544 
    iprot.readStructBegin()
15545 
    while True:
15546 
      (fname, ftype, fid) = iprot.readFieldBegin()
15547 
      if ftype == TType.STOP:
15548 
        break
15549 
      if fid == 0:
15550 
        if ftype == TType.LIST:
15551 
          self.success = []
6031 rajveer 15552 
          (_etype353, _size350) = iprot.readListBegin()
15553 
          for _i354 in xrange(_size350):
15554 
            _elem355 = Order()
15555 
            _elem355.read(iprot)
15556 
            self.success.append(_elem355)
1886 ankur.sing 15557 
          iprot.readListEnd()
15558 
        else:
15559 
          iprot.skip(ftype)
15560 
      else:
15561 
        iprot.skip(ftype)
15562 
      iprot.readFieldEnd()
15563 
    iprot.readStructEnd()
15564 
 
15565 
  def write(self, oprot):
15566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15568 
      return
3064 chandransh 15569 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15570 
    if self.success is not None:
1886 ankur.sing 15571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15573 
      for iter356 in self.success:
15574 
        iter356.write(oprot)
1886 ankur.sing 15575 
      oprot.writeListEnd()
15576 
      oprot.writeFieldEnd()
15577 
    oprot.writeFieldStop()
15578 
    oprot.writeStructEnd()
15579 
 
3431 rajveer 15580 
  def validate(self):
15581 
    return
15582 
 
15583 
 
1886 ankur.sing 15584 
  def __repr__(self):
15585 
    L = ['%s=%r' % (key, value)
15586 
      for key, value in self.__dict__.iteritems()]
15587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15588 
 
15589 
  def __eq__(self, other):
15590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15591 
 
15592 
  def __ne__(self, other):
15593 
    return not (self == other)
15594 
 
4783 phani.kuma 15595 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15596 
 
15597 
  thrift_spec = (
15598 
  )
15599 
 
15600 
  def read(self, iprot):
15601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15603 
      return
15604 
    iprot.readStructBegin()
15605 
    while True:
15606 
      (fname, ftype, fid) = iprot.readFieldBegin()
15607 
      if ftype == TType.STOP:
15608 
        break
15609 
      else:
15610 
        iprot.skip(ftype)
15611 
      iprot.readFieldEnd()
15612 
    iprot.readStructEnd()
15613 
 
15614 
  def write(self, oprot):
15615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15617 
      return
15618 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15619 
    oprot.writeFieldStop()
15620 
    oprot.writeStructEnd()
15621 
 
15622 
  def validate(self):
15623 
    return
15624 
 
15625 
 
15626 
  def __repr__(self):
15627 
    L = ['%s=%r' % (key, value)
15628 
      for key, value in self.__dict__.iteritems()]
15629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15630 
 
15631 
  def __eq__(self, other):
15632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15633 
 
15634 
  def __ne__(self, other):
15635 
    return not (self == other)
15636 
 
15637 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15638 
  """
15639 
  Attributes:
15640 
   - success
15641 
  """
15642 
 
15643 
  thrift_spec = (
15644 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15645 
  )
15646 
 
15647 
  def __init__(self, success=None,):
15648 
    self.success = success
15649 
 
15650 
  def read(self, iprot):
15651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15653 
      return
15654 
    iprot.readStructBegin()
15655 
    while True:
15656 
      (fname, ftype, fid) = iprot.readFieldBegin()
15657 
      if ftype == TType.STOP:
15658 
        break
15659 
      if fid == 0:
15660 
        if ftype == TType.LIST:
15661 
          self.success = []
6031 rajveer 15662 
          (_etype360, _size357) = iprot.readListBegin()
15663 
          for _i361 in xrange(_size357):
15664 
            _elem362 = Order()
15665 
            _elem362.read(iprot)
15666 
            self.success.append(_elem362)
4783 phani.kuma 15667 
          iprot.readListEnd()
15668 
        else:
15669 
          iprot.skip(ftype)
15670 
      else:
15671 
        iprot.skip(ftype)
15672 
      iprot.readFieldEnd()
15673 
    iprot.readStructEnd()
15674 
 
15675 
  def write(self, oprot):
15676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15678 
      return
15679 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15680 
    if self.success is not None:
15681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15682 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15683 
      for iter363 in self.success:
15684 
        iter363.write(oprot)
4783 phani.kuma 15685 
      oprot.writeListEnd()
15686 
      oprot.writeFieldEnd()
15687 
    oprot.writeFieldStop()
15688 
    oprot.writeStructEnd()
15689 
 
15690 
  def validate(self):
15691 
    return
15692 
 
15693 
 
15694 
  def __repr__(self):
15695 
    L = ['%s=%r' % (key, value)
15696 
      for key, value in self.__dict__.iteritems()]
15697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15698 
 
15699 
  def __eq__(self, other):
15700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15701 
 
15702 
  def __ne__(self, other):
15703 
    return not (self == other)
15704 
 
2536 chandransh 15705 
class toggleDOAFlag_args:
15706 
  """
15707 
  Attributes:
15708 
   - orderId
15709 
  """
1886 ankur.sing 15710 
 
2536 chandransh 15711 
  thrift_spec = (
15712 
    None, # 0
15713 
    (1, TType.I64, 'orderId', None, None, ), # 1
15714 
  )
15715 
 
15716 
  def __init__(self, orderId=None,):
15717 
    self.orderId = orderId
15718 
 
15719 
  def read(self, iprot):
15720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15722 
      return
15723 
    iprot.readStructBegin()
15724 
    while True:
15725 
      (fname, ftype, fid) = iprot.readFieldBegin()
15726 
      if ftype == TType.STOP:
15727 
        break
15728 
      if fid == 1:
15729 
        if ftype == TType.I64:
15730 
          self.orderId = iprot.readI64();
15731 
        else:
15732 
          iprot.skip(ftype)
15733 
      else:
15734 
        iprot.skip(ftype)
15735 
      iprot.readFieldEnd()
15736 
    iprot.readStructEnd()
15737 
 
15738 
  def write(self, oprot):
15739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15741 
      return
15742 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15743 
    if self.orderId is not None:
2536 chandransh 15744 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15745 
      oprot.writeI64(self.orderId)
15746 
      oprot.writeFieldEnd()
15747 
    oprot.writeFieldStop()
15748 
    oprot.writeStructEnd()
15749 
 
3431 rajveer 15750 
  def validate(self):
15751 
    return
15752 
 
15753 
 
2536 chandransh 15754 
  def __repr__(self):
15755 
    L = ['%s=%r' % (key, value)
15756 
      for key, value in self.__dict__.iteritems()]
15757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15758 
 
15759 
  def __eq__(self, other):
15760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15761 
 
15762 
  def __ne__(self, other):
15763 
    return not (self == other)
15764 
 
15765 
class toggleDOAFlag_result:
15766 
  """
15767 
  Attributes:
15768 
   - success
15769 
   - ex
15770 
  """
15771 
 
15772 
  thrift_spec = (
15773 
    (0, TType.BOOL, 'success', None, None, ), # 0
15774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15775 
  )
15776 
 
15777 
  def __init__(self, success=None, ex=None,):
15778 
    self.success = success
15779 
    self.ex = ex
15780 
 
15781 
  def read(self, iprot):
15782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15784 
      return
15785 
    iprot.readStructBegin()
15786 
    while True:
15787 
      (fname, ftype, fid) = iprot.readFieldBegin()
15788 
      if ftype == TType.STOP:
15789 
        break
15790 
      if fid == 0:
15791 
        if ftype == TType.BOOL:
15792 
          self.success = iprot.readBool();
15793 
        else:
15794 
          iprot.skip(ftype)
15795 
      elif fid == 1:
15796 
        if ftype == TType.STRUCT:
15797 
          self.ex = TransactionServiceException()
15798 
          self.ex.read(iprot)
15799 
        else:
15800 
          iprot.skip(ftype)
15801 
      else:
15802 
        iprot.skip(ftype)
15803 
      iprot.readFieldEnd()
15804 
    iprot.readStructEnd()
15805 
 
15806 
  def write(self, oprot):
15807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15809 
      return
15810 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15811 
    if self.success is not None:
2536 chandransh 15812 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15813 
      oprot.writeBool(self.success)
15814 
      oprot.writeFieldEnd()
3431 rajveer 15815 
    if self.ex is not None:
2536 chandransh 15816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15817 
      self.ex.write(oprot)
15818 
      oprot.writeFieldEnd()
15819 
    oprot.writeFieldStop()
15820 
    oprot.writeStructEnd()
15821 
 
3431 rajveer 15822 
  def validate(self):
15823 
    return
15824 
 
15825 
 
2536 chandransh 15826 
  def __repr__(self):
15827 
    L = ['%s=%r' % (key, value)
15828 
      for key, value in self.__dict__.iteritems()]
15829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15830 
 
15831 
  def __eq__(self, other):
15832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15833 
 
15834 
  def __ne__(self, other):
15835 
    return not (self == other)
15836 
 
4712 rajveer 15837 
class markOrderAsDelivered_args:
15838 
  """
15839 
  Attributes:
15840 
   - orderId
15841 
   - deliveryTimestamp
15842 
   - receiver
15843 
  """
15844 
 
15845 
  thrift_spec = None
15846 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15847 
    self.orderId = orderId
15848 
    self.deliveryTimestamp = deliveryTimestamp
15849 
    self.receiver = receiver
15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 1:
15861 
        if ftype == TType.I64:
15862 
          self.orderId = iprot.readI64();
15863 
        else:
15864 
          iprot.skip(ftype)
15865 
      elif fid == 2:
15866 
        if ftype == TType.I64:
15867 
          self.deliveryTimestamp = iprot.readI64();
15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      elif fid == -1:
15871 
        if ftype == TType.STRING:
15872 
          self.receiver = iprot.readString();
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15885 
    if self.receiver is not None:
15886 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15887 
      oprot.writeString(self.receiver)
15888 
      oprot.writeFieldEnd()
15889 
    if self.orderId is not None:
15890 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15891 
      oprot.writeI64(self.orderId)
15892 
      oprot.writeFieldEnd()
15893 
    if self.deliveryTimestamp is not None:
15894 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15895 
      oprot.writeI64(self.deliveryTimestamp)
15896 
      oprot.writeFieldEnd()
15897 
    oprot.writeFieldStop()
15898 
    oprot.writeStructEnd()
15899 
 
15900 
  def validate(self):
15901 
    return
15902 
 
15903 
 
15904 
  def __repr__(self):
15905 
    L = ['%s=%r' % (key, value)
15906 
      for key, value in self.__dict__.iteritems()]
15907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15908 
 
15909 
  def __eq__(self, other):
15910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15911 
 
15912 
  def __ne__(self, other):
15913 
    return not (self == other)
15914 
 
15915 
class markOrderAsDelivered_result:
15916 
  """
15917 
  Attributes:
15918 
   - ex
15919 
  """
15920 
 
15921 
  thrift_spec = (
15922 
    None, # 0
15923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15924 
  )
15925 
 
15926 
  def __init__(self, ex=None,):
15927 
    self.ex = ex
15928 
 
15929 
  def read(self, iprot):
15930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15932 
      return
15933 
    iprot.readStructBegin()
15934 
    while True:
15935 
      (fname, ftype, fid) = iprot.readFieldBegin()
15936 
      if ftype == TType.STOP:
15937 
        break
15938 
      if fid == 1:
15939 
        if ftype == TType.STRUCT:
15940 
          self.ex = TransactionServiceException()
15941 
          self.ex.read(iprot)
15942 
        else:
15943 
          iprot.skip(ftype)
15944 
      else:
15945 
        iprot.skip(ftype)
15946 
      iprot.readFieldEnd()
15947 
    iprot.readStructEnd()
15948 
 
15949 
  def write(self, oprot):
15950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15952 
      return
15953 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15954 
    if self.ex is not None:
15955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15956 
      self.ex.write(oprot)
15957 
      oprot.writeFieldEnd()
15958 
    oprot.writeFieldStop()
15959 
    oprot.writeStructEnd()
15960 
 
15961 
  def validate(self):
15962 
    return
15963 
 
15964 
 
15965 
  def __repr__(self):
15966 
    L = ['%s=%r' % (key, value)
15967 
      for key, value in self.__dict__.iteritems()]
15968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15969 
 
15970 
  def __eq__(self, other):
15971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15972 
 
15973 
  def __ne__(self, other):
15974 
    return not (self == other)
15975 
 
5553 rajveer 15976 
class markOrderAsReceivedAtStore_args:
15977 
  """
15978 
  Attributes:
15979 
   - orderId
15980 
   - deliveryTimestamp
15981 
  """
15982 
 
15983 
  thrift_spec = (
15984 
    None, # 0
15985 
    (1, TType.I64, 'orderId', None, None, ), # 1
15986 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15987 
  )
15988 
 
15989 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15990 
    self.orderId = orderId
15991 
    self.deliveryTimestamp = deliveryTimestamp
15992 
 
15993 
  def read(self, iprot):
15994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15996 
      return
15997 
    iprot.readStructBegin()
15998 
    while True:
15999 
      (fname, ftype, fid) = iprot.readFieldBegin()
16000 
      if ftype == TType.STOP:
16001 
        break
16002 
      if fid == 1:
16003 
        if ftype == TType.I64:
16004 
          self.orderId = iprot.readI64();
16005 
        else:
16006 
          iprot.skip(ftype)
16007 
      elif fid == 2:
16008 
        if ftype == TType.I64:
16009 
          self.deliveryTimestamp = iprot.readI64();
16010 
        else:
16011 
          iprot.skip(ftype)
16012 
      else:
16013 
        iprot.skip(ftype)
16014 
      iprot.readFieldEnd()
16015 
    iprot.readStructEnd()
16016 
 
16017 
  def write(self, oprot):
16018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16020 
      return
16021 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16022 
    if self.orderId is not None:
16023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16024 
      oprot.writeI64(self.orderId)
16025 
      oprot.writeFieldEnd()
16026 
    if self.deliveryTimestamp is not None:
16027 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16028 
      oprot.writeI64(self.deliveryTimestamp)
16029 
      oprot.writeFieldEnd()
16030 
    oprot.writeFieldStop()
16031 
    oprot.writeStructEnd()
16032 
 
16033 
  def validate(self):
16034 
    return
16035 
 
16036 
 
16037 
  def __repr__(self):
16038 
    L = ['%s=%r' % (key, value)
16039 
      for key, value in self.__dict__.iteritems()]
16040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16041 
 
16042 
  def __eq__(self, other):
16043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16044 
 
16045 
  def __ne__(self, other):
16046 
    return not (self == other)
16047 
 
16048 
class markOrderAsReceivedAtStore_result:
16049 
  """
16050 
  Attributes:
16051 
   - ex
16052 
  """
16053 
 
16054 
  thrift_spec = (
16055 
    None, # 0
16056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16057 
  )
16058 
 
16059 
  def __init__(self, ex=None,):
16060 
    self.ex = ex
16061 
 
16062 
  def read(self, iprot):
16063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16065 
      return
16066 
    iprot.readStructBegin()
16067 
    while True:
16068 
      (fname, ftype, fid) = iprot.readFieldBegin()
16069 
      if ftype == TType.STOP:
16070 
        break
16071 
      if fid == 1:
16072 
        if ftype == TType.STRUCT:
16073 
          self.ex = TransactionServiceException()
16074 
          self.ex.read(iprot)
16075 
        else:
16076 
          iprot.skip(ftype)
16077 
      else:
16078 
        iprot.skip(ftype)
16079 
      iprot.readFieldEnd()
16080 
    iprot.readStructEnd()
16081 
 
16082 
  def write(self, oprot):
16083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16085 
      return
16086 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16087 
    if self.ex is not None:
16088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16089 
      self.ex.write(oprot)
16090 
      oprot.writeFieldEnd()
16091 
    oprot.writeFieldStop()
16092 
    oprot.writeStructEnd()
16093 
 
16094 
  def validate(self):
16095 
    return
16096 
 
16097 
 
16098 
  def __repr__(self):
16099 
    L = ['%s=%r' % (key, value)
16100 
      for key, value in self.__dict__.iteritems()]
16101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16102 
 
16103 
  def __eq__(self, other):
16104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16105 
 
16106 
  def __ne__(self, other):
16107 
    return not (self == other)
16108 
 
4454 rajveer 16109 
class markOrderDoaRequestReceived_args:
16110 
  """
16111 
  Attributes:
16112 
   - orderId
16113 
  """
16114 
 
16115 
  thrift_spec = (
16116 
    None, # 0
16117 
    (1, TType.I64, 'orderId', None, None, ), # 1
16118 
  )
16119 
 
16120 
  def __init__(self, orderId=None,):
16121 
    self.orderId = orderId
16122 
 
16123 
  def read(self, iprot):
16124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16126 
      return
16127 
    iprot.readStructBegin()
16128 
    while True:
16129 
      (fname, ftype, fid) = iprot.readFieldBegin()
16130 
      if ftype == TType.STOP:
16131 
        break
16132 
      if fid == 1:
16133 
        if ftype == TType.I64:
16134 
          self.orderId = iprot.readI64();
16135 
        else:
16136 
          iprot.skip(ftype)
16137 
      else:
16138 
        iprot.skip(ftype)
16139 
      iprot.readFieldEnd()
16140 
    iprot.readStructEnd()
16141 
 
16142 
  def write(self, oprot):
16143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16145 
      return
16146 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16147 
    if self.orderId is not None:
16148 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16149 
      oprot.writeI64(self.orderId)
16150 
      oprot.writeFieldEnd()
16151 
    oprot.writeFieldStop()
16152 
    oprot.writeStructEnd()
16153 
 
16154 
  def validate(self):
16155 
    return
16156 
 
16157 
 
16158 
  def __repr__(self):
16159 
    L = ['%s=%r' % (key, value)
16160 
      for key, value in self.__dict__.iteritems()]
16161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16162 
 
16163 
  def __eq__(self, other):
16164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16165 
 
16166 
  def __ne__(self, other):
16167 
    return not (self == other)
16168 
 
16169 
class markOrderDoaRequestReceived_result:
16170 
  """
16171 
  Attributes:
16172 
   - success
16173 
   - ex
16174 
  """
16175 
 
16176 
  thrift_spec = (
16177 
    (0, TType.BOOL, 'success', None, None, ), # 0
16178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16179 
  )
16180 
 
16181 
  def __init__(self, success=None, ex=None,):
16182 
    self.success = success
16183 
    self.ex = ex
16184 
 
16185 
  def read(self, iprot):
16186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16188 
      return
16189 
    iprot.readStructBegin()
16190 
    while True:
16191 
      (fname, ftype, fid) = iprot.readFieldBegin()
16192 
      if ftype == TType.STOP:
16193 
        break
16194 
      if fid == 0:
16195 
        if ftype == TType.BOOL:
16196 
          self.success = iprot.readBool();
16197 
        else:
16198 
          iprot.skip(ftype)
16199 
      elif fid == 1:
16200 
        if ftype == TType.STRUCT:
16201 
          self.ex = TransactionServiceException()
16202 
          self.ex.read(iprot)
16203 
        else:
16204 
          iprot.skip(ftype)
16205 
      else:
16206 
        iprot.skip(ftype)
16207 
      iprot.readFieldEnd()
16208 
    iprot.readStructEnd()
16209 
 
16210 
  def write(self, oprot):
16211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16213 
      return
16214 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16215 
    if self.success is not None:
16216 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16217 
      oprot.writeBool(self.success)
16218 
      oprot.writeFieldEnd()
16219 
    if self.ex is not None:
16220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16221 
      self.ex.write(oprot)
16222 
      oprot.writeFieldEnd()
16223 
    oprot.writeFieldStop()
16224 
    oprot.writeStructEnd()
16225 
 
16226 
  def validate(self):
16227 
    return
16228 
 
16229 
 
16230 
  def __repr__(self):
16231 
    L = ['%s=%r' % (key, value)
16232 
      for key, value in self.__dict__.iteritems()]
16233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16234 
 
16235 
  def __eq__(self, other):
16236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16237 
 
16238 
  def __ne__(self, other):
16239 
    return not (self == other)
16240 
 
16241 
class markOrderDoaRequestAuthorized_args:
16242 
  """
16243 
  Attributes:
16244 
   - orderId
16245 
   - isAuthorized
16246 
  """
16247 
 
16248 
  thrift_spec = (
16249 
    None, # 0
16250 
    (1, TType.I64, 'orderId', None, None, ), # 1
16251 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16252 
  )
16253 
 
16254 
  def __init__(self, orderId=None, isAuthorized=None,):
16255 
    self.orderId = orderId
16256 
    self.isAuthorized = isAuthorized
16257 
 
16258 
  def read(self, iprot):
16259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16261 
      return
16262 
    iprot.readStructBegin()
16263 
    while True:
16264 
      (fname, ftype, fid) = iprot.readFieldBegin()
16265 
      if ftype == TType.STOP:
16266 
        break
16267 
      if fid == 1:
16268 
        if ftype == TType.I64:
16269 
          self.orderId = iprot.readI64();
16270 
        else:
16271 
          iprot.skip(ftype)
16272 
      elif fid == 2:
16273 
        if ftype == TType.BOOL:
16274 
          self.isAuthorized = iprot.readBool();
16275 
        else:
16276 
          iprot.skip(ftype)
16277 
      else:
16278 
        iprot.skip(ftype)
16279 
      iprot.readFieldEnd()
16280 
    iprot.readStructEnd()
16281 
 
16282 
  def write(self, oprot):
16283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16285 
      return
16286 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16287 
    if self.orderId is not None:
16288 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16289 
      oprot.writeI64(self.orderId)
16290 
      oprot.writeFieldEnd()
16291 
    if self.isAuthorized is not None:
16292 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16293 
      oprot.writeBool(self.isAuthorized)
16294 
      oprot.writeFieldEnd()
16295 
    oprot.writeFieldStop()
16296 
    oprot.writeStructEnd()
16297 
 
16298 
  def validate(self):
16299 
    return
16300 
 
16301 
 
16302 
  def __repr__(self):
16303 
    L = ['%s=%r' % (key, value)
16304 
      for key, value in self.__dict__.iteritems()]
16305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16306 
 
16307 
  def __eq__(self, other):
16308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16309 
 
16310 
  def __ne__(self, other):
16311 
    return not (self == other)
16312 
 
16313 
class markOrderDoaRequestAuthorized_result:
16314 
  """
16315 
  Attributes:
16316 
   - success
16317 
   - ex
16318 
  """
16319 
 
16320 
  thrift_spec = (
16321 
    (0, TType.BOOL, 'success', None, None, ), # 0
16322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16323 
  )
16324 
 
16325 
  def __init__(self, success=None, ex=None,):
16326 
    self.success = success
16327 
    self.ex = ex
16328 
 
16329 
  def read(self, iprot):
16330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16332 
      return
16333 
    iprot.readStructBegin()
16334 
    while True:
16335 
      (fname, ftype, fid) = iprot.readFieldBegin()
16336 
      if ftype == TType.STOP:
16337 
        break
16338 
      if fid == 0:
16339 
        if ftype == TType.BOOL:
16340 
          self.success = iprot.readBool();
16341 
        else:
16342 
          iprot.skip(ftype)
16343 
      elif fid == 1:
16344 
        if ftype == TType.STRUCT:
16345 
          self.ex = TransactionServiceException()
16346 
          self.ex.read(iprot)
16347 
        else:
16348 
          iprot.skip(ftype)
16349 
      else:
16350 
        iprot.skip(ftype)
16351 
      iprot.readFieldEnd()
16352 
    iprot.readStructEnd()
16353 
 
16354 
  def write(self, oprot):
16355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16357 
      return
16358 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16359 
    if self.success is not None:
16360 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16361 
      oprot.writeBool(self.success)
16362 
      oprot.writeFieldEnd()
16363 
    if self.ex is not None:
16364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16365 
      self.ex.write(oprot)
16366 
      oprot.writeFieldEnd()
16367 
    oprot.writeFieldStop()
16368 
    oprot.writeStructEnd()
16369 
 
16370 
  def validate(self):
16371 
    return
16372 
 
16373 
 
16374 
  def __repr__(self):
16375 
    L = ['%s=%r' % (key, value)
16376 
      for key, value in self.__dict__.iteritems()]
16377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16378 
 
16379 
  def __eq__(self, other):
16380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16381 
 
16382 
  def __ne__(self, other):
16383 
    return not (self == other)
16384 
 
4488 rajveer 16385 
class markOrderReturnRequestReceived_args:
16386 
  """
16387 
  Attributes:
16388 
   - orderId
16389 
  """
16390 
 
16391 
  thrift_spec = (
16392 
    None, # 0
16393 
    (1, TType.I64, 'orderId', None, None, ), # 1
16394 
  )
16395 
 
16396 
  def __init__(self, orderId=None,):
16397 
    self.orderId = orderId
16398 
 
16399 
  def read(self, iprot):
16400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16402 
      return
16403 
    iprot.readStructBegin()
16404 
    while True:
16405 
      (fname, ftype, fid) = iprot.readFieldBegin()
16406 
      if ftype == TType.STOP:
16407 
        break
16408 
      if fid == 1:
16409 
        if ftype == TType.I64:
16410 
          self.orderId = iprot.readI64();
16411 
        else:
16412 
          iprot.skip(ftype)
16413 
      else:
16414 
        iprot.skip(ftype)
16415 
      iprot.readFieldEnd()
16416 
    iprot.readStructEnd()
16417 
 
16418 
  def write(self, oprot):
16419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16421 
      return
16422 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16423 
    if self.orderId is not None:
16424 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16425 
      oprot.writeI64(self.orderId)
16426 
      oprot.writeFieldEnd()
16427 
    oprot.writeFieldStop()
16428 
    oprot.writeStructEnd()
16429 
 
16430 
  def validate(self):
16431 
    return
16432 
 
16433 
 
16434 
  def __repr__(self):
16435 
    L = ['%s=%r' % (key, value)
16436 
      for key, value in self.__dict__.iteritems()]
16437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16438 
 
16439 
  def __eq__(self, other):
16440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16441 
 
16442 
  def __ne__(self, other):
16443 
    return not (self == other)
16444 
 
16445 
class markOrderReturnRequestReceived_result:
16446 
  """
16447 
  Attributes:
16448 
   - success
16449 
   - ex
16450 
  """
16451 
 
16452 
  thrift_spec = (
16453 
    (0, TType.BOOL, 'success', None, None, ), # 0
16454 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16455 
  )
16456 
 
16457 
  def __init__(self, success=None, ex=None,):
16458 
    self.success = success
16459 
    self.ex = ex
16460 
 
16461 
  def read(self, iprot):
16462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16464 
      return
16465 
    iprot.readStructBegin()
16466 
    while True:
16467 
      (fname, ftype, fid) = iprot.readFieldBegin()
16468 
      if ftype == TType.STOP:
16469 
        break
16470 
      if fid == 0:
16471 
        if ftype == TType.BOOL:
16472 
          self.success = iprot.readBool();
16473 
        else:
16474 
          iprot.skip(ftype)
16475 
      elif fid == 1:
16476 
        if ftype == TType.STRUCT:
16477 
          self.ex = TransactionServiceException()
16478 
          self.ex.read(iprot)
16479 
        else:
16480 
          iprot.skip(ftype)
16481 
      else:
16482 
        iprot.skip(ftype)
16483 
      iprot.readFieldEnd()
16484 
    iprot.readStructEnd()
16485 
 
16486 
  def write(self, oprot):
16487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16489 
      return
16490 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16491 
    if self.success is not None:
16492 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16493 
      oprot.writeBool(self.success)
16494 
      oprot.writeFieldEnd()
16495 
    if self.ex is not None:
16496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16497 
      self.ex.write(oprot)
16498 
      oprot.writeFieldEnd()
16499 
    oprot.writeFieldStop()
16500 
    oprot.writeStructEnd()
16501 
 
16502 
  def validate(self):
16503 
    return
16504 
 
16505 
 
16506 
  def __repr__(self):
16507 
    L = ['%s=%r' % (key, value)
16508 
      for key, value in self.__dict__.iteritems()]
16509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16510 
 
16511 
  def __eq__(self, other):
16512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16513 
 
16514 
  def __ne__(self, other):
16515 
    return not (self == other)
16516 
 
16517 
class markOrderReturnRequestAuthorized_args:
16518 
  """
16519 
  Attributes:
16520 
   - orderId
16521 
   - isAuthorized
16522 
  """
16523 
 
16524 
  thrift_spec = (
16525 
    None, # 0
16526 
    (1, TType.I64, 'orderId', None, None, ), # 1
16527 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16528 
  )
16529 
 
16530 
  def __init__(self, orderId=None, isAuthorized=None,):
16531 
    self.orderId = orderId
16532 
    self.isAuthorized = isAuthorized
16533 
 
16534 
  def read(self, iprot):
16535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16537 
      return
16538 
    iprot.readStructBegin()
16539 
    while True:
16540 
      (fname, ftype, fid) = iprot.readFieldBegin()
16541 
      if ftype == TType.STOP:
16542 
        break
16543 
      if fid == 1:
16544 
        if ftype == TType.I64:
16545 
          self.orderId = iprot.readI64();
16546 
        else:
16547 
          iprot.skip(ftype)
16548 
      elif fid == 2:
16549 
        if ftype == TType.BOOL:
16550 
          self.isAuthorized = iprot.readBool();
16551 
        else:
16552 
          iprot.skip(ftype)
16553 
      else:
16554 
        iprot.skip(ftype)
16555 
      iprot.readFieldEnd()
16556 
    iprot.readStructEnd()
16557 
 
16558 
  def write(self, oprot):
16559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16561 
      return
16562 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16563 
    if self.orderId is not None:
16564 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16565 
      oprot.writeI64(self.orderId)
16566 
      oprot.writeFieldEnd()
16567 
    if self.isAuthorized is not None:
16568 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16569 
      oprot.writeBool(self.isAuthorized)
16570 
      oprot.writeFieldEnd()
16571 
    oprot.writeFieldStop()
16572 
    oprot.writeStructEnd()
16573 
 
16574 
  def validate(self):
16575 
    return
16576 
 
16577 
 
16578 
  def __repr__(self):
16579 
    L = ['%s=%r' % (key, value)
16580 
      for key, value in self.__dict__.iteritems()]
16581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16582 
 
16583 
  def __eq__(self, other):
16584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16585 
 
16586 
  def __ne__(self, other):
16587 
    return not (self == other)
16588 
 
16589 
class markOrderReturnRequestAuthorized_result:
16590 
  """
16591 
  Attributes:
16592 
   - success
16593 
   - ex
16594 
  """
16595 
 
16596 
  thrift_spec = (
16597 
    (0, TType.BOOL, 'success', None, None, ), # 0
16598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16599 
  )
16600 
 
16601 
  def __init__(self, success=None, ex=None,):
16602 
    self.success = success
16603 
    self.ex = ex
16604 
 
16605 
  def read(self, iprot):
16606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16608 
      return
16609 
    iprot.readStructBegin()
16610 
    while True:
16611 
      (fname, ftype, fid) = iprot.readFieldBegin()
16612 
      if ftype == TType.STOP:
16613 
        break
16614 
      if fid == 0:
16615 
        if ftype == TType.BOOL:
16616 
          self.success = iprot.readBool();
16617 
        else:
16618 
          iprot.skip(ftype)
16619 
      elif fid == 1:
16620 
        if ftype == TType.STRUCT:
16621 
          self.ex = TransactionServiceException()
16622 
          self.ex.read(iprot)
16623 
        else:
16624 
          iprot.skip(ftype)
16625 
      else:
16626 
        iprot.skip(ftype)
16627 
      iprot.readFieldEnd()
16628 
    iprot.readStructEnd()
16629 
 
16630 
  def write(self, oprot):
16631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16633 
      return
16634 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16635 
    if self.success is not None:
16636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16637 
      oprot.writeBool(self.success)
16638 
      oprot.writeFieldEnd()
16639 
    if self.ex is not None:
16640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16641 
      self.ex.write(oprot)
16642 
      oprot.writeFieldEnd()
16643 
    oprot.writeFieldStop()
16644 
    oprot.writeStructEnd()
16645 
 
16646 
  def validate(self):
16647 
    return
16648 
 
16649 
 
16650 
  def __repr__(self):
16651 
    L = ['%s=%r' % (key, value)
16652 
      for key, value in self.__dict__.iteritems()]
16653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16654 
 
16655 
  def __eq__(self, other):
16656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16657 
 
16658 
  def __ne__(self, other):
16659 
    return not (self == other)
16660 
 
2536 chandransh 16661 
class requestPickupNumber_args:
16662 
  """
16663 
  Attributes:
16664 
   - orderId
4579 rajveer 16665 
   - providerId
2536 chandransh 16666 
  """
16667 
 
16668 
  thrift_spec = (
16669 
    None, # 0
16670 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16671 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16672 
  )
16673 
 
4579 rajveer 16674 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16675 
    self.orderId = orderId
4579 rajveer 16676 
    self.providerId = providerId
2536 chandransh 16677 
 
16678 
  def read(self, iprot):
16679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16681 
      return
16682 
    iprot.readStructBegin()
16683 
    while True:
16684 
      (fname, ftype, fid) = iprot.readFieldBegin()
16685 
      if ftype == TType.STOP:
16686 
        break
16687 
      if fid == 1:
16688 
        if ftype == TType.I64:
16689 
          self.orderId = iprot.readI64();
16690 
        else:
16691 
          iprot.skip(ftype)
4579 rajveer 16692 
      elif fid == 2:
16693 
        if ftype == TType.I64:
16694 
          self.providerId = iprot.readI64();
16695 
        else:
16696 
          iprot.skip(ftype)
2536 chandransh 16697 
      else:
16698 
        iprot.skip(ftype)
16699 
      iprot.readFieldEnd()
16700 
    iprot.readStructEnd()
16701 
 
16702 
  def write(self, oprot):
16703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16705 
      return
16706 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16707 
    if self.orderId is not None:
2536 chandransh 16708 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16709 
      oprot.writeI64(self.orderId)
16710 
      oprot.writeFieldEnd()
4579 rajveer 16711 
    if self.providerId is not None:
16712 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16713 
      oprot.writeI64(self.providerId)
16714 
      oprot.writeFieldEnd()
2536 chandransh 16715 
    oprot.writeFieldStop()
16716 
    oprot.writeStructEnd()
16717 
 
3431 rajveer 16718 
  def validate(self):
16719 
    return
16720 
 
16721 
 
2536 chandransh 16722 
  def __repr__(self):
16723 
    L = ['%s=%r' % (key, value)
16724 
      for key, value in self.__dict__.iteritems()]
16725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16726 
 
16727 
  def __eq__(self, other):
16728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16729 
 
16730 
  def __ne__(self, other):
16731 
    return not (self == other)
16732 
 
16733 
class requestPickupNumber_result:
16734 
  """
16735 
  Attributes:
16736 
   - success
16737 
   - ex
16738 
  """
16739 
 
16740 
  thrift_spec = (
16741 
    (0, TType.BOOL, 'success', None, None, ), # 0
16742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16743 
  )
16744 
 
16745 
  def __init__(self, success=None, ex=None,):
16746 
    self.success = success
16747 
    self.ex = ex
16748 
 
16749 
  def read(self, iprot):
16750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16752 
      return
16753 
    iprot.readStructBegin()
16754 
    while True:
16755 
      (fname, ftype, fid) = iprot.readFieldBegin()
16756 
      if ftype == TType.STOP:
16757 
        break
16758 
      if fid == 0:
16759 
        if ftype == TType.BOOL:
16760 
          self.success = iprot.readBool();
16761 
        else:
16762 
          iprot.skip(ftype)
16763 
      elif fid == 1:
16764 
        if ftype == TType.STRUCT:
16765 
          self.ex = TransactionServiceException()
16766 
          self.ex.read(iprot)
16767 
        else:
16768 
          iprot.skip(ftype)
16769 
      else:
16770 
        iprot.skip(ftype)
16771 
      iprot.readFieldEnd()
16772 
    iprot.readStructEnd()
16773 
 
16774 
  def write(self, oprot):
16775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16777 
      return
16778 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16779 
    if self.success is not None:
2536 chandransh 16780 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16781 
      oprot.writeBool(self.success)
16782 
      oprot.writeFieldEnd()
3431 rajveer 16783 
    if self.ex is not None:
2536 chandransh 16784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16785 
      self.ex.write(oprot)
16786 
      oprot.writeFieldEnd()
16787 
    oprot.writeFieldStop()
16788 
    oprot.writeStructEnd()
16789 
 
3431 rajveer 16790 
  def validate(self):
16791 
    return
16792 
 
16793 
 
2536 chandransh 16794 
  def __repr__(self):
16795 
    L = ['%s=%r' % (key, value)
16796 
      for key, value in self.__dict__.iteritems()]
16797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16798 
 
16799 
  def __eq__(self, other):
16800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16801 
 
16802 
  def __ne__(self, other):
16803 
    return not (self == other)
16804 
 
16805 
class authorizePickup_args:
16806 
  """
16807 
  Attributes:
16808 
   - orderId
16809 
   - pickupNumber
4602 rajveer 16810 
   - providerId
2536 chandransh 16811 
  """
16812 
 
16813 
  thrift_spec = (
16814 
    None, # 0
16815 
    (1, TType.I64, 'orderId', None, None, ), # 1
16816 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16817 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16818 
  )
16819 
 
4602 rajveer 16820 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16821 
    self.orderId = orderId
16822 
    self.pickupNumber = pickupNumber
4602 rajveer 16823 
    self.providerId = providerId
2536 chandransh 16824 
 
16825 
  def read(self, iprot):
16826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16828 
      return
16829 
    iprot.readStructBegin()
16830 
    while True:
16831 
      (fname, ftype, fid) = iprot.readFieldBegin()
16832 
      if ftype == TType.STOP:
16833 
        break
16834 
      if fid == 1:
16835 
        if ftype == TType.I64:
16836 
          self.orderId = iprot.readI64();
16837 
        else:
16838 
          iprot.skip(ftype)
16839 
      elif fid == 2:
16840 
        if ftype == TType.STRING:
16841 
          self.pickupNumber = iprot.readString();
16842 
        else:
16843 
          iprot.skip(ftype)
4602 rajveer 16844 
      elif fid == 3:
16845 
        if ftype == TType.I64:
16846 
          self.providerId = iprot.readI64();
16847 
        else:
16848 
          iprot.skip(ftype)
2536 chandransh 16849 
      else:
16850 
        iprot.skip(ftype)
16851 
      iprot.readFieldEnd()
16852 
    iprot.readStructEnd()
16853 
 
16854 
  def write(self, oprot):
16855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16857 
      return
16858 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16859 
    if self.orderId is not None:
2536 chandransh 16860 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16861 
      oprot.writeI64(self.orderId)
16862 
      oprot.writeFieldEnd()
3431 rajveer 16863 
    if self.pickupNumber is not None:
2536 chandransh 16864 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16865 
      oprot.writeString(self.pickupNumber)
16866 
      oprot.writeFieldEnd()
4602 rajveer 16867 
    if self.providerId is not None:
16868 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16869 
      oprot.writeI64(self.providerId)
16870 
      oprot.writeFieldEnd()
2536 chandransh 16871 
    oprot.writeFieldStop()
16872 
    oprot.writeStructEnd()
16873 
 
3431 rajveer 16874 
  def validate(self):
16875 
    return
16876 
 
16877 
 
2536 chandransh 16878 
  def __repr__(self):
16879 
    L = ['%s=%r' % (key, value)
16880 
      for key, value in self.__dict__.iteritems()]
16881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16882 
 
16883 
  def __eq__(self, other):
16884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16885 
 
16886 
  def __ne__(self, other):
16887 
    return not (self == other)
16888 
 
16889 
class authorizePickup_result:
16890 
  """
16891 
  Attributes:
16892 
   - success
16893 
   - ex
16894 
  """
16895 
 
16896 
  thrift_spec = (
16897 
    (0, TType.BOOL, 'success', None, None, ), # 0
16898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16899 
  )
16900 
 
16901 
  def __init__(self, success=None, ex=None,):
16902 
    self.success = success
16903 
    self.ex = ex
16904 
 
16905 
  def read(self, iprot):
16906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16908 
      return
16909 
    iprot.readStructBegin()
16910 
    while True:
16911 
      (fname, ftype, fid) = iprot.readFieldBegin()
16912 
      if ftype == TType.STOP:
16913 
        break
16914 
      if fid == 0:
16915 
        if ftype == TType.BOOL:
16916 
          self.success = iprot.readBool();
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      elif fid == 1:
16920 
        if ftype == TType.STRUCT:
16921 
          self.ex = TransactionServiceException()
16922 
          self.ex.read(iprot)
16923 
        else:
16924 
          iprot.skip(ftype)
16925 
      else:
16926 
        iprot.skip(ftype)
16927 
      iprot.readFieldEnd()
16928 
    iprot.readStructEnd()
16929 
 
16930 
  def write(self, oprot):
16931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16933 
      return
16934 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16935 
    if self.success is not None:
2536 chandransh 16936 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16937 
      oprot.writeBool(self.success)
16938 
      oprot.writeFieldEnd()
3431 rajveer 16939 
    if self.ex is not None:
2536 chandransh 16940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16941 
      self.ex.write(oprot)
16942 
      oprot.writeFieldEnd()
16943 
    oprot.writeFieldStop()
16944 
    oprot.writeStructEnd()
16945 
 
3431 rajveer 16946 
  def validate(self):
16947 
    return
16948 
 
16949 
 
2536 chandransh 16950 
  def __repr__(self):
16951 
    L = ['%s=%r' % (key, value)
16952 
      for key, value in self.__dict__.iteritems()]
16953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16954 
 
16955 
  def __eq__(self, other):
16956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16957 
 
16958 
  def __ne__(self, other):
16959 
    return not (self == other)
16960 
 
2764 chandransh 16961 
class markDoasAsPickedUp_args:
16962 
  """
16963 
  Attributes:
16964 
   - providerId
16965 
   - pickupDetails
16966 
  """
16967 
 
16968 
  thrift_spec = (
16969 
    None, # 0
16970 
    (1, TType.I64, 'providerId', None, None, ), # 1
16971 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16972 
  )
16973 
 
16974 
  def __init__(self, providerId=None, pickupDetails=None,):
16975 
    self.providerId = providerId
16976 
    self.pickupDetails = pickupDetails
16977 
 
16978 
  def read(self, iprot):
16979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16981 
      return
16982 
    iprot.readStructBegin()
16983 
    while True:
16984 
      (fname, ftype, fid) = iprot.readFieldBegin()
16985 
      if ftype == TType.STOP:
16986 
        break
16987 
      if fid == 1:
16988 
        if ftype == TType.I64:
16989 
          self.providerId = iprot.readI64();
16990 
        else:
16991 
          iprot.skip(ftype)
16992 
      elif fid == 2:
16993 
        if ftype == TType.MAP:
16994 
          self.pickupDetails = {}
6031 rajveer 16995 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16996 
          for _i368 in xrange(_size364):
16997 
            _key369 = iprot.readString();
16998 
            _val370 = iprot.readString();
16999 
            self.pickupDetails[_key369] = _val370
2764 chandransh 17000 
          iprot.readMapEnd()
17001 
        else:
17002 
          iprot.skip(ftype)
17003 
      else:
17004 
        iprot.skip(ftype)
17005 
      iprot.readFieldEnd()
17006 
    iprot.readStructEnd()
17007 
 
17008 
  def write(self, oprot):
17009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17011 
      return
17012 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17013 
    if self.providerId is not None:
2764 chandransh 17014 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17015 
      oprot.writeI64(self.providerId)
17016 
      oprot.writeFieldEnd()
3431 rajveer 17017 
    if self.pickupDetails is not None:
2764 chandransh 17018 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17019 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17020 
      for kiter371,viter372 in self.pickupDetails.items():
17021 
        oprot.writeString(kiter371)
17022 
        oprot.writeString(viter372)
2764 chandransh 17023 
      oprot.writeMapEnd()
17024 
      oprot.writeFieldEnd()
17025 
    oprot.writeFieldStop()
17026 
    oprot.writeStructEnd()
17027 
 
3431 rajveer 17028 
  def validate(self):
17029 
    return
17030 
 
17031 
 
2764 chandransh 17032 
  def __repr__(self):
17033 
    L = ['%s=%r' % (key, value)
17034 
      for key, value in self.__dict__.iteritems()]
17035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17036 
 
17037 
  def __eq__(self, other):
17038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17039 
 
17040 
  def __ne__(self, other):
17041 
    return not (self == other)
17042 
 
17043 
class markDoasAsPickedUp_result:
4910 phani.kuma 17044 
 
17045 
  thrift_spec = (
17046 
  )
17047 
 
17048 
  def read(self, iprot):
17049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17051 
      return
17052 
    iprot.readStructBegin()
17053 
    while True:
17054 
      (fname, ftype, fid) = iprot.readFieldBegin()
17055 
      if ftype == TType.STOP:
17056 
        break
17057 
      else:
17058 
        iprot.skip(ftype)
17059 
      iprot.readFieldEnd()
17060 
    iprot.readStructEnd()
17061 
 
17062 
  def write(self, oprot):
17063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17065 
      return
17066 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17067 
    oprot.writeFieldStop()
17068 
    oprot.writeStructEnd()
17069 
 
17070 
  def validate(self):
17071 
    return
17072 
 
17073 
 
17074 
  def __repr__(self):
17075 
    L = ['%s=%r' % (key, value)
17076 
      for key, value in self.__dict__.iteritems()]
17077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17078 
 
17079 
  def __eq__(self, other):
17080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17081 
 
17082 
  def __ne__(self, other):
17083 
    return not (self == other)
17084 
 
17085 
class getDoasNotPickedUp_args:
2764 chandransh 17086 
  """
17087 
  Attributes:
4910 phani.kuma 17088 
   - providerId
17089 
  """
17090 
 
17091 
  thrift_spec = (
17092 
    None, # 0
17093 
    (1, TType.I64, 'providerId', None, None, ), # 1
17094 
  )
17095 
 
17096 
  def __init__(self, providerId=None,):
17097 
    self.providerId = providerId
17098 
 
17099 
  def read(self, iprot):
17100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17102 
      return
17103 
    iprot.readStructBegin()
17104 
    while True:
17105 
      (fname, ftype, fid) = iprot.readFieldBegin()
17106 
      if ftype == TType.STOP:
17107 
        break
17108 
      if fid == 1:
17109 
        if ftype == TType.I64:
17110 
          self.providerId = iprot.readI64();
17111 
        else:
17112 
          iprot.skip(ftype)
17113 
      else:
17114 
        iprot.skip(ftype)
17115 
      iprot.readFieldEnd()
17116 
    iprot.readStructEnd()
17117 
 
17118 
  def write(self, oprot):
17119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17121 
      return
17122 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17123 
    if self.providerId is not None:
17124 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17125 
      oprot.writeI64(self.providerId)
17126 
      oprot.writeFieldEnd()
17127 
    oprot.writeFieldStop()
17128 
    oprot.writeStructEnd()
17129 
 
17130 
  def validate(self):
17131 
    return
17132 
 
17133 
 
17134 
  def __repr__(self):
17135 
    L = ['%s=%r' % (key, value)
17136 
      for key, value in self.__dict__.iteritems()]
17137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17138 
 
17139 
  def __eq__(self, other):
17140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17141 
 
17142 
  def __ne__(self, other):
17143 
    return not (self == other)
17144 
 
17145 
class getDoasNotPickedUp_result:
17146 
  """
17147 
  Attributes:
2764 chandransh 17148 
   - success
17149 
  """
17150 
 
17151 
  thrift_spec = (
17152 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17153 
  )
17154 
 
17155 
  def __init__(self, success=None,):
17156 
    self.success = success
17157 
 
17158 
  def read(self, iprot):
17159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17161 
      return
17162 
    iprot.readStructBegin()
17163 
    while True:
17164 
      (fname, ftype, fid) = iprot.readFieldBegin()
17165 
      if ftype == TType.STOP:
17166 
        break
17167 
      if fid == 0:
17168 
        if ftype == TType.LIST:
17169 
          self.success = []
6031 rajveer 17170 
          (_etype376, _size373) = iprot.readListBegin()
17171 
          for _i377 in xrange(_size373):
17172 
            _elem378 = Order()
17173 
            _elem378.read(iprot)
17174 
            self.success.append(_elem378)
2764 chandransh 17175 
          iprot.readListEnd()
17176 
        else:
17177 
          iprot.skip(ftype)
17178 
      else:
17179 
        iprot.skip(ftype)
17180 
      iprot.readFieldEnd()
17181 
    iprot.readStructEnd()
17182 
 
17183 
  def write(self, oprot):
17184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17186 
      return
4910 phani.kuma 17187 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17188 
    if self.success is not None:
2764 chandransh 17189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17191 
      for iter379 in self.success:
17192 
        iter379.write(oprot)
2764 chandransh 17193 
      oprot.writeListEnd()
17194 
      oprot.writeFieldEnd()
17195 
    oprot.writeFieldStop()
17196 
    oprot.writeStructEnd()
17197 
 
3431 rajveer 17198 
  def validate(self):
17199 
    return
17200 
 
17201 
 
2764 chandransh 17202 
  def __repr__(self):
17203 
    L = ['%s=%r' % (key, value)
17204 
      for key, value in self.__dict__.iteritems()]
17205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17206 
 
17207 
  def __eq__(self, other):
17208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17209 
 
17210 
  def __ne__(self, other):
17211 
    return not (self == other)
17212 
 
4741 phani.kuma 17213 
class markReturnOrdersAsPickedUp_args:
17214 
  """
17215 
  Attributes:
17216 
   - providerId
17217 
   - pickupDetails
17218 
  """
17219 
 
17220 
  thrift_spec = (
17221 
    None, # 0
17222 
    (1, TType.I64, 'providerId', None, None, ), # 1
17223 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17224 
  )
17225 
 
17226 
  def __init__(self, providerId=None, pickupDetails=None,):
17227 
    self.providerId = providerId
17228 
    self.pickupDetails = pickupDetails
17229 
 
17230 
  def read(self, iprot):
17231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17233 
      return
17234 
    iprot.readStructBegin()
17235 
    while True:
17236 
      (fname, ftype, fid) = iprot.readFieldBegin()
17237 
      if ftype == TType.STOP:
17238 
        break
17239 
      if fid == 1:
17240 
        if ftype == TType.I64:
17241 
          self.providerId = iprot.readI64();
17242 
        else:
17243 
          iprot.skip(ftype)
17244 
      elif fid == 2:
17245 
        if ftype == TType.MAP:
17246 
          self.pickupDetails = {}
6031 rajveer 17247 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
17248 
          for _i384 in xrange(_size380):
17249 
            _key385 = iprot.readString();
17250 
            _val386 = iprot.readString();
17251 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 17252 
          iprot.readMapEnd()
17253 
        else:
17254 
          iprot.skip(ftype)
17255 
      else:
17256 
        iprot.skip(ftype)
17257 
      iprot.readFieldEnd()
17258 
    iprot.readStructEnd()
17259 
 
17260 
  def write(self, oprot):
17261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17263 
      return
17264 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17265 
    if self.providerId is not None:
17266 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17267 
      oprot.writeI64(self.providerId)
17268 
      oprot.writeFieldEnd()
17269 
    if self.pickupDetails is not None:
17270 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17271 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17272 
      for kiter387,viter388 in self.pickupDetails.items():
17273 
        oprot.writeString(kiter387)
17274 
        oprot.writeString(viter388)
4741 phani.kuma 17275 
      oprot.writeMapEnd()
17276 
      oprot.writeFieldEnd()
17277 
    oprot.writeFieldStop()
17278 
    oprot.writeStructEnd()
17279 
 
17280 
  def validate(self):
17281 
    return
17282 
 
17283 
 
17284 
  def __repr__(self):
17285 
    L = ['%s=%r' % (key, value)
17286 
      for key, value in self.__dict__.iteritems()]
17287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17288 
 
17289 
  def __eq__(self, other):
17290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17291 
 
17292 
  def __ne__(self, other):
17293 
    return not (self == other)
17294 
 
17295 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17296 
 
17297 
  thrift_spec = (
17298 
  )
17299 
 
17300 
  def read(self, iprot):
17301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17303 
      return
17304 
    iprot.readStructBegin()
17305 
    while True:
17306 
      (fname, ftype, fid) = iprot.readFieldBegin()
17307 
      if ftype == TType.STOP:
17308 
        break
17309 
      else:
17310 
        iprot.skip(ftype)
17311 
      iprot.readFieldEnd()
17312 
    iprot.readStructEnd()
17313 
 
17314 
  def write(self, oprot):
17315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17317 
      return
17318 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17319 
    oprot.writeFieldStop()
17320 
    oprot.writeStructEnd()
17321 
 
17322 
  def validate(self):
17323 
    return
17324 
 
17325 
 
17326 
  def __repr__(self):
17327 
    L = ['%s=%r' % (key, value)
17328 
      for key, value in self.__dict__.iteritems()]
17329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17330 
 
17331 
  def __eq__(self, other):
17332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17333 
 
17334 
  def __ne__(self, other):
17335 
    return not (self == other)
17336 
 
17337 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17338 
  """
17339 
  Attributes:
4910 phani.kuma 17340 
   - providerId
17341 
  """
17342 
 
17343 
  thrift_spec = (
17344 
    None, # 0
17345 
    (1, TType.I64, 'providerId', None, None, ), # 1
17346 
  )
17347 
 
17348 
  def __init__(self, providerId=None,):
17349 
    self.providerId = providerId
17350 
 
17351 
  def read(self, iprot):
17352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17354 
      return
17355 
    iprot.readStructBegin()
17356 
    while True:
17357 
      (fname, ftype, fid) = iprot.readFieldBegin()
17358 
      if ftype == TType.STOP:
17359 
        break
17360 
      if fid == 1:
17361 
        if ftype == TType.I64:
17362 
          self.providerId = iprot.readI64();
17363 
        else:
17364 
          iprot.skip(ftype)
17365 
      else:
17366 
        iprot.skip(ftype)
17367 
      iprot.readFieldEnd()
17368 
    iprot.readStructEnd()
17369 
 
17370 
  def write(self, oprot):
17371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17373 
      return
17374 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17375 
    if self.providerId is not None:
17376 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17377 
      oprot.writeI64(self.providerId)
17378 
      oprot.writeFieldEnd()
17379 
    oprot.writeFieldStop()
17380 
    oprot.writeStructEnd()
17381 
 
17382 
  def validate(self):
17383 
    return
17384 
 
17385 
 
17386 
  def __repr__(self):
17387 
    L = ['%s=%r' % (key, value)
17388 
      for key, value in self.__dict__.iteritems()]
17389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17390 
 
17391 
  def __eq__(self, other):
17392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17393 
 
17394 
  def __ne__(self, other):
17395 
    return not (self == other)
17396 
 
17397 
class getReturnOrdersNotPickedUp_result:
17398 
  """
17399 
  Attributes:
4741 phani.kuma 17400 
   - success
17401 
  """
17402 
 
17403 
  thrift_spec = (
17404 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17405 
  )
17406 
 
17407 
  def __init__(self, success=None,):
17408 
    self.success = success
17409 
 
17410 
  def read(self, iprot):
17411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17413 
      return
17414 
    iprot.readStructBegin()
17415 
    while True:
17416 
      (fname, ftype, fid) = iprot.readFieldBegin()
17417 
      if ftype == TType.STOP:
17418 
        break
17419 
      if fid == 0:
17420 
        if ftype == TType.LIST:
17421 
          self.success = []
6031 rajveer 17422 
          (_etype392, _size389) = iprot.readListBegin()
17423 
          for _i393 in xrange(_size389):
17424 
            _elem394 = Order()
17425 
            _elem394.read(iprot)
17426 
            self.success.append(_elem394)
4741 phani.kuma 17427 
          iprot.readListEnd()
17428 
        else:
17429 
          iprot.skip(ftype)
17430 
      else:
17431 
        iprot.skip(ftype)
17432 
      iprot.readFieldEnd()
17433 
    iprot.readStructEnd()
17434 
 
17435 
  def write(self, oprot):
17436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17438 
      return
4910 phani.kuma 17439 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17440 
    if self.success is not None:
17441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17443 
      for iter395 in self.success:
17444 
        iter395.write(oprot)
4741 phani.kuma 17445 
      oprot.writeListEnd()
17446 
      oprot.writeFieldEnd()
17447 
    oprot.writeFieldStop()
17448 
    oprot.writeStructEnd()
17449 
 
17450 
  def validate(self):
17451 
    return
17452 
 
17453 
 
17454 
  def __repr__(self):
17455 
    L = ['%s=%r' % (key, value)
17456 
      for key, value in self.__dict__.iteritems()]
17457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17458 
 
17459 
  def __eq__(self, other):
17460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17461 
 
17462 
  def __ne__(self, other):
17463 
    return not (self == other)
17464 
 
2616 chandransh 17465 
class receiveReturn_args:
2591 chandransh 17466 
  """
17467 
  Attributes:
17468 
   - orderId
4479 rajveer 17469 
   - receiveCondition
2591 chandransh 17470 
  """
2536 chandransh 17471 
 
2591 chandransh 17472 
  thrift_spec = (
17473 
    None, # 0
17474 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17475 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17476 
  )
17477 
 
4479 rajveer 17478 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17479 
    self.orderId = orderId
4479 rajveer 17480 
    self.receiveCondition = receiveCondition
2591 chandransh 17481 
 
17482 
  def read(self, iprot):
17483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17485 
      return
17486 
    iprot.readStructBegin()
17487 
    while True:
17488 
      (fname, ftype, fid) = iprot.readFieldBegin()
17489 
      if ftype == TType.STOP:
17490 
        break
17491 
      if fid == 1:
17492 
        if ftype == TType.I64:
17493 
          self.orderId = iprot.readI64();
17494 
        else:
17495 
          iprot.skip(ftype)
4479 rajveer 17496 
      elif fid == 2:
17497 
        if ftype == TType.I64:
17498 
          self.receiveCondition = iprot.readI64();
17499 
        else:
17500 
          iprot.skip(ftype)
2591 chandransh 17501 
      else:
17502 
        iprot.skip(ftype)
17503 
      iprot.readFieldEnd()
17504 
    iprot.readStructEnd()
17505 
 
17506 
  def write(self, oprot):
17507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17509 
      return
2616 chandransh 17510 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17511 
    if self.orderId is not None:
2591 chandransh 17512 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17513 
      oprot.writeI64(self.orderId)
17514 
      oprot.writeFieldEnd()
4479 rajveer 17515 
    if self.receiveCondition is not None:
17516 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17517 
      oprot.writeI64(self.receiveCondition)
17518 
      oprot.writeFieldEnd()
2591 chandransh 17519 
    oprot.writeFieldStop()
17520 
    oprot.writeStructEnd()
17521 
 
3431 rajveer 17522 
  def validate(self):
17523 
    return
17524 
 
17525 
 
2591 chandransh 17526 
  def __repr__(self):
17527 
    L = ['%s=%r' % (key, value)
17528 
      for key, value in self.__dict__.iteritems()]
17529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17530 
 
17531 
  def __eq__(self, other):
17532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17533 
 
17534 
  def __ne__(self, other):
17535 
    return not (self == other)
17536 
 
2616 chandransh 17537 
class receiveReturn_result:
2591 chandransh 17538 
  """
17539 
  Attributes:
17540 
   - success
17541 
   - ex
17542 
  """
17543 
 
17544 
  thrift_spec = (
17545 
    (0, TType.BOOL, 'success', None, None, ), # 0
17546 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17547 
  )
17548 
 
17549 
  def __init__(self, success=None, ex=None,):
17550 
    self.success = success
17551 
    self.ex = ex
17552 
 
17553 
  def read(self, iprot):
17554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17556 
      return
17557 
    iprot.readStructBegin()
17558 
    while True:
17559 
      (fname, ftype, fid) = iprot.readFieldBegin()
17560 
      if ftype == TType.STOP:
17561 
        break
17562 
      if fid == 0:
17563 
        if ftype == TType.BOOL:
17564 
          self.success = iprot.readBool();
17565 
        else:
17566 
          iprot.skip(ftype)
17567 
      elif fid == 1:
17568 
        if ftype == TType.STRUCT:
17569 
          self.ex = TransactionServiceException()
17570 
          self.ex.read(iprot)
17571 
        else:
17572 
          iprot.skip(ftype)
17573 
      else:
17574 
        iprot.skip(ftype)
17575 
      iprot.readFieldEnd()
17576 
    iprot.readStructEnd()
17577 
 
17578 
  def write(self, oprot):
17579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17581 
      return
2616 chandransh 17582 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17583 
    if self.success is not None:
2591 chandransh 17584 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17585 
      oprot.writeBool(self.success)
17586 
      oprot.writeFieldEnd()
3431 rajveer 17587 
    if self.ex is not None:
2591 chandransh 17588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17589 
      self.ex.write(oprot)
17590 
      oprot.writeFieldEnd()
17591 
    oprot.writeFieldStop()
17592 
    oprot.writeStructEnd()
17593 
 
3431 rajveer 17594 
  def validate(self):
17595 
    return
17596 
 
17597 
 
2591 chandransh 17598 
  def __repr__(self):
17599 
    L = ['%s=%r' % (key, value)
17600 
      for key, value in self.__dict__.iteritems()]
17601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17602 
 
17603 
  def __eq__(self, other):
17604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17605 
 
17606 
  def __ne__(self, other):
17607 
    return not (self == other)
17608 
 
17609 
class validateDoa_args:
17610 
  """
17611 
  Attributes:
17612 
   - orderId
17613 
   - isValid
17614 
  """
17615 
 
17616 
  thrift_spec = (
17617 
    None, # 0
17618 
    (1, TType.I64, 'orderId', None, None, ), # 1
17619 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17620 
  )
17621 
 
17622 
  def __init__(self, orderId=None, isValid=None,):
17623 
    self.orderId = orderId
17624 
    self.isValid = isValid
17625 
 
17626 
  def read(self, iprot):
17627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17629 
      return
17630 
    iprot.readStructBegin()
17631 
    while True:
17632 
      (fname, ftype, fid) = iprot.readFieldBegin()
17633 
      if ftype == TType.STOP:
17634 
        break
17635 
      if fid == 1:
17636 
        if ftype == TType.I64:
17637 
          self.orderId = iprot.readI64();
17638 
        else:
17639 
          iprot.skip(ftype)
17640 
      elif fid == 2:
17641 
        if ftype == TType.BOOL:
17642 
          self.isValid = iprot.readBool();
17643 
        else:
17644 
          iprot.skip(ftype)
17645 
      else:
17646 
        iprot.skip(ftype)
17647 
      iprot.readFieldEnd()
17648 
    iprot.readStructEnd()
17649 
 
17650 
  def write(self, oprot):
17651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17653 
      return
17654 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17655 
    if self.orderId is not None:
2591 chandransh 17656 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17657 
      oprot.writeI64(self.orderId)
17658 
      oprot.writeFieldEnd()
3431 rajveer 17659 
    if self.isValid is not None:
2591 chandransh 17660 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17661 
      oprot.writeBool(self.isValid)
17662 
      oprot.writeFieldEnd()
17663 
    oprot.writeFieldStop()
17664 
    oprot.writeStructEnd()
17665 
 
3431 rajveer 17666 
  def validate(self):
17667 
    return
17668 
 
17669 
 
2591 chandransh 17670 
  def __repr__(self):
17671 
    L = ['%s=%r' % (key, value)
17672 
      for key, value in self.__dict__.iteritems()]
17673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17674 
 
17675 
  def __eq__(self, other):
17676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17677 
 
17678 
  def __ne__(self, other):
17679 
    return not (self == other)
17680 
 
17681 
class validateDoa_result:
17682 
  """
17683 
  Attributes:
17684 
   - success
17685 
   - ex
17686 
  """
17687 
 
17688 
  thrift_spec = (
17689 
    (0, TType.BOOL, 'success', None, None, ), # 0
17690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17691 
  )
17692 
 
17693 
  def __init__(self, success=None, ex=None,):
17694 
    self.success = success
17695 
    self.ex = ex
17696 
 
17697 
  def read(self, iprot):
17698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17700 
      return
17701 
    iprot.readStructBegin()
17702 
    while True:
17703 
      (fname, ftype, fid) = iprot.readFieldBegin()
17704 
      if ftype == TType.STOP:
17705 
        break
17706 
      if fid == 0:
17707 
        if ftype == TType.BOOL:
17708 
          self.success = iprot.readBool();
17709 
        else:
17710 
          iprot.skip(ftype)
17711 
      elif fid == 1:
17712 
        if ftype == TType.STRUCT:
17713 
          self.ex = TransactionServiceException()
17714 
          self.ex.read(iprot)
17715 
        else:
17716 
          iprot.skip(ftype)
17717 
      else:
17718 
        iprot.skip(ftype)
17719 
      iprot.readFieldEnd()
17720 
    iprot.readStructEnd()
17721 
 
17722 
  def write(self, oprot):
17723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17725 
      return
17726 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17727 
    if self.success is not None:
2591 chandransh 17728 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17729 
      oprot.writeBool(self.success)
17730 
      oprot.writeFieldEnd()
3431 rajveer 17731 
    if self.ex is not None:
2591 chandransh 17732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17733 
      self.ex.write(oprot)
17734 
      oprot.writeFieldEnd()
17735 
    oprot.writeFieldStop()
17736 
    oprot.writeStructEnd()
17737 
 
3431 rajveer 17738 
  def validate(self):
17739 
    return
17740 
 
17741 
 
2591 chandransh 17742 
  def __repr__(self):
17743 
    L = ['%s=%r' % (key, value)
17744 
      for key, value in self.__dict__.iteritems()]
17745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17746 
 
17747 
  def __eq__(self, other):
17748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17749 
 
17750 
  def __ne__(self, other):
17751 
    return not (self == other)
17752 
 
4495 rajveer 17753 
class validateReturnProduct_args:
17754 
  """
17755 
  Attributes:
17756 
   - orderId
17757 
   - isUsable
17758 
  """
17759 
 
17760 
  thrift_spec = (
17761 
    None, # 0
17762 
    (1, TType.I64, 'orderId', None, None, ), # 1
17763 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17764 
  )
17765 
 
17766 
  def __init__(self, orderId=None, isUsable=None,):
17767 
    self.orderId = orderId
17768 
    self.isUsable = isUsable
17769 
 
17770 
  def read(self, iprot):
17771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17773 
      return
17774 
    iprot.readStructBegin()
17775 
    while True:
17776 
      (fname, ftype, fid) = iprot.readFieldBegin()
17777 
      if ftype == TType.STOP:
17778 
        break
17779 
      if fid == 1:
17780 
        if ftype == TType.I64:
17781 
          self.orderId = iprot.readI64();
17782 
        else:
17783 
          iprot.skip(ftype)
17784 
      elif fid == 2:
17785 
        if ftype == TType.BOOL:
17786 
          self.isUsable = iprot.readBool();
17787 
        else:
17788 
          iprot.skip(ftype)
17789 
      else:
17790 
        iprot.skip(ftype)
17791 
      iprot.readFieldEnd()
17792 
    iprot.readStructEnd()
17793 
 
17794 
  def write(self, oprot):
17795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17797 
      return
17798 
    oprot.writeStructBegin('validateReturnProduct_args')
17799 
    if self.orderId is not None:
17800 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17801 
      oprot.writeI64(self.orderId)
17802 
      oprot.writeFieldEnd()
17803 
    if self.isUsable is not None:
17804 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17805 
      oprot.writeBool(self.isUsable)
17806 
      oprot.writeFieldEnd()
17807 
    oprot.writeFieldStop()
17808 
    oprot.writeStructEnd()
17809 
 
17810 
  def validate(self):
17811 
    return
17812 
 
17813 
 
17814 
  def __repr__(self):
17815 
    L = ['%s=%r' % (key, value)
17816 
      for key, value in self.__dict__.iteritems()]
17817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17818 
 
17819 
  def __eq__(self, other):
17820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17821 
 
17822 
  def __ne__(self, other):
17823 
    return not (self == other)
17824 
 
17825 
class validateReturnProduct_result:
17826 
  """
17827 
  Attributes:
17828 
   - success
17829 
   - ex
17830 
  """
17831 
 
17832 
  thrift_spec = (
17833 
    (0, TType.BOOL, 'success', None, None, ), # 0
17834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17835 
  )
17836 
 
17837 
  def __init__(self, success=None, ex=None,):
17838 
    self.success = success
17839 
    self.ex = ex
17840 
 
17841 
  def read(self, iprot):
17842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17844 
      return
17845 
    iprot.readStructBegin()
17846 
    while True:
17847 
      (fname, ftype, fid) = iprot.readFieldBegin()
17848 
      if ftype == TType.STOP:
17849 
        break
17850 
      if fid == 0:
17851 
        if ftype == TType.BOOL:
17852 
          self.success = iprot.readBool();
17853 
        else:
17854 
          iprot.skip(ftype)
17855 
      elif fid == 1:
17856 
        if ftype == TType.STRUCT:
17857 
          self.ex = TransactionServiceException()
17858 
          self.ex.read(iprot)
17859 
        else:
17860 
          iprot.skip(ftype)
17861 
      else:
17862 
        iprot.skip(ftype)
17863 
      iprot.readFieldEnd()
17864 
    iprot.readStructEnd()
17865 
 
17866 
  def write(self, oprot):
17867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17869 
      return
17870 
    oprot.writeStructBegin('validateReturnProduct_result')
17871 
    if self.success is not None:
17872 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17873 
      oprot.writeBool(self.success)
17874 
      oprot.writeFieldEnd()
17875 
    if self.ex is not None:
17876 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17877 
      self.ex.write(oprot)
17878 
      oprot.writeFieldEnd()
17879 
    oprot.writeFieldStop()
17880 
    oprot.writeStructEnd()
17881 
 
17882 
  def validate(self):
17883 
    return
17884 
 
17885 
 
17886 
  def __repr__(self):
17887 
    L = ['%s=%r' % (key, value)
17888 
      for key, value in self.__dict__.iteritems()]
17889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17890 
 
17891 
  def __eq__(self, other):
17892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17893 
 
17894 
  def __ne__(self, other):
17895 
    return not (self == other)
17896 
 
2616 chandransh 17897 
class reshipOrder_args:
17898 
  """
17899 
  Attributes:
17900 
   - orderId
17901 
  """
2591 chandransh 17902 
 
2616 chandransh 17903 
  thrift_spec = (
17904 
    None, # 0
17905 
    (1, TType.I64, 'orderId', None, None, ), # 1
17906 
  )
17907 
 
17908 
  def __init__(self, orderId=None,):
17909 
    self.orderId = orderId
17910 
 
17911 
  def read(self, iprot):
17912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17914 
      return
17915 
    iprot.readStructBegin()
17916 
    while True:
17917 
      (fname, ftype, fid) = iprot.readFieldBegin()
17918 
      if ftype == TType.STOP:
17919 
        break
17920 
      if fid == 1:
17921 
        if ftype == TType.I64:
17922 
          self.orderId = iprot.readI64();
17923 
        else:
17924 
          iprot.skip(ftype)
17925 
      else:
17926 
        iprot.skip(ftype)
17927 
      iprot.readFieldEnd()
17928 
    iprot.readStructEnd()
17929 
 
17930 
  def write(self, oprot):
17931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17933 
      return
17934 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17935 
    if self.orderId is not None:
2616 chandransh 17936 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17937 
      oprot.writeI64(self.orderId)
17938 
      oprot.writeFieldEnd()
17939 
    oprot.writeFieldStop()
17940 
    oprot.writeStructEnd()
17941 
 
3431 rajveer 17942 
  def validate(self):
17943 
    return
17944 
 
17945 
 
2616 chandransh 17946 
  def __repr__(self):
17947 
    L = ['%s=%r' % (key, value)
17948 
      for key, value in self.__dict__.iteritems()]
17949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17950 
 
17951 
  def __eq__(self, other):
17952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17953 
 
17954 
  def __ne__(self, other):
17955 
    return not (self == other)
17956 
 
17957 
class reshipOrder_result:
17958 
  """
17959 
  Attributes:
17960 
   - success
17961 
   - ex
17962 
  """
17963 
 
17964 
  thrift_spec = (
17965 
    (0, TType.I64, 'success', None, None, ), # 0
17966 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17967 
  )
17968 
 
17969 
  def __init__(self, success=None, ex=None,):
17970 
    self.success = success
17971 
    self.ex = ex
17972 
 
17973 
  def read(self, iprot):
17974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17976 
      return
17977 
    iprot.readStructBegin()
17978 
    while True:
17979 
      (fname, ftype, fid) = iprot.readFieldBegin()
17980 
      if ftype == TType.STOP:
17981 
        break
17982 
      if fid == 0:
17983 
        if ftype == TType.I64:
17984 
          self.success = iprot.readI64();
17985 
        else:
17986 
          iprot.skip(ftype)
17987 
      elif fid == 1:
17988 
        if ftype == TType.STRUCT:
17989 
          self.ex = TransactionServiceException()
17990 
          self.ex.read(iprot)
17991 
        else:
17992 
          iprot.skip(ftype)
17993 
      else:
17994 
        iprot.skip(ftype)
17995 
      iprot.readFieldEnd()
17996 
    iprot.readStructEnd()
17997 
 
17998 
  def write(self, oprot):
17999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18001 
      return
18002 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18003 
    if self.success is not None:
2616 chandransh 18004 
      oprot.writeFieldBegin('success', TType.I64, 0)
18005 
      oprot.writeI64(self.success)
18006 
      oprot.writeFieldEnd()
3431 rajveer 18007 
    if self.ex is not None:
2616 chandransh 18008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18009 
      self.ex.write(oprot)
18010 
      oprot.writeFieldEnd()
18011 
    oprot.writeFieldStop()
18012 
    oprot.writeStructEnd()
18013 
 
3431 rajveer 18014 
  def validate(self):
18015 
    return
18016 
 
18017 
 
2616 chandransh 18018 
  def __repr__(self):
18019 
    L = ['%s=%r' % (key, value)
18020 
      for key, value in self.__dict__.iteritems()]
18021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18022 
 
18023 
  def __eq__(self, other):
18024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18025 
 
18026 
  def __ne__(self, other):
18027 
    return not (self == other)
18028 
 
18029 
class refundOrder_args:
18030 
  """
18031 
  Attributes:
18032 
   - orderId
3226 chandransh 18033 
   - refundedBy
18034 
   - reason
2616 chandransh 18035 
  """
18036 
 
18037 
  thrift_spec = (
18038 
    None, # 0
18039 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18040 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18041 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18042 
  )
18043 
 
3226 chandransh 18044 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18045 
    self.orderId = orderId
3226 chandransh 18046 
    self.refundedBy = refundedBy
18047 
    self.reason = reason
2616 chandransh 18048 
 
18049 
  def read(self, iprot):
18050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18052 
      return
18053 
    iprot.readStructBegin()
18054 
    while True:
18055 
      (fname, ftype, fid) = iprot.readFieldBegin()
18056 
      if ftype == TType.STOP:
18057 
        break
18058 
      if fid == 1:
18059 
        if ftype == TType.I64:
18060 
          self.orderId = iprot.readI64();
18061 
        else:
18062 
          iprot.skip(ftype)
3226 chandransh 18063 
      elif fid == 2:
18064 
        if ftype == TType.STRING:
18065 
          self.refundedBy = iprot.readString();
18066 
        else:
18067 
          iprot.skip(ftype)
18068 
      elif fid == 3:
18069 
        if ftype == TType.STRING:
18070 
          self.reason = iprot.readString();
18071 
        else:
18072 
          iprot.skip(ftype)
2616 chandransh 18073 
      else:
18074 
        iprot.skip(ftype)
18075 
      iprot.readFieldEnd()
18076 
    iprot.readStructEnd()
18077 
 
18078 
  def write(self, oprot):
18079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18081 
      return
18082 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18083 
    if self.orderId is not None:
2616 chandransh 18084 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18085 
      oprot.writeI64(self.orderId)
18086 
      oprot.writeFieldEnd()
3431 rajveer 18087 
    if self.refundedBy is not None:
3226 chandransh 18088 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18089 
      oprot.writeString(self.refundedBy)
18090 
      oprot.writeFieldEnd()
3431 rajveer 18091 
    if self.reason is not None:
3226 chandransh 18092 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18093 
      oprot.writeString(self.reason)
18094 
      oprot.writeFieldEnd()
2616 chandransh 18095 
    oprot.writeFieldStop()
18096 
    oprot.writeStructEnd()
18097 
 
3431 rajveer 18098 
  def validate(self):
18099 
    return
18100 
 
18101 
 
2616 chandransh 18102 
  def __repr__(self):
18103 
    L = ['%s=%r' % (key, value)
18104 
      for key, value in self.__dict__.iteritems()]
18105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18106 
 
18107 
  def __eq__(self, other):
18108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18109 
 
18110 
  def __ne__(self, other):
18111 
    return not (self == other)
18112 
 
18113 
class refundOrder_result:
18114 
  """
18115 
  Attributes:
18116 
   - success
18117 
   - ex
18118 
  """
18119 
 
18120 
  thrift_spec = (
18121 
    (0, TType.BOOL, 'success', None, None, ), # 0
18122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18123 
  )
18124 
 
18125 
  def __init__(self, success=None, ex=None,):
18126 
    self.success = success
18127 
    self.ex = ex
18128 
 
18129 
  def read(self, iprot):
18130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18132 
      return
18133 
    iprot.readStructBegin()
18134 
    while True:
18135 
      (fname, ftype, fid) = iprot.readFieldBegin()
18136 
      if ftype == TType.STOP:
18137 
        break
18138 
      if fid == 0:
18139 
        if ftype == TType.BOOL:
18140 
          self.success = iprot.readBool();
18141 
        else:
18142 
          iprot.skip(ftype)
18143 
      elif fid == 1:
18144 
        if ftype == TType.STRUCT:
18145 
          self.ex = TransactionServiceException()
18146 
          self.ex.read(iprot)
18147 
        else:
18148 
          iprot.skip(ftype)
18149 
      else:
18150 
        iprot.skip(ftype)
18151 
      iprot.readFieldEnd()
18152 
    iprot.readStructEnd()
18153 
 
18154 
  def write(self, oprot):
18155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18157 
      return
18158 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18159 
    if self.success is not None:
2616 chandransh 18160 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18161 
      oprot.writeBool(self.success)
18162 
      oprot.writeFieldEnd()
3431 rajveer 18163 
    if self.ex is not None:
2616 chandransh 18164 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18165 
      self.ex.write(oprot)
18166 
      oprot.writeFieldEnd()
18167 
    oprot.writeFieldStop()
18168 
    oprot.writeStructEnd()
18169 
 
3431 rajveer 18170 
  def validate(self):
18171 
    return
18172 
 
18173 
 
2616 chandransh 18174 
  def __repr__(self):
18175 
    L = ['%s=%r' % (key, value)
18176 
      for key, value in self.__dict__.iteritems()]
18177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18178 
 
18179 
  def __eq__(self, other):
18180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18181 
 
18182 
  def __ne__(self, other):
18183 
    return not (self == other)
18184 
 
2690 chandransh 18185 
class getReturnOrders_args:
18186 
  """
18187 
  Attributes:
18188 
   - warehouseId
18189 
   - fromDate
18190 
   - toDate
18191 
  """
2616 chandransh 18192 
 
2690 chandransh 18193 
  thrift_spec = (
18194 
    None, # 0
18195 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18196 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18197 
    (3, TType.I64, 'toDate', None, None, ), # 3
18198 
  )
18199 
 
18200 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18201 
    self.warehouseId = warehouseId
18202 
    self.fromDate = fromDate
18203 
    self.toDate = toDate
18204 
 
18205 
  def read(self, iprot):
18206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18208 
      return
18209 
    iprot.readStructBegin()
18210 
    while True:
18211 
      (fname, ftype, fid) = iprot.readFieldBegin()
18212 
      if ftype == TType.STOP:
18213 
        break
18214 
      if fid == 1:
18215 
        if ftype == TType.I64:
18216 
          self.warehouseId = iprot.readI64();
18217 
        else:
18218 
          iprot.skip(ftype)
18219 
      elif fid == 2:
18220 
        if ftype == TType.I64:
18221 
          self.fromDate = iprot.readI64();
18222 
        else:
18223 
          iprot.skip(ftype)
18224 
      elif fid == 3:
18225 
        if ftype == TType.I64:
18226 
          self.toDate = iprot.readI64();
18227 
        else:
18228 
          iprot.skip(ftype)
18229 
      else:
18230 
        iprot.skip(ftype)
18231 
      iprot.readFieldEnd()
18232 
    iprot.readStructEnd()
18233 
 
18234 
  def write(self, oprot):
18235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18237 
      return
18238 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18239 
    if self.warehouseId is not None:
2690 chandransh 18240 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18241 
      oprot.writeI64(self.warehouseId)
18242 
      oprot.writeFieldEnd()
3431 rajveer 18243 
    if self.fromDate is not None:
2690 chandransh 18244 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18245 
      oprot.writeI64(self.fromDate)
18246 
      oprot.writeFieldEnd()
3431 rajveer 18247 
    if self.toDate is not None:
2690 chandransh 18248 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18249 
      oprot.writeI64(self.toDate)
18250 
      oprot.writeFieldEnd()
18251 
    oprot.writeFieldStop()
18252 
    oprot.writeStructEnd()
18253 
 
3431 rajveer 18254 
  def validate(self):
18255 
    return
18256 
 
18257 
 
2690 chandransh 18258 
  def __repr__(self):
18259 
    L = ['%s=%r' % (key, value)
18260 
      for key, value in self.__dict__.iteritems()]
18261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18262 
 
18263 
  def __eq__(self, other):
18264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18265 
 
18266 
  def __ne__(self, other):
18267 
    return not (self == other)
18268 
 
18269 
class getReturnOrders_result:
18270 
  """
18271 
  Attributes:
18272 
   - success
18273 
  """
18274 
 
18275 
  thrift_spec = (
18276 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18277 
  )
18278 
 
18279 
  def __init__(self, success=None,):
18280 
    self.success = success
18281 
 
18282 
  def read(self, iprot):
18283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18285 
      return
18286 
    iprot.readStructBegin()
18287 
    while True:
18288 
      (fname, ftype, fid) = iprot.readFieldBegin()
18289 
      if ftype == TType.STOP:
18290 
        break
18291 
      if fid == 0:
18292 
        if ftype == TType.LIST:
18293 
          self.success = []
6031 rajveer 18294 
          (_etype399, _size396) = iprot.readListBegin()
18295 
          for _i400 in xrange(_size396):
18296 
            _elem401 = ReturnOrder()
18297 
            _elem401.read(iprot)
18298 
            self.success.append(_elem401)
2690 chandransh 18299 
          iprot.readListEnd()
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      else:
18303 
        iprot.skip(ftype)
18304 
      iprot.readFieldEnd()
18305 
    iprot.readStructEnd()
18306 
 
18307 
  def write(self, oprot):
18308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18310 
      return
18311 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18312 
    if self.success is not None:
2690 chandransh 18313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18315 
      for iter402 in self.success:
18316 
        iter402.write(oprot)
2690 chandransh 18317 
      oprot.writeListEnd()
18318 
      oprot.writeFieldEnd()
18319 
    oprot.writeFieldStop()
18320 
    oprot.writeStructEnd()
18321 
 
3431 rajveer 18322 
  def validate(self):
18323 
    return
18324 
 
18325 
 
2690 chandransh 18326 
  def __repr__(self):
18327 
    L = ['%s=%r' % (key, value)
18328 
      for key, value in self.__dict__.iteritems()]
18329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18330 
 
18331 
  def __eq__(self, other):
18332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18333 
 
18334 
  def __ne__(self, other):
18335 
    return not (self == other)
18336 
 
5481 phani.kuma 18337 
class getAllReturnOrders_args:
18338 
  """
18339 
  Attributes:
18340 
   - onlyNotProcessed
18341 
   - fromDate
18342 
   - toDate
18343 
  """
18344 
 
18345 
  thrift_spec = (
18346 
    None, # 0
18347 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18348 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18349 
    (3, TType.I64, 'toDate', None, None, ), # 3
18350 
  )
18351 
 
18352 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18353 
    self.onlyNotProcessed = onlyNotProcessed
18354 
    self.fromDate = fromDate
18355 
    self.toDate = toDate
18356 
 
18357 
  def read(self, iprot):
18358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18360 
      return
18361 
    iprot.readStructBegin()
18362 
    while True:
18363 
      (fname, ftype, fid) = iprot.readFieldBegin()
18364 
      if ftype == TType.STOP:
18365 
        break
18366 
      if fid == 1:
18367 
        if ftype == TType.BOOL:
18368 
          self.onlyNotProcessed = iprot.readBool();
18369 
        else:
18370 
          iprot.skip(ftype)
18371 
      elif fid == 2:
18372 
        if ftype == TType.I64:
18373 
          self.fromDate = iprot.readI64();
18374 
        else:
18375 
          iprot.skip(ftype)
18376 
      elif fid == 3:
18377 
        if ftype == TType.I64:
18378 
          self.toDate = iprot.readI64();
18379 
        else:
18380 
          iprot.skip(ftype)
18381 
      else:
18382 
        iprot.skip(ftype)
18383 
      iprot.readFieldEnd()
18384 
    iprot.readStructEnd()
18385 
 
18386 
  def write(self, oprot):
18387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18389 
      return
18390 
    oprot.writeStructBegin('getAllReturnOrders_args')
18391 
    if self.onlyNotProcessed is not None:
18392 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18393 
      oprot.writeBool(self.onlyNotProcessed)
18394 
      oprot.writeFieldEnd()
18395 
    if self.fromDate is not None:
18396 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18397 
      oprot.writeI64(self.fromDate)
18398 
      oprot.writeFieldEnd()
18399 
    if self.toDate is not None:
18400 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18401 
      oprot.writeI64(self.toDate)
18402 
      oprot.writeFieldEnd()
18403 
    oprot.writeFieldStop()
18404 
    oprot.writeStructEnd()
18405 
 
18406 
  def validate(self):
18407 
    return
18408 
 
18409 
 
18410 
  def __repr__(self):
18411 
    L = ['%s=%r' % (key, value)
18412 
      for key, value in self.__dict__.iteritems()]
18413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18414 
 
18415 
  def __eq__(self, other):
18416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18417 
 
18418 
  def __ne__(self, other):
18419 
    return not (self == other)
18420 
 
18421 
class getAllReturnOrders_result:
18422 
  """
18423 
  Attributes:
18424 
   - success
18425 
  """
18426 
 
18427 
  thrift_spec = (
18428 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18429 
  )
18430 
 
18431 
  def __init__(self, success=None,):
18432 
    self.success = success
18433 
 
18434 
  def read(self, iprot):
18435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18437 
      return
18438 
    iprot.readStructBegin()
18439 
    while True:
18440 
      (fname, ftype, fid) = iprot.readFieldBegin()
18441 
      if ftype == TType.STOP:
18442 
        break
18443 
      if fid == 0:
18444 
        if ftype == TType.LIST:
18445 
          self.success = []
6031 rajveer 18446 
          (_etype406, _size403) = iprot.readListBegin()
18447 
          for _i407 in xrange(_size403):
18448 
            _elem408 = ReturnOrder()
18449 
            _elem408.read(iprot)
18450 
            self.success.append(_elem408)
5481 phani.kuma 18451 
          iprot.readListEnd()
18452 
        else:
18453 
          iprot.skip(ftype)
18454 
      else:
18455 
        iprot.skip(ftype)
18456 
      iprot.readFieldEnd()
18457 
    iprot.readStructEnd()
18458 
 
18459 
  def write(self, oprot):
18460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18462 
      return
18463 
    oprot.writeStructBegin('getAllReturnOrders_result')
18464 
    if self.success is not None:
18465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18467 
      for iter409 in self.success:
18468 
        iter409.write(oprot)
5481 phani.kuma 18469 
      oprot.writeListEnd()
18470 
      oprot.writeFieldEnd()
18471 
    oprot.writeFieldStop()
18472 
    oprot.writeStructEnd()
18473 
 
18474 
  def validate(self):
18475 
    return
18476 
 
18477 
 
18478 
  def __repr__(self):
18479 
    L = ['%s=%r' % (key, value)
18480 
      for key, value in self.__dict__.iteritems()]
18481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18482 
 
18483 
  def __eq__(self, other):
18484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18485 
 
18486 
  def __ne__(self, other):
18487 
    return not (self == other)
18488 
 
2700 chandransh 18489 
class getReturnOrder_args:
18490 
  """
18491 
  Attributes:
18492 
   - id
18493 
  """
18494 
 
18495 
  thrift_spec = (
18496 
    None, # 0
18497 
    (1, TType.I64, 'id', None, None, ), # 1
18498 
  )
18499 
 
18500 
  def __init__(self, id=None,):
18501 
    self.id = id
18502 
 
18503 
  def read(self, iprot):
18504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18506 
      return
18507 
    iprot.readStructBegin()
18508 
    while True:
18509 
      (fname, ftype, fid) = iprot.readFieldBegin()
18510 
      if ftype == TType.STOP:
18511 
        break
18512 
      if fid == 1:
18513 
        if ftype == TType.I64:
18514 
          self.id = iprot.readI64();
18515 
        else:
18516 
          iprot.skip(ftype)
18517 
      else:
18518 
        iprot.skip(ftype)
18519 
      iprot.readFieldEnd()
18520 
    iprot.readStructEnd()
18521 
 
18522 
  def write(self, oprot):
18523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18525 
      return
18526 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18527 
    if self.id is not None:
2700 chandransh 18528 
      oprot.writeFieldBegin('id', TType.I64, 1)
18529 
      oprot.writeI64(self.id)
18530 
      oprot.writeFieldEnd()
18531 
    oprot.writeFieldStop()
18532 
    oprot.writeStructEnd()
18533 
 
3431 rajveer 18534 
  def validate(self):
18535 
    return
18536 
 
18537 
 
2700 chandransh 18538 
  def __repr__(self):
18539 
    L = ['%s=%r' % (key, value)
18540 
      for key, value in self.__dict__.iteritems()]
18541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18542 
 
18543 
  def __eq__(self, other):
18544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18545 
 
18546 
  def __ne__(self, other):
18547 
    return not (self == other)
18548 
 
18549 
class getReturnOrder_result:
18550 
  """
18551 
  Attributes:
18552 
   - success
18553 
   - ex
18554 
  """
18555 
 
18556 
  thrift_spec = (
18557 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18559 
  )
18560 
 
18561 
  def __init__(self, success=None, ex=None,):
18562 
    self.success = success
18563 
    self.ex = ex
18564 
 
18565 
  def read(self, iprot):
18566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18568 
      return
18569 
    iprot.readStructBegin()
18570 
    while True:
18571 
      (fname, ftype, fid) = iprot.readFieldBegin()
18572 
      if ftype == TType.STOP:
18573 
        break
18574 
      if fid == 0:
18575 
        if ftype == TType.STRUCT:
18576 
          self.success = ReturnOrder()
18577 
          self.success.read(iprot)
18578 
        else:
18579 
          iprot.skip(ftype)
18580 
      elif fid == 1:
18581 
        if ftype == TType.STRUCT:
18582 
          self.ex = TransactionServiceException()
18583 
          self.ex.read(iprot)
18584 
        else:
18585 
          iprot.skip(ftype)
18586 
      else:
18587 
        iprot.skip(ftype)
18588 
      iprot.readFieldEnd()
18589 
    iprot.readStructEnd()
18590 
 
18591 
  def write(self, oprot):
18592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18594 
      return
18595 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18596 
    if self.success is not None:
2700 chandransh 18597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18598 
      self.success.write(oprot)
18599 
      oprot.writeFieldEnd()
3431 rajveer 18600 
    if self.ex is not None:
2700 chandransh 18601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18602 
      self.ex.write(oprot)
18603 
      oprot.writeFieldEnd()
18604 
    oprot.writeFieldStop()
18605 
    oprot.writeStructEnd()
18606 
 
3431 rajveer 18607 
  def validate(self):
18608 
    return
18609 
 
18610 
 
2700 chandransh 18611 
  def __repr__(self):
18612 
    L = ['%s=%r' % (key, value)
18613 
      for key, value in self.__dict__.iteritems()]
18614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18615 
 
18616 
  def __eq__(self, other):
18617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18618 
 
18619 
  def __ne__(self, other):
18620 
    return not (self == other)
18621 
 
2690 chandransh 18622 
class processReturn_args:
18623 
  """
18624 
  Attributes:
18625 
   - returnOrderId
18626 
  """
18627 
 
18628 
  thrift_spec = (
18629 
    None, # 0
18630 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18631 
  )
18632 
 
18633 
  def __init__(self, returnOrderId=None,):
18634 
    self.returnOrderId = returnOrderId
18635 
 
18636 
  def read(self, iprot):
18637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18639 
      return
18640 
    iprot.readStructBegin()
18641 
    while True:
18642 
      (fname, ftype, fid) = iprot.readFieldBegin()
18643 
      if ftype == TType.STOP:
18644 
        break
18645 
      if fid == 1:
18646 
        if ftype == TType.I64:
18647 
          self.returnOrderId = iprot.readI64();
18648 
        else:
18649 
          iprot.skip(ftype)
18650 
      else:
18651 
        iprot.skip(ftype)
18652 
      iprot.readFieldEnd()
18653 
    iprot.readStructEnd()
18654 
 
18655 
  def write(self, oprot):
18656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18658 
      return
18659 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18660 
    if self.returnOrderId is not None:
2690 chandransh 18661 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18662 
      oprot.writeI64(self.returnOrderId)
18663 
      oprot.writeFieldEnd()
18664 
    oprot.writeFieldStop()
18665 
    oprot.writeStructEnd()
18666 
 
3431 rajveer 18667 
  def validate(self):
18668 
    return
18669 
 
18670 
 
2690 chandransh 18671 
  def __repr__(self):
18672 
    L = ['%s=%r' % (key, value)
18673 
      for key, value in self.__dict__.iteritems()]
18674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18675 
 
18676 
  def __eq__(self, other):
18677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18678 
 
18679 
  def __ne__(self, other):
18680 
    return not (self == other)
18681 
 
18682 
class processReturn_result:
18683 
  """
18684 
  Attributes:
18685 
   - ex
18686 
  """
18687 
 
18688 
  thrift_spec = (
18689 
    None, # 0
18690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18691 
  )
18692 
 
18693 
  def __init__(self, ex=None,):
18694 
    self.ex = ex
18695 
 
18696 
  def read(self, iprot):
18697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18699 
      return
18700 
    iprot.readStructBegin()
18701 
    while True:
18702 
      (fname, ftype, fid) = iprot.readFieldBegin()
18703 
      if ftype == TType.STOP:
18704 
        break
18705 
      if fid == 1:
18706 
        if ftype == TType.STRUCT:
18707 
          self.ex = TransactionServiceException()
18708 
          self.ex.read(iprot)
18709 
        else:
18710 
          iprot.skip(ftype)
18711 
      else:
18712 
        iprot.skip(ftype)
18713 
      iprot.readFieldEnd()
18714 
    iprot.readStructEnd()
18715 
 
18716 
  def write(self, oprot):
18717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18719 
      return
18720 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18721 
    if self.ex is not None:
2690 chandransh 18722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18723 
      self.ex.write(oprot)
18724 
      oprot.writeFieldEnd()
18725 
    oprot.writeFieldStop()
18726 
    oprot.writeStructEnd()
18727 
 
3431 rajveer 18728 
  def validate(self):
18729 
    return
18730 
 
18731 
 
2690 chandransh 18732 
  def __repr__(self):
18733 
    L = ['%s=%r' % (key, value)
18734 
      for key, value in self.__dict__.iteritems()]
18735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18736 
 
18737 
  def __eq__(self, other):
18738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18739 
 
18740 
  def __ne__(self, other):
18741 
    return not (self == other)
18742 
 
3451 chandransh 18743 
class updateWeight_args:
18744 
  """
18745 
  Attributes:
18746 
   - orderId
18747 
   - weight
18748 
  """
18749 
 
18750 
  thrift_spec = (
18751 
    None, # 0
18752 
    (1, TType.I64, 'orderId', None, None, ), # 1
18753 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18754 
  )
18755 
 
18756 
  def __init__(self, orderId=None, weight=None,):
18757 
    self.orderId = orderId
18758 
    self.weight = weight
18759 
 
18760 
  def read(self, iprot):
18761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18763 
      return
18764 
    iprot.readStructBegin()
18765 
    while True:
18766 
      (fname, ftype, fid) = iprot.readFieldBegin()
18767 
      if ftype == TType.STOP:
18768 
        break
18769 
      if fid == 1:
18770 
        if ftype == TType.I64:
18771 
          self.orderId = iprot.readI64();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      elif fid == 2:
18775 
        if ftype == TType.DOUBLE:
18776 
          self.weight = iprot.readDouble();
18777 
        else:
18778 
          iprot.skip(ftype)
18779 
      else:
18780 
        iprot.skip(ftype)
18781 
      iprot.readFieldEnd()
18782 
    iprot.readStructEnd()
18783 
 
18784 
  def write(self, oprot):
18785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18787 
      return
18788 
    oprot.writeStructBegin('updateWeight_args')
18789 
    if self.orderId is not None:
18790 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18791 
      oprot.writeI64(self.orderId)
18792 
      oprot.writeFieldEnd()
18793 
    if self.weight is not None:
18794 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18795 
      oprot.writeDouble(self.weight)
18796 
      oprot.writeFieldEnd()
18797 
    oprot.writeFieldStop()
18798 
    oprot.writeStructEnd()
18799 
 
18800 
  def validate(self):
18801 
    return
18802 
 
18803 
 
18804 
  def __repr__(self):
18805 
    L = ['%s=%r' % (key, value)
18806 
      for key, value in self.__dict__.iteritems()]
18807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18808 
 
18809 
  def __eq__(self, other):
18810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18811 
 
18812 
  def __ne__(self, other):
18813 
    return not (self == other)
18814 
 
18815 
class updateWeight_result:
18816 
  """
18817 
  Attributes:
18818 
   - success
18819 
   - ex
18820 
  """
18821 
 
18822 
  thrift_spec = (
18823 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18825 
  )
18826 
 
18827 
  def __init__(self, success=None, ex=None,):
18828 
    self.success = success
18829 
    self.ex = ex
18830 
 
18831 
  def read(self, iprot):
18832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18834 
      return
18835 
    iprot.readStructBegin()
18836 
    while True:
18837 
      (fname, ftype, fid) = iprot.readFieldBegin()
18838 
      if ftype == TType.STOP:
18839 
        break
18840 
      if fid == 0:
18841 
        if ftype == TType.STRUCT:
18842 
          self.success = Order()
18843 
          self.success.read(iprot)
18844 
        else:
18845 
          iprot.skip(ftype)
18846 
      elif fid == 1:
18847 
        if ftype == TType.STRUCT:
18848 
          self.ex = TransactionServiceException()
18849 
          self.ex.read(iprot)
18850 
        else:
18851 
          iprot.skip(ftype)
18852 
      else:
18853 
        iprot.skip(ftype)
18854 
      iprot.readFieldEnd()
18855 
    iprot.readStructEnd()
18856 
 
18857 
  def write(self, oprot):
18858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18860 
      return
18861 
    oprot.writeStructBegin('updateWeight_result')
18862 
    if self.success is not None:
18863 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18864 
      self.success.write(oprot)
18865 
      oprot.writeFieldEnd()
18866 
    if self.ex is not None:
18867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18868 
      self.ex.write(oprot)
18869 
      oprot.writeFieldEnd()
18870 
    oprot.writeFieldStop()
18871 
    oprot.writeStructEnd()
18872 
 
18873 
  def validate(self):
18874 
    return
18875 
 
18876 
 
18877 
  def __repr__(self):
18878 
    L = ['%s=%r' % (key, value)
18879 
      for key, value in self.__dict__.iteritems()]
18880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18881 
 
18882 
  def __eq__(self, other):
18883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18884 
 
18885 
  def __ne__(self, other):
18886 
    return not (self == other)
3469 chandransh 18887 
 
18888 
class changeItem_args:
18889 
  """
18890 
  Attributes:
18891 
   - orderId
18892 
   - itemId
18893 
  """
18894 
 
18895 
  thrift_spec = (
18896 
    None, # 0
18897 
    (1, TType.I64, 'orderId', None, None, ), # 1
18898 
    (2, TType.I64, 'itemId', None, None, ), # 2
18899 
  )
18900 
 
18901 
  def __init__(self, orderId=None, itemId=None,):
18902 
    self.orderId = orderId
18903 
    self.itemId = itemId
18904 
 
18905 
  def read(self, iprot):
18906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18908 
      return
18909 
    iprot.readStructBegin()
18910 
    while True:
18911 
      (fname, ftype, fid) = iprot.readFieldBegin()
18912 
      if ftype == TType.STOP:
18913 
        break
18914 
      if fid == 1:
18915 
        if ftype == TType.I64:
18916 
          self.orderId = iprot.readI64();
18917 
        else:
18918 
          iprot.skip(ftype)
18919 
      elif fid == 2:
18920 
        if ftype == TType.I64:
18921 
          self.itemId = iprot.readI64();
18922 
        else:
18923 
          iprot.skip(ftype)
18924 
      else:
18925 
        iprot.skip(ftype)
18926 
      iprot.readFieldEnd()
18927 
    iprot.readStructEnd()
18928 
 
18929 
  def write(self, oprot):
18930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18932 
      return
18933 
    oprot.writeStructBegin('changeItem_args')
18934 
    if self.orderId is not None:
18935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18936 
      oprot.writeI64(self.orderId)
18937 
      oprot.writeFieldEnd()
18938 
    if self.itemId is not None:
18939 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18940 
      oprot.writeI64(self.itemId)
18941 
      oprot.writeFieldEnd()
18942 
    oprot.writeFieldStop()
18943 
    oprot.writeStructEnd()
18944 
 
18945 
  def validate(self):
18946 
    return
18947 
 
18948 
 
18949 
  def __repr__(self):
18950 
    L = ['%s=%r' % (key, value)
18951 
      for key, value in self.__dict__.iteritems()]
18952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18953 
 
18954 
  def __eq__(self, other):
18955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18956 
 
18957 
  def __ne__(self, other):
18958 
    return not (self == other)
18959 
 
18960 
class changeItem_result:
18961 
  """
18962 
  Attributes:
18963 
   - success
18964 
   - ex
18965 
  """
18966 
 
18967 
  thrift_spec = (
18968 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18969 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18970 
  )
18971 
 
18972 
  def __init__(self, success=None, ex=None,):
18973 
    self.success = success
18974 
    self.ex = ex
18975 
 
18976 
  def read(self, iprot):
18977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18979 
      return
18980 
    iprot.readStructBegin()
18981 
    while True:
18982 
      (fname, ftype, fid) = iprot.readFieldBegin()
18983 
      if ftype == TType.STOP:
18984 
        break
18985 
      if fid == 0:
18986 
        if ftype == TType.STRUCT:
18987 
          self.success = Order()
18988 
          self.success.read(iprot)
18989 
        else:
18990 
          iprot.skip(ftype)
18991 
      elif fid == 1:
18992 
        if ftype == TType.STRUCT:
18993 
          self.ex = TransactionServiceException()
18994 
          self.ex.read(iprot)
18995 
        else:
18996 
          iprot.skip(ftype)
18997 
      else:
18998 
        iprot.skip(ftype)
18999 
      iprot.readFieldEnd()
19000 
    iprot.readStructEnd()
19001 
 
19002 
  def write(self, oprot):
19003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19005 
      return
19006 
    oprot.writeStructBegin('changeItem_result')
19007 
    if self.success is not None:
19008 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19009 
      self.success.write(oprot)
19010 
      oprot.writeFieldEnd()
19011 
    if self.ex is not None:
19012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19013 
      self.ex.write(oprot)
19014 
      oprot.writeFieldEnd()
19015 
    oprot.writeFieldStop()
19016 
    oprot.writeStructEnd()
19017 
 
19018 
  def validate(self):
19019 
    return
19020 
 
19021 
 
19022 
  def __repr__(self):
19023 
    L = ['%s=%r' % (key, value)
19024 
      for key, value in self.__dict__.iteritems()]
19025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19026 
 
19027 
  def __eq__(self, other):
19028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19029 
 
19030 
  def __ne__(self, other):
19031 
    return not (self == other)
19032 
 
19033 
class shiftToWarehouse_args:
19034 
  """
19035 
  Attributes:
19036 
   - orderId
19037 
   - warehouseId
19038 
  """
19039 
 
19040 
  thrift_spec = (
19041 
    None, # 0
19042 
    (1, TType.I64, 'orderId', None, None, ), # 1
19043 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19044 
  )
19045 
 
19046 
  def __init__(self, orderId=None, warehouseId=None,):
19047 
    self.orderId = orderId
19048 
    self.warehouseId = warehouseId
19049 
 
19050 
  def read(self, iprot):
19051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19053 
      return
19054 
    iprot.readStructBegin()
19055 
    while True:
19056 
      (fname, ftype, fid) = iprot.readFieldBegin()
19057 
      if ftype == TType.STOP:
19058 
        break
19059 
      if fid == 1:
19060 
        if ftype == TType.I64:
19061 
          self.orderId = iprot.readI64();
19062 
        else:
19063 
          iprot.skip(ftype)
19064 
      elif fid == 2:
19065 
        if ftype == TType.I64:
19066 
          self.warehouseId = iprot.readI64();
19067 
        else:
19068 
          iprot.skip(ftype)
19069 
      else:
19070 
        iprot.skip(ftype)
19071 
      iprot.readFieldEnd()
19072 
    iprot.readStructEnd()
19073 
 
19074 
  def write(self, oprot):
19075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19077 
      return
19078 
    oprot.writeStructBegin('shiftToWarehouse_args')
19079 
    if self.orderId is not None:
19080 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19081 
      oprot.writeI64(self.orderId)
19082 
      oprot.writeFieldEnd()
19083 
    if self.warehouseId is not None:
19084 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19085 
      oprot.writeI64(self.warehouseId)
19086 
      oprot.writeFieldEnd()
19087 
    oprot.writeFieldStop()
19088 
    oprot.writeStructEnd()
19089 
 
19090 
  def validate(self):
19091 
    return
19092 
 
19093 
 
19094 
  def __repr__(self):
19095 
    L = ['%s=%r' % (key, value)
19096 
      for key, value in self.__dict__.iteritems()]
19097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19098 
 
19099 
  def __eq__(self, other):
19100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19101 
 
19102 
  def __ne__(self, other):
19103 
    return not (self == other)
19104 
 
19105 
class shiftToWarehouse_result:
19106 
  """
19107 
  Attributes:
19108 
   - success
19109 
   - ex
19110 
  """
19111 
 
19112 
  thrift_spec = (
19113 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19115 
  )
19116 
 
19117 
  def __init__(self, success=None, ex=None,):
19118 
    self.success = success
19119 
    self.ex = ex
19120 
 
19121 
  def read(self, iprot):
19122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19124 
      return
19125 
    iprot.readStructBegin()
19126 
    while True:
19127 
      (fname, ftype, fid) = iprot.readFieldBegin()
19128 
      if ftype == TType.STOP:
19129 
        break
19130 
      if fid == 0:
19131 
        if ftype == TType.STRUCT:
19132 
          self.success = Order()
19133 
          self.success.read(iprot)
19134 
        else:
19135 
          iprot.skip(ftype)
19136 
      elif fid == 1:
19137 
        if ftype == TType.STRUCT:
19138 
          self.ex = TransactionServiceException()
19139 
          self.ex.read(iprot)
19140 
        else:
19141 
          iprot.skip(ftype)
19142 
      else:
19143 
        iprot.skip(ftype)
19144 
      iprot.readFieldEnd()
19145 
    iprot.readStructEnd()
19146 
 
19147 
  def write(self, oprot):
19148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19150 
      return
19151 
    oprot.writeStructBegin('shiftToWarehouse_result')
19152 
    if self.success is not None:
19153 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19154 
      self.success.write(oprot)
19155 
      oprot.writeFieldEnd()
19156 
    if self.ex is not None:
19157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19158 
      self.ex.write(oprot)
19159 
      oprot.writeFieldEnd()
19160 
    oprot.writeFieldStop()
19161 
    oprot.writeStructEnd()
19162 
 
19163 
  def validate(self):
19164 
    return
19165 
 
19166 
 
19167 
  def __repr__(self):
19168 
    L = ['%s=%r' % (key, value)
19169 
      for key, value in self.__dict__.iteritems()]
19170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19171 
 
19172 
  def __eq__(self, other):
19173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19174 
 
19175 
  def __ne__(self, other):
19176 
    return not (self == other)
3553 chandransh 19177 
 
19178 
class addDelayReason_args:
19179 
  """
19180 
  Attributes:
19181 
   - orderId
19182 
   - delayReason
3986 chandransh 19183 
   - furtherDelay
4647 rajveer 19184 
   - delayReasonText
3553 chandransh 19185 
  """
19186 
 
19187 
  thrift_spec = (
19188 
    None, # 0
19189 
    (1, TType.I64, 'orderId', None, None, ), # 1
19190 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19191 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19192 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19193 
  )
19194 
 
4647 rajveer 19195 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19196 
    self.orderId = orderId
19197 
    self.delayReason = delayReason
3986 chandransh 19198 
    self.furtherDelay = furtherDelay
4647 rajveer 19199 
    self.delayReasonText = delayReasonText
3553 chandransh 19200 
 
19201 
  def read(self, iprot):
19202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19204 
      return
19205 
    iprot.readStructBegin()
19206 
    while True:
19207 
      (fname, ftype, fid) = iprot.readFieldBegin()
19208 
      if ftype == TType.STOP:
19209 
        break
19210 
      if fid == 1:
19211 
        if ftype == TType.I64:
19212 
          self.orderId = iprot.readI64();
19213 
        else:
19214 
          iprot.skip(ftype)
19215 
      elif fid == 2:
19216 
        if ftype == TType.I32:
19217 
          self.delayReason = iprot.readI32();
19218 
        else:
19219 
          iprot.skip(ftype)
3986 chandransh 19220 
      elif fid == 3:
19221 
        if ftype == TType.I64:
19222 
          self.furtherDelay = iprot.readI64();
19223 
        else:
19224 
          iprot.skip(ftype)
4647 rajveer 19225 
      elif fid == 4:
19226 
        if ftype == TType.STRING:
19227 
          self.delayReasonText = iprot.readString();
19228 
        else:
19229 
          iprot.skip(ftype)
3553 chandransh 19230 
      else:
19231 
        iprot.skip(ftype)
19232 
      iprot.readFieldEnd()
19233 
    iprot.readStructEnd()
19234 
 
19235 
  def write(self, oprot):
19236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19238 
      return
19239 
    oprot.writeStructBegin('addDelayReason_args')
19240 
    if self.orderId is not None:
19241 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19242 
      oprot.writeI64(self.orderId)
19243 
      oprot.writeFieldEnd()
19244 
    if self.delayReason is not None:
19245 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19246 
      oprot.writeI32(self.delayReason)
19247 
      oprot.writeFieldEnd()
3986 chandransh 19248 
    if self.furtherDelay is not None:
19249 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19250 
      oprot.writeI64(self.furtherDelay)
19251 
      oprot.writeFieldEnd()
4647 rajveer 19252 
    if self.delayReasonText is not None:
19253 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19254 
      oprot.writeString(self.delayReasonText)
19255 
      oprot.writeFieldEnd()
3553 chandransh 19256 
    oprot.writeFieldStop()
19257 
    oprot.writeStructEnd()
19258 
 
19259 
  def validate(self):
19260 
    return
19261 
 
19262 
 
19263 
  def __repr__(self):
19264 
    L = ['%s=%r' % (key, value)
19265 
      for key, value in self.__dict__.iteritems()]
19266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19267 
 
19268 
  def __eq__(self, other):
19269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19270 
 
19271 
  def __ne__(self, other):
19272 
    return not (self == other)
19273 
 
19274 
class addDelayReason_result:
19275 
  """
19276 
  Attributes:
19277 
   - success
19278 
   - ex
19279 
  """
19280 
 
19281 
  thrift_spec = (
19282 
    (0, TType.BOOL, 'success', None, None, ), # 0
19283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19284 
  )
19285 
 
19286 
  def __init__(self, success=None, ex=None,):
19287 
    self.success = success
19288 
    self.ex = ex
19289 
 
19290 
  def read(self, iprot):
19291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19293 
      return
19294 
    iprot.readStructBegin()
19295 
    while True:
19296 
      (fname, ftype, fid) = iprot.readFieldBegin()
19297 
      if ftype == TType.STOP:
19298 
        break
19299 
      if fid == 0:
19300 
        if ftype == TType.BOOL:
19301 
          self.success = iprot.readBool();
19302 
        else:
19303 
          iprot.skip(ftype)
19304 
      elif fid == 1:
19305 
        if ftype == TType.STRUCT:
19306 
          self.ex = TransactionServiceException()
19307 
          self.ex.read(iprot)
19308 
        else:
19309 
          iprot.skip(ftype)
19310 
      else:
19311 
        iprot.skip(ftype)
19312 
      iprot.readFieldEnd()
19313 
    iprot.readStructEnd()
19314 
 
19315 
  def write(self, oprot):
19316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19318 
      return
19319 
    oprot.writeStructBegin('addDelayReason_result')
19320 
    if self.success is not None:
19321 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19322 
      oprot.writeBool(self.success)
19323 
      oprot.writeFieldEnd()
19324 
    if self.ex is not None:
19325 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19326 
      self.ex.write(oprot)
19327 
      oprot.writeFieldEnd()
19328 
    oprot.writeFieldStop()
19329 
    oprot.writeStructEnd()
19330 
 
19331 
  def validate(self):
19332 
    return
19333 
 
19334 
 
19335 
  def __repr__(self):
19336 
    L = ['%s=%r' % (key, value)
19337 
      for key, value in self.__dict__.iteritems()]
19338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19339 
 
19340 
  def __eq__(self, other):
19341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19342 
 
19343 
  def __ne__(self, other):
19344 
    return not (self == other)
3956 chandransh 19345 
 
19346 
class reconcileCodCollection_args:
19347 
  """
19348 
  Attributes:
19349 
   - collectedAmountMap
19350 
   - xferBy
19351 
   - xferTxnId
19352 
   - xferDate
19353 
  """
19354 
 
19355 
  thrift_spec = (
19356 
    None, # 0
19357 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19358 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19359 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19360 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19361 
  )
19362 
 
19363 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19364 
    self.collectedAmountMap = collectedAmountMap
19365 
    self.xferBy = xferBy
19366 
    self.xferTxnId = xferTxnId
19367 
    self.xferDate = xferDate
19368 
 
19369 
  def read(self, iprot):
19370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19372 
      return
19373 
    iprot.readStructBegin()
19374 
    while True:
19375 
      (fname, ftype, fid) = iprot.readFieldBegin()
19376 
      if ftype == TType.STOP:
19377 
        break
19378 
      if fid == 1:
19379 
        if ftype == TType.MAP:
19380 
          self.collectedAmountMap = {}
6031 rajveer 19381 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19382 
          for _i414 in xrange(_size410):
19383 
            _key415 = iprot.readString();
19384 
            _val416 = iprot.readDouble();
19385 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19386 
          iprot.readMapEnd()
19387 
        else:
19388 
          iprot.skip(ftype)
19389 
      elif fid == 2:
19390 
        if ftype == TType.STRING:
19391 
          self.xferBy = iprot.readString();
19392 
        else:
19393 
          iprot.skip(ftype)
19394 
      elif fid == 3:
19395 
        if ftype == TType.STRING:
19396 
          self.xferTxnId = iprot.readString();
19397 
        else:
19398 
          iprot.skip(ftype)
19399 
      elif fid == 4:
19400 
        if ftype == TType.I64:
19401 
          self.xferDate = iprot.readI64();
19402 
        else:
19403 
          iprot.skip(ftype)
19404 
      else:
19405 
        iprot.skip(ftype)
19406 
      iprot.readFieldEnd()
19407 
    iprot.readStructEnd()
19408 
 
19409 
  def write(self, oprot):
19410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19412 
      return
19413 
    oprot.writeStructBegin('reconcileCodCollection_args')
19414 
    if self.collectedAmountMap is not None:
19415 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19416 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19417 
      for kiter417,viter418 in self.collectedAmountMap.items():
19418 
        oprot.writeString(kiter417)
19419 
        oprot.writeDouble(viter418)
3956 chandransh 19420 
      oprot.writeMapEnd()
19421 
      oprot.writeFieldEnd()
19422 
    if self.xferBy is not None:
19423 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19424 
      oprot.writeString(self.xferBy)
19425 
      oprot.writeFieldEnd()
19426 
    if self.xferTxnId is not None:
19427 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19428 
      oprot.writeString(self.xferTxnId)
19429 
      oprot.writeFieldEnd()
19430 
    if self.xferDate is not None:
19431 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19432 
      oprot.writeI64(self.xferDate)
19433 
      oprot.writeFieldEnd()
19434 
    oprot.writeFieldStop()
19435 
    oprot.writeStructEnd()
19436 
 
19437 
  def validate(self):
19438 
    return
19439 
 
19440 
 
19441 
  def __repr__(self):
19442 
    L = ['%s=%r' % (key, value)
19443 
      for key, value in self.__dict__.iteritems()]
19444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19445 
 
19446 
  def __eq__(self, other):
19447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19448 
 
19449 
  def __ne__(self, other):
19450 
    return not (self == other)
19451 
 
19452 
class reconcileCodCollection_result:
19453 
  """
19454 
  Attributes:
19455 
   - success
19456 
   - ex
19457 
  """
19458 
 
19459 
  thrift_spec = (
19460 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19461 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19462 
  )
19463 
 
19464 
  def __init__(self, success=None, ex=None,):
19465 
    self.success = success
19466 
    self.ex = ex
19467 
 
19468 
  def read(self, iprot):
19469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19471 
      return
19472 
    iprot.readStructBegin()
19473 
    while True:
19474 
      (fname, ftype, fid) = iprot.readFieldBegin()
19475 
      if ftype == TType.STOP:
19476 
        break
19477 
      if fid == 0:
19478 
        if ftype == TType.MAP:
19479 
          self.success = {}
6031 rajveer 19480 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19481 
          for _i423 in xrange(_size419):
19482 
            _key424 = iprot.readString();
19483 
            _val425 = iprot.readString();
19484 
            self.success[_key424] = _val425
3956 chandransh 19485 
          iprot.readMapEnd()
19486 
        else:
19487 
          iprot.skip(ftype)
19488 
      elif fid == 1:
19489 
        if ftype == TType.STRUCT:
19490 
          self.ex = TransactionServiceException()
19491 
          self.ex.read(iprot)
19492 
        else:
19493 
          iprot.skip(ftype)
19494 
      else:
19495 
        iprot.skip(ftype)
19496 
      iprot.readFieldEnd()
19497 
    iprot.readStructEnd()
19498 
 
19499 
  def write(self, oprot):
19500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19502 
      return
19503 
    oprot.writeStructBegin('reconcileCodCollection_result')
19504 
    if self.success is not None:
19505 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19506 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19507 
      for kiter426,viter427 in self.success.items():
19508 
        oprot.writeString(kiter426)
19509 
        oprot.writeString(viter427)
3956 chandransh 19510 
      oprot.writeMapEnd()
19511 
      oprot.writeFieldEnd()
19512 
    if self.ex is not None:
19513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19514 
      self.ex.write(oprot)
19515 
      oprot.writeFieldEnd()
19516 
    oprot.writeFieldStop()
19517 
    oprot.writeStructEnd()
19518 
 
19519 
  def validate(self):
19520 
    return
19521 
 
19522 
 
19523 
  def __repr__(self):
19524 
    L = ['%s=%r' % (key, value)
19525 
      for key, value in self.__dict__.iteritems()]
19526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19527 
 
19528 
  def __eq__(self, other):
19529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19530 
 
19531 
  def __ne__(self, other):
19532 
    return not (self == other)
4008 mandeep.dh 19533 
 
19534 
class getTransactionsRequiringExtraProcessing_args:
19535 
  """
19536 
  Attributes:
19537 
   - category
19538 
  """
19539 
 
19540 
  thrift_spec = (
19541 
    None, # 0
19542 
    (1, TType.I32, 'category', None, None, ), # 1
19543 
  )
19544 
 
19545 
  def __init__(self, category=None,):
19546 
    self.category = category
19547 
 
19548 
  def read(self, iprot):
19549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19551 
      return
19552 
    iprot.readStructBegin()
19553 
    while True:
19554 
      (fname, ftype, fid) = iprot.readFieldBegin()
19555 
      if ftype == TType.STOP:
19556 
        break
19557 
      if fid == 1:
19558 
        if ftype == TType.I32:
19559 
          self.category = iprot.readI32();
19560 
        else:
19561 
          iprot.skip(ftype)
19562 
      else:
19563 
        iprot.skip(ftype)
19564 
      iprot.readFieldEnd()
19565 
    iprot.readStructEnd()
19566 
 
19567 
  def write(self, oprot):
19568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19570 
      return
19571 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19572 
    if self.category is not None:
19573 
      oprot.writeFieldBegin('category', TType.I32, 1)
19574 
      oprot.writeI32(self.category)
19575 
      oprot.writeFieldEnd()
19576 
    oprot.writeFieldStop()
19577 
    oprot.writeStructEnd()
19578 
 
19579 
  def validate(self):
19580 
    return
19581 
 
19582 
 
19583 
  def __repr__(self):
19584 
    L = ['%s=%r' % (key, value)
19585 
      for key, value in self.__dict__.iteritems()]
19586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19587 
 
19588 
  def __eq__(self, other):
19589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19590 
 
19591 
  def __ne__(self, other):
19592 
    return not (self == other)
19593 
 
19594 
class getTransactionsRequiringExtraProcessing_result:
19595 
  """
19596 
  Attributes:
19597 
   - success
19598 
  """
19599 
 
19600 
  thrift_spec = (
19601 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19602 
  )
19603 
 
19604 
  def __init__(self, success=None,):
19605 
    self.success = success
19606 
 
19607 
  def read(self, iprot):
19608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19610 
      return
19611 
    iprot.readStructBegin()
19612 
    while True:
19613 
      (fname, ftype, fid) = iprot.readFieldBegin()
19614 
      if ftype == TType.STOP:
19615 
        break
19616 
      if fid == 0:
19617 
        if ftype == TType.LIST:
19618 
          self.success = []
6031 rajveer 19619 
          (_etype431, _size428) = iprot.readListBegin()
19620 
          for _i432 in xrange(_size428):
19621 
            _elem433 = iprot.readI64();
19622 
            self.success.append(_elem433)
4008 mandeep.dh 19623 
          iprot.readListEnd()
19624 
        else:
19625 
          iprot.skip(ftype)
19626 
      else:
19627 
        iprot.skip(ftype)
19628 
      iprot.readFieldEnd()
19629 
    iprot.readStructEnd()
19630 
 
19631 
  def write(self, oprot):
19632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19634 
      return
19635 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19636 
    if self.success is not None:
19637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19638 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19639 
      for iter434 in self.success:
19640 
        oprot.writeI64(iter434)
4008 mandeep.dh 19641 
      oprot.writeListEnd()
19642 
      oprot.writeFieldEnd()
19643 
    oprot.writeFieldStop()
19644 
    oprot.writeStructEnd()
19645 
 
19646 
  def validate(self):
19647 
    return
19648 
 
19649 
 
19650 
  def __repr__(self):
19651 
    L = ['%s=%r' % (key, value)
19652 
      for key, value in self.__dict__.iteritems()]
19653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19654 
 
19655 
  def __eq__(self, other):
19656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19657 
 
19658 
  def __ne__(self, other):
19659 
    return not (self == other)
19660 
 
19661 
class markTransactionAsProcessed_args:
19662 
  """
19663 
  Attributes:
19664 
   - transactionId
19665 
   - category
19666 
  """
19667 
 
19668 
  thrift_spec = (
19669 
    None, # 0
19670 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19671 
    (2, TType.I32, 'category', None, None, ), # 2
19672 
  )
19673 
 
19674 
  def __init__(self, transactionId=None, category=None,):
19675 
    self.transactionId = transactionId
19676 
    self.category = category
19677 
 
19678 
  def read(self, iprot):
19679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19681 
      return
19682 
    iprot.readStructBegin()
19683 
    while True:
19684 
      (fname, ftype, fid) = iprot.readFieldBegin()
19685 
      if ftype == TType.STOP:
19686 
        break
19687 
      if fid == 1:
19688 
        if ftype == TType.I64:
19689 
          self.transactionId = iprot.readI64();
19690 
        else:
19691 
          iprot.skip(ftype)
19692 
      elif fid == 2:
19693 
        if ftype == TType.I32:
19694 
          self.category = iprot.readI32();
19695 
        else:
19696 
          iprot.skip(ftype)
19697 
      else:
19698 
        iprot.skip(ftype)
19699 
      iprot.readFieldEnd()
19700 
    iprot.readStructEnd()
19701 
 
19702 
  def write(self, oprot):
19703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19705 
      return
19706 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19707 
    if self.transactionId is not None:
19708 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19709 
      oprot.writeI64(self.transactionId)
19710 
      oprot.writeFieldEnd()
19711 
    if self.category is not None:
19712 
      oprot.writeFieldBegin('category', TType.I32, 2)
19713 
      oprot.writeI32(self.category)
19714 
      oprot.writeFieldEnd()
19715 
    oprot.writeFieldStop()
19716 
    oprot.writeStructEnd()
19717 
 
19718 
  def validate(self):
19719 
    return
19720 
 
19721 
 
19722 
  def __repr__(self):
19723 
    L = ['%s=%r' % (key, value)
19724 
      for key, value in self.__dict__.iteritems()]
19725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19726 
 
19727 
  def __eq__(self, other):
19728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19729 
 
19730 
  def __ne__(self, other):
19731 
    return not (self == other)
19732 
 
19733 
class markTransactionAsProcessed_result:
19734 
 
19735 
  thrift_spec = (
19736 
  )
19737 
 
19738 
  def read(self, iprot):
19739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19741 
      return
19742 
    iprot.readStructBegin()
19743 
    while True:
19744 
      (fname, ftype, fid) = iprot.readFieldBegin()
19745 
      if ftype == TType.STOP:
19746 
        break
19747 
      else:
19748 
        iprot.skip(ftype)
19749 
      iprot.readFieldEnd()
19750 
    iprot.readStructEnd()
19751 
 
19752 
  def write(self, oprot):
19753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19755 
      return
19756 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19757 
    oprot.writeFieldStop()
19758 
    oprot.writeStructEnd()
19759 
 
19760 
  def validate(self):
19761 
    return
19762 
 
19763 
 
19764 
  def __repr__(self):
19765 
    L = ['%s=%r' % (key, value)
19766 
      for key, value in self.__dict__.iteritems()]
19767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19768 
 
19769 
  def __eq__(self, other):
19770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19771 
 
19772 
  def __ne__(self, other):
19773 
    return not (self == other)
4018 chandransh 19774 
 
19775 
class getItemWiseRiskyOrdersCount_args:
19776 
 
19777 
  thrift_spec = (
19778 
  )
19779 
 
19780 
  def read(self, iprot):
19781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19783 
      return
19784 
    iprot.readStructBegin()
19785 
    while True:
19786 
      (fname, ftype, fid) = iprot.readFieldBegin()
19787 
      if ftype == TType.STOP:
19788 
        break
19789 
      else:
19790 
        iprot.skip(ftype)
19791 
      iprot.readFieldEnd()
19792 
    iprot.readStructEnd()
19793 
 
19794 
  def write(self, oprot):
19795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19797 
      return
19798 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19799 
    oprot.writeFieldStop()
19800 
    oprot.writeStructEnd()
19801 
 
19802 
  def validate(self):
19803 
    return
19804 
 
19805 
 
19806 
  def __repr__(self):
19807 
    L = ['%s=%r' % (key, value)
19808 
      for key, value in self.__dict__.iteritems()]
19809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19810 
 
19811 
  def __eq__(self, other):
19812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19813 
 
19814 
  def __ne__(self, other):
19815 
    return not (self == other)
19816 
 
19817 
class getItemWiseRiskyOrdersCount_result:
19818 
  """
19819 
  Attributes:
19820 
   - success
19821 
  """
19822 
 
19823 
  thrift_spec = (
19824 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19825 
  )
19826 
 
19827 
  def __init__(self, success=None,):
19828 
    self.success = success
19829 
 
19830 
  def read(self, iprot):
19831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19833 
      return
19834 
    iprot.readStructBegin()
19835 
    while True:
19836 
      (fname, ftype, fid) = iprot.readFieldBegin()
19837 
      if ftype == TType.STOP:
19838 
        break
19839 
      if fid == 0:
19840 
        if ftype == TType.MAP:
19841 
          self.success = {}
6031 rajveer 19842 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19843 
          for _i439 in xrange(_size435):
19844 
            _key440 = iprot.readI64();
19845 
            _val441 = iprot.readI64();
19846 
            self.success[_key440] = _val441
4018 chandransh 19847 
          iprot.readMapEnd()
19848 
        else:
19849 
          iprot.skip(ftype)
19850 
      else:
19851 
        iprot.skip(ftype)
19852 
      iprot.readFieldEnd()
19853 
    iprot.readStructEnd()
19854 
 
19855 
  def write(self, oprot):
19856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19858 
      return
19859 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19860 
    if self.success is not None:
19861 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19862 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19863 
      for kiter442,viter443 in self.success.items():
19864 
        oprot.writeI64(kiter442)
19865 
        oprot.writeI64(viter443)
4018 chandransh 19866 
      oprot.writeMapEnd()
19867 
      oprot.writeFieldEnd()
19868 
    oprot.writeFieldStop()
19869 
    oprot.writeStructEnd()
19870 
 
19871 
  def validate(self):
19872 
    return
19873 
 
19874 
 
19875 
  def __repr__(self):
19876 
    L = ['%s=%r' % (key, value)
19877 
      for key, value in self.__dict__.iteritems()]
19878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19879 
 
19880 
  def __eq__(self, other):
19881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19882 
 
19883 
  def __ne__(self, other):
19884 
    return not (self == other)
4247 rajveer 19885 
 
4295 varun.gupt 19886 
class getOrdersForItemIds_args:
19887 
  """
19888 
  Attributes:
19889 
   - itemIds
19890 
  """
19891 
 
19892 
  thrift_spec = (
19893 
    None, # 0
19894 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19895 
  )
19896 
 
19897 
  def __init__(self, itemIds=None,):
19898 
    self.itemIds = itemIds
19899 
 
19900 
  def read(self, iprot):
19901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19903 
      return
19904 
    iprot.readStructBegin()
19905 
    while True:
19906 
      (fname, ftype, fid) = iprot.readFieldBegin()
19907 
      if ftype == TType.STOP:
19908 
        break
19909 
      if fid == 1:
19910 
        if ftype == TType.LIST:
19911 
          self.itemIds = []
6031 rajveer 19912 
          (_etype447, _size444) = iprot.readListBegin()
19913 
          for _i448 in xrange(_size444):
19914 
            _elem449 = iprot.readI64();
19915 
            self.itemIds.append(_elem449)
4295 varun.gupt 19916 
          iprot.readListEnd()
19917 
        else:
19918 
          iprot.skip(ftype)
19919 
      else:
19920 
        iprot.skip(ftype)
19921 
      iprot.readFieldEnd()
19922 
    iprot.readStructEnd()
19923 
 
19924 
  def write(self, oprot):
19925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19927 
      return
19928 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19929 
    if self.itemIds is not None:
19930 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19931 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19932 
      for iter450 in self.itemIds:
19933 
        oprot.writeI64(iter450)
4295 varun.gupt 19934 
      oprot.writeListEnd()
19935 
      oprot.writeFieldEnd()
19936 
    oprot.writeFieldStop()
19937 
    oprot.writeStructEnd()
19938 
 
19939 
  def validate(self):
19940 
    return
19941 
 
19942 
 
19943 
  def __repr__(self):
19944 
    L = ['%s=%r' % (key, value)
19945 
      for key, value in self.__dict__.iteritems()]
19946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19947 
 
19948 
  def __eq__(self, other):
19949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19950 
 
19951 
  def __ne__(self, other):
19952 
    return not (self == other)
19953 
 
19954 
class getOrdersForItemIds_result:
19955 
  """
19956 
  Attributes:
19957 
   - success
19958 
  """
19959 
 
19960 
  thrift_spec = (
19961 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19962 
  )
19963 
 
19964 
  def __init__(self, success=None,):
19965 
    self.success = success
19966 
 
19967 
  def read(self, iprot):
19968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19970 
      return
19971 
    iprot.readStructBegin()
19972 
    while True:
19973 
      (fname, ftype, fid) = iprot.readFieldBegin()
19974 
      if ftype == TType.STOP:
19975 
        break
19976 
      if fid == 0:
19977 
        if ftype == TType.LIST:
19978 
          self.success = []
6031 rajveer 19979 
          (_etype454, _size451) = iprot.readListBegin()
19980 
          for _i455 in xrange(_size451):
19981 
            _elem456 = Order()
19982 
            _elem456.read(iprot)
19983 
            self.success.append(_elem456)
4295 varun.gupt 19984 
          iprot.readListEnd()
19985 
        else:
19986 
          iprot.skip(ftype)
19987 
      else:
19988 
        iprot.skip(ftype)
19989 
      iprot.readFieldEnd()
19990 
    iprot.readStructEnd()
19991 
 
19992 
  def write(self, oprot):
19993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19995 
      return
19996 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19997 
    if self.success is not None:
19998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 20000 
      for iter457 in self.success:
20001 
        iter457.write(oprot)
4295 varun.gupt 20002 
      oprot.writeListEnd()
20003 
      oprot.writeFieldEnd()
20004 
    oprot.writeFieldStop()
20005 
    oprot.writeStructEnd()
20006 
 
20007 
  def validate(self):
20008 
    return
20009 
 
20010 
 
20011 
  def __repr__(self):
20012 
    L = ['%s=%r' % (key, value)
20013 
      for key, value in self.__dict__.iteritems()]
20014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20015 
 
20016 
  def __eq__(self, other):
20017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20018 
 
20019 
  def __ne__(self, other):
20020 
    return not (self == other)
20021 
 
4247 rajveer 20022 
class markOrderCancellationRequestReceived_args:
20023 
  """
20024 
  Attributes:
20025 
   - orderId
20026 
  """
20027 
 
20028 
  thrift_spec = (
20029 
    None, # 0
20030 
    (1, TType.I64, 'orderId', None, None, ), # 1
20031 
  )
20032 
 
20033 
  def __init__(self, orderId=None,):
20034 
    self.orderId = orderId
20035 
 
20036 
  def read(self, iprot):
20037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20039 
      return
20040 
    iprot.readStructBegin()
20041 
    while True:
20042 
      (fname, ftype, fid) = iprot.readFieldBegin()
20043 
      if ftype == TType.STOP:
20044 
        break
20045 
      if fid == 1:
20046 
        if ftype == TType.I64:
20047 
          self.orderId = iprot.readI64();
20048 
        else:
20049 
          iprot.skip(ftype)
20050 
      else:
20051 
        iprot.skip(ftype)
20052 
      iprot.readFieldEnd()
20053 
    iprot.readStructEnd()
20054 
 
20055 
  def write(self, oprot):
20056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20058 
      return
20059 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20060 
    if self.orderId is not None:
20061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20062 
      oprot.writeI64(self.orderId)
20063 
      oprot.writeFieldEnd()
20064 
    oprot.writeFieldStop()
20065 
    oprot.writeStructEnd()
20066 
 
20067 
  def validate(self):
20068 
    return
20069 
 
20070 
 
20071 
  def __repr__(self):
20072 
    L = ['%s=%r' % (key, value)
20073 
      for key, value in self.__dict__.iteritems()]
20074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20075 
 
20076 
  def __eq__(self, other):
20077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20078 
 
20079 
  def __ne__(self, other):
20080 
    return not (self == other)
20081 
 
20082 
class markOrderCancellationRequestReceived_result:
20083 
  """
20084 
  Attributes:
20085 
   - ex
20086 
  """
20087 
 
20088 
  thrift_spec = (
20089 
    None, # 0
20090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20091 
  )
20092 
 
20093 
  def __init__(self, ex=None,):
20094 
    self.ex = ex
20095 
 
20096 
  def read(self, iprot):
20097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20099 
      return
20100 
    iprot.readStructBegin()
20101 
    while True:
20102 
      (fname, ftype, fid) = iprot.readFieldBegin()
20103 
      if ftype == TType.STOP:
20104 
        break
20105 
      if fid == 1:
20106 
        if ftype == TType.STRUCT:
20107 
          self.ex = TransactionServiceException()
20108 
          self.ex.read(iprot)
20109 
        else:
20110 
          iprot.skip(ftype)
20111 
      else:
20112 
        iprot.skip(ftype)
20113 
      iprot.readFieldEnd()
20114 
    iprot.readStructEnd()
20115 
 
20116 
  def write(self, oprot):
20117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20119 
      return
20120 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20121 
    if self.ex is not None:
20122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20123 
      self.ex.write(oprot)
20124 
      oprot.writeFieldEnd()
20125 
    oprot.writeFieldStop()
20126 
    oprot.writeStructEnd()
20127 
 
20128 
  def validate(self):
20129 
    return
20130 
 
20131 
 
20132 
  def __repr__(self):
20133 
    L = ['%s=%r' % (key, value)
20134 
      for key, value in self.__dict__.iteritems()]
20135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20136 
 
20137 
  def __eq__(self, other):
20138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20139 
 
20140 
  def __ne__(self, other):
20141 
    return not (self == other)
20142 
 
20143 
class markOrderCancellationRequestConfirmed_args:
20144 
  """
20145 
  Attributes:
20146 
   - orderId
20147 
  """
20148 
 
20149 
  thrift_spec = (
20150 
    None, # 0
20151 
    (1, TType.I64, 'orderId', None, None, ), # 1
20152 
  )
20153 
 
20154 
  def __init__(self, orderId=None,):
20155 
    self.orderId = orderId
20156 
 
20157 
  def read(self, iprot):
20158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20160 
      return
20161 
    iprot.readStructBegin()
20162 
    while True:
20163 
      (fname, ftype, fid) = iprot.readFieldBegin()
20164 
      if ftype == TType.STOP:
20165 
        break
20166 
      if fid == 1:
20167 
        if ftype == TType.I64:
20168 
          self.orderId = iprot.readI64();
20169 
        else:
20170 
          iprot.skip(ftype)
20171 
      else:
20172 
        iprot.skip(ftype)
20173 
      iprot.readFieldEnd()
20174 
    iprot.readStructEnd()
20175 
 
20176 
  def write(self, oprot):
20177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20179 
      return
20180 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20181 
    if self.orderId is not None:
20182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20183 
      oprot.writeI64(self.orderId)
20184 
      oprot.writeFieldEnd()
20185 
    oprot.writeFieldStop()
20186 
    oprot.writeStructEnd()
20187 
 
20188 
  def validate(self):
20189 
    return
20190 
 
20191 
 
20192 
  def __repr__(self):
20193 
    L = ['%s=%r' % (key, value)
20194 
      for key, value in self.__dict__.iteritems()]
20195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20196 
 
20197 
  def __eq__(self, other):
20198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20199 
 
20200 
  def __ne__(self, other):
20201 
    return not (self == other)
20202 
 
20203 
class markOrderCancellationRequestConfirmed_result:
20204 
  """
20205 
  Attributes:
20206 
   - ex
20207 
  """
20208 
 
20209 
  thrift_spec = (
20210 
    None, # 0
20211 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20212 
  )
20213 
 
20214 
  def __init__(self, ex=None,):
20215 
    self.ex = ex
20216 
 
20217 
  def read(self, iprot):
20218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20220 
      return
20221 
    iprot.readStructBegin()
20222 
    while True:
20223 
      (fname, ftype, fid) = iprot.readFieldBegin()
20224 
      if ftype == TType.STOP:
20225 
        break
20226 
      if fid == 1:
20227 
        if ftype == TType.STRUCT:
20228 
          self.ex = TransactionServiceException()
20229 
          self.ex.read(iprot)
20230 
        else:
20231 
          iprot.skip(ftype)
20232 
      else:
20233 
        iprot.skip(ftype)
20234 
      iprot.readFieldEnd()
20235 
    iprot.readStructEnd()
20236 
 
20237 
  def write(self, oprot):
20238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20240 
      return
20241 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20242 
    if self.ex is not None:
20243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20244 
      self.ex.write(oprot)
20245 
      oprot.writeFieldEnd()
20246 
    oprot.writeFieldStop()
20247 
    oprot.writeStructEnd()
20248 
 
20249 
  def validate(self):
20250 
    return
20251 
 
20252 
 
20253 
  def __repr__(self):
20254 
    L = ['%s=%r' % (key, value)
20255 
      for key, value in self.__dict__.iteritems()]
20256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20257 
 
20258 
  def __eq__(self, other):
20259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20260 
 
20261 
  def __ne__(self, other):
20262 
    return not (self == other)
20263 
 
20264 
class markOrderCancellationRequestDenied_args:
20265 
  """
20266 
  Attributes:
20267 
   - orderId
20268 
  """
20269 
 
20270 
  thrift_spec = (
20271 
    None, # 0
20272 
    (1, TType.I64, 'orderId', None, None, ), # 1
20273 
  )
20274 
 
20275 
  def __init__(self, orderId=None,):
20276 
    self.orderId = orderId
20277 
 
20278 
  def read(self, iprot):
20279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20281 
      return
20282 
    iprot.readStructBegin()
20283 
    while True:
20284 
      (fname, ftype, fid) = iprot.readFieldBegin()
20285 
      if ftype == TType.STOP:
20286 
        break
20287 
      if fid == 1:
20288 
        if ftype == TType.I64:
20289 
          self.orderId = iprot.readI64();
20290 
        else:
20291 
          iprot.skip(ftype)
20292 
      else:
20293 
        iprot.skip(ftype)
20294 
      iprot.readFieldEnd()
20295 
    iprot.readStructEnd()
20296 
 
20297 
  def write(self, oprot):
20298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20300 
      return
20301 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20302 
    if self.orderId is not None:
20303 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20304 
      oprot.writeI64(self.orderId)
20305 
      oprot.writeFieldEnd()
20306 
    oprot.writeFieldStop()
20307 
    oprot.writeStructEnd()
20308 
 
20309 
  def validate(self):
20310 
    return
20311 
 
20312 
 
20313 
  def __repr__(self):
20314 
    L = ['%s=%r' % (key, value)
20315 
      for key, value in self.__dict__.iteritems()]
20316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20317 
 
20318 
  def __eq__(self, other):
20319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20320 
 
20321 
  def __ne__(self, other):
20322 
    return not (self == other)
20323 
 
20324 
class markOrderCancellationRequestDenied_result:
20325 
  """
20326 
  Attributes:
20327 
   - ex
20328 
  """
20329 
 
20330 
  thrift_spec = (
20331 
    None, # 0
20332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20333 
  )
20334 
 
20335 
  def __init__(self, ex=None,):
20336 
    self.ex = ex
20337 
 
20338 
  def read(self, iprot):
20339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20341 
      return
20342 
    iprot.readStructBegin()
20343 
    while True:
20344 
      (fname, ftype, fid) = iprot.readFieldBegin()
20345 
      if ftype == TType.STOP:
20346 
        break
20347 
      if fid == 1:
20348 
        if ftype == TType.STRUCT:
20349 
          self.ex = TransactionServiceException()
20350 
          self.ex.read(iprot)
20351 
        else:
20352 
          iprot.skip(ftype)
20353 
      else:
20354 
        iprot.skip(ftype)
20355 
      iprot.readFieldEnd()
20356 
    iprot.readStructEnd()
20357 
 
20358 
  def write(self, oprot):
20359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20361 
      return
20362 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20363 
    if self.ex is not None:
20364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20365 
      self.ex.write(oprot)
20366 
      oprot.writeFieldEnd()
20367 
    oprot.writeFieldStop()
20368 
    oprot.writeStructEnd()
20369 
 
20370 
  def validate(self):
20371 
    return
20372 
 
20373 
 
20374 
  def __repr__(self):
20375 
    L = ['%s=%r' % (key, value)
20376 
      for key, value in self.__dict__.iteritems()]
20377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20378 
 
20379 
  def __eq__(self, other):
20380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20381 
 
20382 
  def __ne__(self, other):
20383 
    return not (self == other)
20384 
 
4258 rajveer 20385 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20386 
  """
20387 
  Attributes:
4258 rajveer 20388 
   - transactionId
4247 rajveer 20389 
  """
20390 
 
20391 
  thrift_spec = (
20392 
    None, # 0
4258 rajveer 20393 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20394 
  )
20395 
 
4258 rajveer 20396 
  def __init__(self, transactionId=None,):
20397 
    self.transactionId = transactionId
4247 rajveer 20398 
 
20399 
  def read(self, iprot):
20400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20402 
      return
20403 
    iprot.readStructBegin()
20404 
    while True:
20405 
      (fname, ftype, fid) = iprot.readFieldBegin()
20406 
      if ftype == TType.STOP:
20407 
        break
20408 
      if fid == 1:
20409 
        if ftype == TType.I64:
4258 rajveer 20410 
          self.transactionId = iprot.readI64();
4247 rajveer 20411 
        else:
20412 
          iprot.skip(ftype)
20413 
      else:
20414 
        iprot.skip(ftype)
20415 
      iprot.readFieldEnd()
20416 
    iprot.readStructEnd()
20417 
 
20418 
  def write(self, oprot):
20419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20421 
      return
4258 rajveer 20422 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20423 
    if self.transactionId is not None:
20424 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20425 
      oprot.writeI64(self.transactionId)
4247 rajveer 20426 
      oprot.writeFieldEnd()
20427 
    oprot.writeFieldStop()
20428 
    oprot.writeStructEnd()
20429 
 
20430 
  def validate(self):
20431 
    return
20432 
 
20433 
 
20434 
  def __repr__(self):
20435 
    L = ['%s=%r' % (key, value)
20436 
      for key, value in self.__dict__.iteritems()]
20437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20438 
 
20439 
  def __eq__(self, other):
20440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20441 
 
20442 
  def __ne__(self, other):
20443 
    return not (self == other)
20444 
 
4258 rajveer 20445 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20446 
  """
20447 
  Attributes:
20448 
   - ex
20449 
  """
20450 
 
20451 
  thrift_spec = (
20452 
    None, # 0
20453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20454 
  )
20455 
 
20456 
  def __init__(self, ex=None,):
20457 
    self.ex = ex
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 1:
20469 
        if ftype == TType.STRUCT:
20470 
          self.ex = TransactionServiceException()
20471 
          self.ex.read(iprot)
20472 
        else:
20473 
          iprot.skip(ftype)
20474 
      else:
20475 
        iprot.skip(ftype)
20476 
      iprot.readFieldEnd()
20477 
    iprot.readStructEnd()
20478 
 
20479 
  def write(self, oprot):
20480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20482 
      return
4258 rajveer 20483 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20484 
    if self.ex is not None:
20485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20486 
      self.ex.write(oprot)
20487 
      oprot.writeFieldEnd()
20488 
    oprot.writeFieldStop()
20489 
    oprot.writeStructEnd()
20490 
 
20491 
  def validate(self):
20492 
    return
20493 
 
20494 
 
20495 
  def __repr__(self):
20496 
    L = ['%s=%r' % (key, value)
20497 
      for key, value in self.__dict__.iteritems()]
20498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20499 
 
20500 
  def __eq__(self, other):
20501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20502 
 
20503 
  def __ne__(self, other):
20504 
    return not (self == other)
4259 anupam.sin 20505 
 
20506 
class refundTransaction_args:
20507 
  """
20508 
  Attributes:
20509 
   - transactionId
20510 
   - refundedBy
20511 
   - reason
20512 
  """
20513 
 
20514 
  thrift_spec = (
20515 
    None, # 0
20516 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20517 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20518 
    (3, TType.STRING, 'reason', None, None, ), # 3
20519 
  )
20520 
 
20521 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20522 
    self.transactionId = transactionId
20523 
    self.refundedBy = refundedBy
20524 
    self.reason = reason
20525 
 
20526 
  def read(self, iprot):
20527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20529 
      return
20530 
    iprot.readStructBegin()
20531 
    while True:
20532 
      (fname, ftype, fid) = iprot.readFieldBegin()
20533 
      if ftype == TType.STOP:
20534 
        break
20535 
      if fid == 1:
20536 
        if ftype == TType.I64:
20537 
          self.transactionId = iprot.readI64();
20538 
        else:
20539 
          iprot.skip(ftype)
20540 
      elif fid == 2:
20541 
        if ftype == TType.STRING:
20542 
          self.refundedBy = iprot.readString();
20543 
        else:
20544 
          iprot.skip(ftype)
20545 
      elif fid == 3:
20546 
        if ftype == TType.STRING:
20547 
          self.reason = iprot.readString();
20548 
        else:
20549 
          iprot.skip(ftype)
20550 
      else:
20551 
        iprot.skip(ftype)
20552 
      iprot.readFieldEnd()
20553 
    iprot.readStructEnd()
20554 
 
20555 
  def write(self, oprot):
20556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20558 
      return
20559 
    oprot.writeStructBegin('refundTransaction_args')
20560 
    if self.transactionId is not None:
20561 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20562 
      oprot.writeI64(self.transactionId)
20563 
      oprot.writeFieldEnd()
20564 
    if self.refundedBy is not None:
20565 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20566 
      oprot.writeString(self.refundedBy)
20567 
      oprot.writeFieldEnd()
20568 
    if self.reason is not None:
20569 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20570 
      oprot.writeString(self.reason)
20571 
      oprot.writeFieldEnd()
20572 
    oprot.writeFieldStop()
20573 
    oprot.writeStructEnd()
20574 
 
20575 
  def validate(self):
20576 
    return
20577 
 
20578 
 
20579 
  def __repr__(self):
20580 
    L = ['%s=%r' % (key, value)
20581 
      for key, value in self.__dict__.iteritems()]
20582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20583 
 
20584 
  def __eq__(self, other):
20585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20586 
 
20587 
  def __ne__(self, other):
20588 
    return not (self == other)
20589 
 
20590 
class refundTransaction_result:
20591 
  """
20592 
  Attributes:
20593 
   - ex
20594 
  """
20595 
 
20596 
  thrift_spec = (
20597 
    None, # 0
20598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20599 
  )
20600 
 
20601 
  def __init__(self, ex=None,):
20602 
    self.ex = ex
20603 
 
20604 
  def read(self, iprot):
20605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20607 
      return
20608 
    iprot.readStructBegin()
20609 
    while True:
20610 
      (fname, ftype, fid) = iprot.readFieldBegin()
20611 
      if ftype == TType.STOP:
20612 
        break
20613 
      if fid == 1:
20614 
        if ftype == TType.STRUCT:
20615 
          self.ex = TransactionServiceException()
20616 
          self.ex.read(iprot)
20617 
        else:
20618 
          iprot.skip(ftype)
20619 
      else:
20620 
        iprot.skip(ftype)
20621 
      iprot.readFieldEnd()
20622 
    iprot.readStructEnd()
20623 
 
20624 
  def write(self, oprot):
20625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20627 
      return
20628 
    oprot.writeStructBegin('refundTransaction_result')
20629 
    if self.ex is not None:
20630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20631 
      self.ex.write(oprot)
20632 
      oprot.writeFieldEnd()
20633 
    oprot.writeFieldStop()
20634 
    oprot.writeStructEnd()
20635 
 
20636 
  def validate(self):
20637 
    return
20638 
 
20639 
 
20640 
  def __repr__(self):
20641 
    L = ['%s=%r' % (key, value)
20642 
      for key, value in self.__dict__.iteritems()]
20643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20644 
 
20645 
  def __eq__(self, other):
20646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20647 
 
20648 
  def __ne__(self, other):
20649 
    return not (self == other)
4285 rajveer 20650 
 
4324 mandeep.dh 20651 
class updateShipmentAddress_args:
20652 
  """
20653 
  Attributes:
20654 
   - orderId
20655 
   - addressId
20656 
  """
20657 
 
20658 
  thrift_spec = (
20659 
    None, # 0
20660 
    (1, TType.I64, 'orderId', None, None, ), # 1
20661 
    (2, TType.I64, 'addressId', None, None, ), # 2
20662 
  )
20663 
 
20664 
  def __init__(self, orderId=None, addressId=None,):
20665 
    self.orderId = orderId
20666 
    self.addressId = addressId
20667 
 
20668 
  def read(self, iprot):
20669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20671 
      return
20672 
    iprot.readStructBegin()
20673 
    while True:
20674 
      (fname, ftype, fid) = iprot.readFieldBegin()
20675 
      if ftype == TType.STOP:
20676 
        break
20677 
      if fid == 1:
20678 
        if ftype == TType.I64:
20679 
          self.orderId = iprot.readI64();
20680 
        else:
20681 
          iprot.skip(ftype)
20682 
      elif fid == 2:
20683 
        if ftype == TType.I64:
20684 
          self.addressId = iprot.readI64();
20685 
        else:
20686 
          iprot.skip(ftype)
20687 
      else:
20688 
        iprot.skip(ftype)
20689 
      iprot.readFieldEnd()
20690 
    iprot.readStructEnd()
20691 
 
20692 
  def write(self, oprot):
20693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20695 
      return
20696 
    oprot.writeStructBegin('updateShipmentAddress_args')
20697 
    if self.orderId is not None:
20698 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20699 
      oprot.writeI64(self.orderId)
20700 
      oprot.writeFieldEnd()
20701 
    if self.addressId is not None:
20702 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20703 
      oprot.writeI64(self.addressId)
20704 
      oprot.writeFieldEnd()
20705 
    oprot.writeFieldStop()
20706 
    oprot.writeStructEnd()
20707 
 
20708 
  def validate(self):
20709 
    return
20710 
 
20711 
 
20712 
  def __repr__(self):
20713 
    L = ['%s=%r' % (key, value)
20714 
      for key, value in self.__dict__.iteritems()]
20715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20716 
 
20717 
  def __eq__(self, other):
20718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20719 
 
20720 
  def __ne__(self, other):
20721 
    return not (self == other)
20722 
 
20723 
class updateShipmentAddress_result:
20724 
  """
20725 
  Attributes:
20726 
   - ex
20727 
  """
20728 
 
20729 
  thrift_spec = (
20730 
    None, # 0
20731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20732 
  )
20733 
 
20734 
  def __init__(self, ex=None,):
20735 
    self.ex = ex
20736 
 
20737 
  def read(self, iprot):
20738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20740 
      return
20741 
    iprot.readStructBegin()
20742 
    while True:
20743 
      (fname, ftype, fid) = iprot.readFieldBegin()
20744 
      if ftype == TType.STOP:
20745 
        break
20746 
      if fid == 1:
20747 
        if ftype == TType.STRUCT:
20748 
          self.ex = TransactionServiceException()
20749 
          self.ex.read(iprot)
20750 
        else:
20751 
          iprot.skip(ftype)
20752 
      else:
20753 
        iprot.skip(ftype)
20754 
      iprot.readFieldEnd()
20755 
    iprot.readStructEnd()
20756 
 
20757 
  def write(self, oprot):
20758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20760 
      return
20761 
    oprot.writeStructBegin('updateShipmentAddress_result')
20762 
    if self.ex is not None:
20763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20764 
      self.ex.write(oprot)
20765 
      oprot.writeFieldEnd()
20766 
    oprot.writeFieldStop()
20767 
    oprot.writeStructEnd()
20768 
 
20769 
  def validate(self):
20770 
    return
20771 
 
20772 
 
20773 
  def __repr__(self):
20774 
    L = ['%s=%r' % (key, value)
20775 
      for key, value in self.__dict__.iteritems()]
20776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20777 
 
20778 
  def __eq__(self, other):
20779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20780 
 
20781 
  def __ne__(self, other):
20782 
    return not (self == other)
20783 
 
4285 rajveer 20784 
class acceptOrdersForItemId_args:
20785 
  """
20786 
  Attributes:
20787 
   - itemId
20788 
   - inventory
20789 
  """
20790 
 
20791 
  thrift_spec = (
20792 
    None, # 0
20793 
    (1, TType.I64, 'itemId', None, None, ), # 1
20794 
    (2, TType.I64, 'inventory', None, None, ), # 2
20795 
  )
20796 
 
20797 
  def __init__(self, itemId=None, inventory=None,):
20798 
    self.itemId = itemId
20799 
    self.inventory = inventory
20800 
 
20801 
  def read(self, iprot):
20802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20804 
      return
20805 
    iprot.readStructBegin()
20806 
    while True:
20807 
      (fname, ftype, fid) = iprot.readFieldBegin()
20808 
      if ftype == TType.STOP:
20809 
        break
20810 
      if fid == 1:
20811 
        if ftype == TType.I64:
20812 
          self.itemId = iprot.readI64();
20813 
        else:
20814 
          iprot.skip(ftype)
20815 
      elif fid == 2:
20816 
        if ftype == TType.I64:
20817 
          self.inventory = iprot.readI64();
20818 
        else:
20819 
          iprot.skip(ftype)
20820 
      else:
20821 
        iprot.skip(ftype)
20822 
      iprot.readFieldEnd()
20823 
    iprot.readStructEnd()
20824 
 
20825 
  def write(self, oprot):
20826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20828 
      return
20829 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20830 
    if self.itemId is not None:
20831 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20832 
      oprot.writeI64(self.itemId)
20833 
      oprot.writeFieldEnd()
20834 
    if self.inventory is not None:
20835 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20836 
      oprot.writeI64(self.inventory)
20837 
      oprot.writeFieldEnd()
20838 
    oprot.writeFieldStop()
20839 
    oprot.writeStructEnd()
20840 
 
20841 
  def validate(self):
20842 
    return
20843 
 
20844 
 
20845 
  def __repr__(self):
20846 
    L = ['%s=%r' % (key, value)
20847 
      for key, value in self.__dict__.iteritems()]
20848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20849 
 
20850 
  def __eq__(self, other):
20851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20852 
 
20853 
  def __ne__(self, other):
20854 
    return not (self == other)
20855 
 
20856 
class acceptOrdersForItemId_result:
20857 
  """
20858 
  Attributes:
20859 
   - success
20860 
   - ex
20861 
  """
20862 
 
20863 
  thrift_spec = (
20864 
    (0, TType.BOOL, 'success', None, None, ), # 0
20865 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20866 
  )
20867 
 
20868 
  def __init__(self, success=None, ex=None,):
20869 
    self.success = success
20870 
    self.ex = ex
20871 
 
20872 
  def read(self, iprot):
20873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20875 
      return
20876 
    iprot.readStructBegin()
20877 
    while True:
20878 
      (fname, ftype, fid) = iprot.readFieldBegin()
20879 
      if ftype == TType.STOP:
20880 
        break
20881 
      if fid == 0:
20882 
        if ftype == TType.BOOL:
20883 
          self.success = iprot.readBool();
20884 
        else:
20885 
          iprot.skip(ftype)
20886 
      elif fid == 1:
20887 
        if ftype == TType.STRUCT:
20888 
          self.ex = TransactionServiceException()
20889 
          self.ex.read(iprot)
20890 
        else:
20891 
          iprot.skip(ftype)
20892 
      else:
20893 
        iprot.skip(ftype)
20894 
      iprot.readFieldEnd()
20895 
    iprot.readStructEnd()
20896 
 
20897 
  def write(self, oprot):
20898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20900 
      return
20901 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20902 
    if self.success is not None:
20903 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20904 
      oprot.writeBool(self.success)
20905 
      oprot.writeFieldEnd()
20906 
    if self.ex is not None:
20907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20908 
      self.ex.write(oprot)
20909 
      oprot.writeFieldEnd()
20910 
    oprot.writeFieldStop()
20911 
    oprot.writeStructEnd()
20912 
 
20913 
  def validate(self):
20914 
    return
20915 
 
20916 
 
20917 
  def __repr__(self):
20918 
    L = ['%s=%r' % (key, value)
20919 
      for key, value in self.__dict__.iteritems()]
20920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20921 
 
20922 
  def __eq__(self, other):
20923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20924 
 
20925 
  def __ne__(self, other):
20926 
    return not (self == other)
4303 rajveer 20927 
 
20928 
class markOrdersAsPORaised_args:
20929 
  """
20930 
  Attributes:
20931 
   - vendorId
20932 
   - itemId
20933 
   - quantity
20934 
   - estimate
4369 rajveer 20935 
   - isReminder
4303 rajveer 20936 
  """
20937 
 
20938 
  thrift_spec = (
20939 
    None, # 0
20940 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20941 
    (2, TType.I64, 'itemId', None, None, ), # 2
20942 
    (3, TType.I64, 'quantity', None, None, ), # 3
20943 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20944 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20945 
  )
20946 
 
4369 rajveer 20947 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20948 
    self.vendorId = vendorId
20949 
    self.itemId = itemId
20950 
    self.quantity = quantity
20951 
    self.estimate = estimate
4369 rajveer 20952 
    self.isReminder = isReminder
4303 rajveer 20953 
 
20954 
  def read(self, iprot):
20955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20957 
      return
20958 
    iprot.readStructBegin()
20959 
    while True:
20960 
      (fname, ftype, fid) = iprot.readFieldBegin()
20961 
      if ftype == TType.STOP:
20962 
        break
20963 
      if fid == 1:
20964 
        if ftype == TType.I64:
20965 
          self.vendorId = iprot.readI64();
20966 
        else:
20967 
          iprot.skip(ftype)
20968 
      elif fid == 2:
20969 
        if ftype == TType.I64:
20970 
          self.itemId = iprot.readI64();
20971 
        else:
20972 
          iprot.skip(ftype)
20973 
      elif fid == 3:
20974 
        if ftype == TType.I64:
20975 
          self.quantity = iprot.readI64();
20976 
        else:
20977 
          iprot.skip(ftype)
20978 
      elif fid == 4:
20979 
        if ftype == TType.I64:
20980 
          self.estimate = iprot.readI64();
20981 
        else:
20982 
          iprot.skip(ftype)
4369 rajveer 20983 
      elif fid == 5:
20984 
        if ftype == TType.BOOL:
20985 
          self.isReminder = iprot.readBool();
20986 
        else:
20987 
          iprot.skip(ftype)
4303 rajveer 20988 
      else:
20989 
        iprot.skip(ftype)
20990 
      iprot.readFieldEnd()
20991 
    iprot.readStructEnd()
20992 
 
20993 
  def write(self, oprot):
20994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20996 
      return
20997 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20998 
    if self.vendorId is not None:
20999 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21000 
      oprot.writeI64(self.vendorId)
21001 
      oprot.writeFieldEnd()
21002 
    if self.itemId is not None:
21003 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21004 
      oprot.writeI64(self.itemId)
21005 
      oprot.writeFieldEnd()
21006 
    if self.quantity is not None:
21007 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21008 
      oprot.writeI64(self.quantity)
21009 
      oprot.writeFieldEnd()
21010 
    if self.estimate is not None:
21011 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21012 
      oprot.writeI64(self.estimate)
21013 
      oprot.writeFieldEnd()
4369 rajveer 21014 
    if self.isReminder is not None:
21015 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21016 
      oprot.writeBool(self.isReminder)
21017 
      oprot.writeFieldEnd()
4303 rajveer 21018 
    oprot.writeFieldStop()
21019 
    oprot.writeStructEnd()
21020 
 
21021 
  def validate(self):
21022 
    return
21023 
 
21024 
 
21025 
  def __repr__(self):
21026 
    L = ['%s=%r' % (key, value)
21027 
      for key, value in self.__dict__.iteritems()]
21028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21029 
 
21030 
  def __eq__(self, other):
21031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21032 
 
21033 
  def __ne__(self, other):
21034 
    return not (self == other)
21035 
 
21036 
class markOrdersAsPORaised_result:
21037 
  """
21038 
  Attributes:
21039 
   - ex
21040 
  """
21041 
 
21042 
  thrift_spec = (
21043 
    None, # 0
21044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21045 
  )
21046 
 
21047 
  def __init__(self, ex=None,):
21048 
    self.ex = ex
21049 
 
21050 
  def read(self, iprot):
21051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21053 
      return
21054 
    iprot.readStructBegin()
21055 
    while True:
21056 
      (fname, ftype, fid) = iprot.readFieldBegin()
21057 
      if ftype == TType.STOP:
21058 
        break
21059 
      if fid == 1:
21060 
        if ftype == TType.STRUCT:
21061 
          self.ex = TransactionServiceException()
21062 
          self.ex.read(iprot)
21063 
        else:
21064 
          iprot.skip(ftype)
21065 
      else:
21066 
        iprot.skip(ftype)
21067 
      iprot.readFieldEnd()
21068 
    iprot.readStructEnd()
21069 
 
21070 
  def write(self, oprot):
21071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21073 
      return
21074 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21075 
    if self.ex is not None:
21076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21077 
      self.ex.write(oprot)
21078 
      oprot.writeFieldEnd()
21079 
    oprot.writeFieldStop()
21080 
    oprot.writeStructEnd()
21081 
 
21082 
  def validate(self):
21083 
    return
21084 
 
21085 
 
21086 
  def __repr__(self):
21087 
    L = ['%s=%r' % (key, value)
21088 
      for key, value in self.__dict__.iteritems()]
21089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21090 
 
21091 
  def __eq__(self, other):
21092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21093 
 
21094 
  def __ne__(self, other):
21095 
    return not (self == other)
21096 
 
21097 
class markOrdersAsReversalInitiated_args:
21098 
  """
21099 
  Attributes:
21100 
   - vendorId
21101 
   - itemId
21102 
   - quantity
21103 
   - estimate
4369 rajveer 21104 
   - isReminder
4303 rajveer 21105 
  """
21106 
 
21107 
  thrift_spec = (
21108 
    None, # 0
21109 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21110 
    (2, TType.I64, 'itemId', None, None, ), # 2
21111 
    (3, TType.I64, 'quantity', None, None, ), # 3
21112 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21113 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21114 
  )
21115 
 
4369 rajveer 21116 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21117 
    self.vendorId = vendorId
21118 
    self.itemId = itemId
21119 
    self.quantity = quantity
21120 
    self.estimate = estimate
4369 rajveer 21121 
    self.isReminder = isReminder
4303 rajveer 21122 
 
21123 
  def read(self, iprot):
21124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21126 
      return
21127 
    iprot.readStructBegin()
21128 
    while True:
21129 
      (fname, ftype, fid) = iprot.readFieldBegin()
21130 
      if ftype == TType.STOP:
21131 
        break
21132 
      if fid == 1:
21133 
        if ftype == TType.I64:
21134 
          self.vendorId = iprot.readI64();
21135 
        else:
21136 
          iprot.skip(ftype)
21137 
      elif fid == 2:
21138 
        if ftype == TType.I64:
21139 
          self.itemId = iprot.readI64();
21140 
        else:
21141 
          iprot.skip(ftype)
21142 
      elif fid == 3:
21143 
        if ftype == TType.I64:
21144 
          self.quantity = iprot.readI64();
21145 
        else:
21146 
          iprot.skip(ftype)
21147 
      elif fid == 4:
21148 
        if ftype == TType.I64:
21149 
          self.estimate = iprot.readI64();
21150 
        else:
21151 
          iprot.skip(ftype)
4369 rajveer 21152 
      elif fid == 5:
21153 
        if ftype == TType.BOOL:
21154 
          self.isReminder = iprot.readBool();
21155 
        else:
21156 
          iprot.skip(ftype)
4303 rajveer 21157 
      else:
21158 
        iprot.skip(ftype)
21159 
      iprot.readFieldEnd()
21160 
    iprot.readStructEnd()
21161 
 
21162 
  def write(self, oprot):
21163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21165 
      return
21166 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21167 
    if self.vendorId is not None:
21168 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21169 
      oprot.writeI64(self.vendorId)
21170 
      oprot.writeFieldEnd()
21171 
    if self.itemId is not None:
21172 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21173 
      oprot.writeI64(self.itemId)
21174 
      oprot.writeFieldEnd()
21175 
    if self.quantity is not None:
21176 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21177 
      oprot.writeI64(self.quantity)
21178 
      oprot.writeFieldEnd()
21179 
    if self.estimate is not None:
21180 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21181 
      oprot.writeI64(self.estimate)
21182 
      oprot.writeFieldEnd()
4369 rajveer 21183 
    if self.isReminder is not None:
21184 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21185 
      oprot.writeBool(self.isReminder)
21186 
      oprot.writeFieldEnd()
4303 rajveer 21187 
    oprot.writeFieldStop()
21188 
    oprot.writeStructEnd()
21189 
 
21190 
  def validate(self):
21191 
    return
21192 
 
21193 
 
21194 
  def __repr__(self):
21195 
    L = ['%s=%r' % (key, value)
21196 
      for key, value in self.__dict__.iteritems()]
21197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21198 
 
21199 
  def __eq__(self, other):
21200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21201 
 
21202 
  def __ne__(self, other):
21203 
    return not (self == other)
21204 
 
21205 
class markOrdersAsReversalInitiated_result:
21206 
  """
21207 
  Attributes:
21208 
   - ex
21209 
  """
21210 
 
21211 
  thrift_spec = (
21212 
    None, # 0
21213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21214 
  )
21215 
 
21216 
  def __init__(self, ex=None,):
21217 
    self.ex = ex
21218 
 
21219 
  def read(self, iprot):
21220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21222 
      return
21223 
    iprot.readStructBegin()
21224 
    while True:
21225 
      (fname, ftype, fid) = iprot.readFieldBegin()
21226 
      if ftype == TType.STOP:
21227 
        break
21228 
      if fid == 1:
21229 
        if ftype == TType.STRUCT:
21230 
          self.ex = TransactionServiceException()
21231 
          self.ex.read(iprot)
21232 
        else:
21233 
          iprot.skip(ftype)
21234 
      else:
21235 
        iprot.skip(ftype)
21236 
      iprot.readFieldEnd()
21237 
    iprot.readStructEnd()
21238 
 
21239 
  def write(self, oprot):
21240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21242 
      return
21243 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21244 
    if self.ex is not None:
21245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21246 
      self.ex.write(oprot)
21247 
      oprot.writeFieldEnd()
21248 
    oprot.writeFieldStop()
21249 
    oprot.writeStructEnd()
21250 
 
21251 
  def validate(self):
21252 
    return
21253 
 
21254 
 
21255 
  def __repr__(self):
21256 
    L = ['%s=%r' % (key, value)
21257 
      for key, value in self.__dict__.iteritems()]
21258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21259 
 
21260 
  def __eq__(self, other):
21261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21262 
 
21263 
  def __ne__(self, other):
21264 
    return not (self == other)
21265 
 
21266 
class markOrdersAsNotAvailabke_args:
21267 
  """
21268 
  Attributes:
21269 
   - vendorId
21270 
   - itemId
21271 
   - quantity
21272 
   - estimate
4369 rajveer 21273 
   - isReminder
4303 rajveer 21274 
  """
21275 
 
21276 
  thrift_spec = (
21277 
    None, # 0
21278 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21279 
    (2, TType.I64, 'itemId', None, None, ), # 2
21280 
    (3, TType.I64, 'quantity', None, None, ), # 3
21281 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21282 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21283 
  )
21284 
 
4369 rajveer 21285 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21286 
    self.vendorId = vendorId
21287 
    self.itemId = itemId
21288 
    self.quantity = quantity
21289 
    self.estimate = estimate
4369 rajveer 21290 
    self.isReminder = isReminder
4303 rajveer 21291 
 
21292 
  def read(self, iprot):
21293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21295 
      return
21296 
    iprot.readStructBegin()
21297 
    while True:
21298 
      (fname, ftype, fid) = iprot.readFieldBegin()
21299 
      if ftype == TType.STOP:
21300 
        break
21301 
      if fid == 1:
21302 
        if ftype == TType.I64:
21303 
          self.vendorId = iprot.readI64();
21304 
        else:
21305 
          iprot.skip(ftype)
21306 
      elif fid == 2:
21307 
        if ftype == TType.I64:
21308 
          self.itemId = iprot.readI64();
21309 
        else:
21310 
          iprot.skip(ftype)
21311 
      elif fid == 3:
21312 
        if ftype == TType.I64:
21313 
          self.quantity = iprot.readI64();
21314 
        else:
21315 
          iprot.skip(ftype)
21316 
      elif fid == 4:
21317 
        if ftype == TType.I64:
21318 
          self.estimate = iprot.readI64();
21319 
        else:
21320 
          iprot.skip(ftype)
4369 rajveer 21321 
      elif fid == 5:
21322 
        if ftype == TType.BOOL:
21323 
          self.isReminder = iprot.readBool();
21324 
        else:
21325 
          iprot.skip(ftype)
4303 rajveer 21326 
      else:
21327 
        iprot.skip(ftype)
21328 
      iprot.readFieldEnd()
21329 
    iprot.readStructEnd()
21330 
 
21331 
  def write(self, oprot):
21332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21334 
      return
21335 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21336 
    if self.vendorId is not None:
21337 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21338 
      oprot.writeI64(self.vendorId)
21339 
      oprot.writeFieldEnd()
21340 
    if self.itemId is not None:
21341 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21342 
      oprot.writeI64(self.itemId)
21343 
      oprot.writeFieldEnd()
21344 
    if self.quantity is not None:
21345 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21346 
      oprot.writeI64(self.quantity)
21347 
      oprot.writeFieldEnd()
21348 
    if self.estimate is not None:
21349 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21350 
      oprot.writeI64(self.estimate)
21351 
      oprot.writeFieldEnd()
4369 rajveer 21352 
    if self.isReminder is not None:
21353 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21354 
      oprot.writeBool(self.isReminder)
21355 
      oprot.writeFieldEnd()
4303 rajveer 21356 
    oprot.writeFieldStop()
21357 
    oprot.writeStructEnd()
21358 
 
21359 
  def validate(self):
21360 
    return
21361 
 
21362 
 
21363 
  def __repr__(self):
21364 
    L = ['%s=%r' % (key, value)
21365 
      for key, value in self.__dict__.iteritems()]
21366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21367 
 
21368 
  def __eq__(self, other):
21369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21370 
 
21371 
  def __ne__(self, other):
21372 
    return not (self == other)
21373 
 
21374 
class markOrdersAsNotAvailabke_result:
21375 
  """
21376 
  Attributes:
21377 
   - ex
21378 
  """
21379 
 
21380 
  thrift_spec = (
21381 
    None, # 0
21382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21383 
  )
21384 
 
21385 
  def __init__(self, ex=None,):
21386 
    self.ex = ex
21387 
 
21388 
  def read(self, iprot):
21389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21391 
      return
21392 
    iprot.readStructBegin()
21393 
    while True:
21394 
      (fname, ftype, fid) = iprot.readFieldBegin()
21395 
      if ftype == TType.STOP:
21396 
        break
21397 
      if fid == 1:
21398 
        if ftype == TType.STRUCT:
21399 
          self.ex = TransactionServiceException()
21400 
          self.ex.read(iprot)
21401 
        else:
21402 
          iprot.skip(ftype)
21403 
      else:
21404 
        iprot.skip(ftype)
21405 
      iprot.readFieldEnd()
21406 
    iprot.readStructEnd()
21407 
 
21408 
  def write(self, oprot):
21409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21411 
      return
21412 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21413 
    if self.ex is not None:
21414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21415 
      self.ex.write(oprot)
21416 
      oprot.writeFieldEnd()
21417 
    oprot.writeFieldStop()
21418 
    oprot.writeStructEnd()
21419 
 
21420 
  def validate(self):
21421 
    return
21422 
 
21423 
 
21424 
  def __repr__(self):
21425 
    L = ['%s=%r' % (key, value)
21426 
      for key, value in self.__dict__.iteritems()]
21427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21428 
 
21429 
  def __eq__(self, other):
21430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21431 
 
21432 
  def __ne__(self, other):
21433 
    return not (self == other)
4369 rajveer 21434 
 
21435 
class markOrdersAsTimeout_args:
21436 
  """
21437 
  Attributes:
21438 
   - vendorId
21439 
  """
21440 
 
21441 
  thrift_spec = (
21442 
    None, # 0
21443 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21444 
  )
21445 
 
21446 
  def __init__(self, vendorId=None,):
21447 
    self.vendorId = vendorId
21448 
 
21449 
  def read(self, iprot):
21450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21452 
      return
21453 
    iprot.readStructBegin()
21454 
    while True:
21455 
      (fname, ftype, fid) = iprot.readFieldBegin()
21456 
      if ftype == TType.STOP:
21457 
        break
21458 
      if fid == 1:
21459 
        if ftype == TType.I64:
21460 
          self.vendorId = iprot.readI64();
21461 
        else:
21462 
          iprot.skip(ftype)
21463 
      else:
21464 
        iprot.skip(ftype)
21465 
      iprot.readFieldEnd()
21466 
    iprot.readStructEnd()
21467 
 
21468 
  def write(self, oprot):
21469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21471 
      return
21472 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21473 
    if self.vendorId is not None:
21474 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21475 
      oprot.writeI64(self.vendorId)
21476 
      oprot.writeFieldEnd()
21477 
    oprot.writeFieldStop()
21478 
    oprot.writeStructEnd()
21479 
 
21480 
  def validate(self):
21481 
    return
21482 
 
21483 
 
21484 
  def __repr__(self):
21485 
    L = ['%s=%r' % (key, value)
21486 
      for key, value in self.__dict__.iteritems()]
21487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21488 
 
21489 
  def __eq__(self, other):
21490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21491 
 
21492 
  def __ne__(self, other):
21493 
    return not (self == other)
21494 
 
21495 
class markOrdersAsTimeout_result:
21496 
  """
21497 
  Attributes:
21498 
   - success
21499 
   - ex
21500 
  """
21501 
 
21502 
  thrift_spec = (
21503 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21505 
  )
21506 
 
21507 
  def __init__(self, success=None, ex=None,):
21508 
    self.success = success
21509 
    self.ex = ex
21510 
 
21511 
  def read(self, iprot):
21512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21514 
      return
21515 
    iprot.readStructBegin()
21516 
    while True:
21517 
      (fname, ftype, fid) = iprot.readFieldBegin()
21518 
      if ftype == TType.STOP:
21519 
        break
21520 
      if fid == 0:
21521 
        if ftype == TType.MAP:
21522 
          self.success = {}
6031 rajveer 21523 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21524 
          for _i462 in xrange(_size458):
21525 
            _key463 = iprot.readI32();
21526 
            _val464 = TimeoutSummary()
21527 
            _val464.read(iprot)
21528 
            self.success[_key463] = _val464
4369 rajveer 21529 
          iprot.readMapEnd()
21530 
        else:
21531 
          iprot.skip(ftype)
21532 
      elif fid == 1:
21533 
        if ftype == TType.STRUCT:
21534 
          self.ex = TransactionServiceException()
21535 
          self.ex.read(iprot)
21536 
        else:
21537 
          iprot.skip(ftype)
21538 
      else:
21539 
        iprot.skip(ftype)
21540 
      iprot.readFieldEnd()
21541 
    iprot.readStructEnd()
21542 
 
21543 
  def write(self, oprot):
21544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21546 
      return
21547 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21548 
    if self.success is not None:
21549 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21550 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21551 
      for kiter465,viter466 in self.success.items():
21552 
        oprot.writeI32(kiter465)
21553 
        viter466.write(oprot)
4369 rajveer 21554 
      oprot.writeMapEnd()
21555 
      oprot.writeFieldEnd()
21556 
    if self.ex is not None:
21557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21558 
      self.ex.write(oprot)
21559 
      oprot.writeFieldEnd()
21560 
    oprot.writeFieldStop()
21561 
    oprot.writeStructEnd()
21562 
 
21563 
  def validate(self):
21564 
    return
21565 
 
21566 
 
21567 
  def __repr__(self):
21568 
    L = ['%s=%r' % (key, value)
21569 
      for key, value in self.__dict__.iteritems()]
21570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21571 
 
21572 
  def __eq__(self, other):
21573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21574 
 
21575 
  def __ne__(self, other):
21576 
    return not (self == other)
4386 anupam.sin 21577 
 
4662 rajveer 21578 
class markOrderAsLostInTransit_args:
21579 
  """
21580 
  Attributes:
21581 
   - orderId
21582 
  """
21583 
 
21584 
  thrift_spec = (
21585 
    None, # 0
21586 
    (1, TType.I64, 'orderId', None, None, ), # 1
21587 
  )
21588 
 
21589 
  def __init__(self, orderId=None,):
21590 
    self.orderId = orderId
21591 
 
21592 
  def read(self, iprot):
21593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21595 
      return
21596 
    iprot.readStructBegin()
21597 
    while True:
21598 
      (fname, ftype, fid) = iprot.readFieldBegin()
21599 
      if ftype == TType.STOP:
21600 
        break
21601 
      if fid == 1:
21602 
        if ftype == TType.I64:
21603 
          self.orderId = iprot.readI64();
21604 
        else:
21605 
          iprot.skip(ftype)
21606 
      else:
21607 
        iprot.skip(ftype)
21608 
      iprot.readFieldEnd()
21609 
    iprot.readStructEnd()
21610 
 
21611 
  def write(self, oprot):
21612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21614 
      return
21615 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21616 
    if self.orderId is not None:
21617 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21618 
      oprot.writeI64(self.orderId)
21619 
      oprot.writeFieldEnd()
21620 
    oprot.writeFieldStop()
21621 
    oprot.writeStructEnd()
21622 
 
21623 
  def validate(self):
21624 
    return
21625 
 
21626 
 
21627 
  def __repr__(self):
21628 
    L = ['%s=%r' % (key, value)
21629 
      for key, value in self.__dict__.iteritems()]
21630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21631 
 
21632 
  def __eq__(self, other):
21633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21634 
 
21635 
  def __ne__(self, other):
21636 
    return not (self == other)
21637 
 
21638 
class markOrderAsLostInTransit_result:
21639 
  """
21640 
  Attributes:
21641 
   - success
21642 
   - ex
21643 
  """
21644 
 
21645 
  thrift_spec = (
21646 
    (0, TType.BOOL, 'success', None, None, ), # 0
21647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21648 
  )
21649 
 
21650 
  def __init__(self, success=None, ex=None,):
21651 
    self.success = success
21652 
    self.ex = ex
21653 
 
21654 
  def read(self, iprot):
21655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21657 
      return
21658 
    iprot.readStructBegin()
21659 
    while True:
21660 
      (fname, ftype, fid) = iprot.readFieldBegin()
21661 
      if ftype == TType.STOP:
21662 
        break
21663 
      if fid == 0:
21664 
        if ftype == TType.BOOL:
21665 
          self.success = iprot.readBool();
21666 
        else:
21667 
          iprot.skip(ftype)
21668 
      elif fid == 1:
21669 
        if ftype == TType.STRUCT:
21670 
          self.ex = TransactionServiceException()
21671 
          self.ex.read(iprot)
21672 
        else:
21673 
          iprot.skip(ftype)
21674 
      else:
21675 
        iprot.skip(ftype)
21676 
      iprot.readFieldEnd()
21677 
    iprot.readStructEnd()
21678 
 
21679 
  def write(self, oprot):
21680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21682 
      return
21683 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21684 
    if self.success is not None:
21685 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21686 
      oprot.writeBool(self.success)
21687 
      oprot.writeFieldEnd()
21688 
    if self.ex is not None:
21689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21690 
      self.ex.write(oprot)
21691 
      oprot.writeFieldEnd()
21692 
    oprot.writeFieldStop()
21693 
    oprot.writeStructEnd()
21694 
 
21695 
  def validate(self):
21696 
    return
21697 
 
21698 
 
21699 
  def __repr__(self):
21700 
    L = ['%s=%r' % (key, value)
21701 
      for key, value in self.__dict__.iteritems()]
21702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21703 
 
21704 
  def __eq__(self, other):
21705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21706 
 
21707 
  def __ne__(self, other):
21708 
    return not (self == other)
21709 
 
4386 anupam.sin 21710 
class getOrderForAwb_args:
21711 
  """
21712 
  Attributes:
21713 
   - awb
21714 
  """
21715 
 
21716 
  thrift_spec = (
21717 
    None, # 0
21718 
    (1, TType.STRING, 'awb', None, None, ), # 1
21719 
  )
21720 
 
21721 
  def __init__(self, awb=None,):
21722 
    self.awb = awb
21723 
 
21724 
  def read(self, iprot):
21725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21727 
      return
21728 
    iprot.readStructBegin()
21729 
    while True:
21730 
      (fname, ftype, fid) = iprot.readFieldBegin()
21731 
      if ftype == TType.STOP:
21732 
        break
21733 
      if fid == 1:
21734 
        if ftype == TType.STRING:
21735 
          self.awb = iprot.readString();
21736 
        else:
21737 
          iprot.skip(ftype)
21738 
      else:
21739 
        iprot.skip(ftype)
21740 
      iprot.readFieldEnd()
21741 
    iprot.readStructEnd()
21742 
 
21743 
  def write(self, oprot):
21744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21746 
      return
21747 
    oprot.writeStructBegin('getOrderForAwb_args')
21748 
    if self.awb is not None:
21749 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21750 
      oprot.writeString(self.awb)
21751 
      oprot.writeFieldEnd()
21752 
    oprot.writeFieldStop()
21753 
    oprot.writeStructEnd()
21754 
 
21755 
  def validate(self):
21756 
    return
21757 
 
21758 
 
21759 
  def __repr__(self):
21760 
    L = ['%s=%r' % (key, value)
21761 
      for key, value in self.__dict__.iteritems()]
21762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21763 
 
21764 
  def __eq__(self, other):
21765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21766 
 
21767 
  def __ne__(self, other):
21768 
    return not (self == other)
21769 
 
21770 
class getOrderForAwb_result:
21771 
  """
21772 
  Attributes:
21773 
   - success
21774 
   - ex
21775 
  """
21776 
 
21777 
  thrift_spec = (
21778 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21780 
  )
21781 
 
21782 
  def __init__(self, success=None, ex=None,):
21783 
    self.success = success
21784 
    self.ex = ex
21785 
 
21786 
  def read(self, iprot):
21787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21789 
      return
21790 
    iprot.readStructBegin()
21791 
    while True:
21792 
      (fname, ftype, fid) = iprot.readFieldBegin()
21793 
      if ftype == TType.STOP:
21794 
        break
21795 
      if fid == 0:
21796 
        if ftype == TType.STRUCT:
21797 
          self.success = Order()
21798 
          self.success.read(iprot)
21799 
        else:
21800 
          iprot.skip(ftype)
21801 
      elif fid == 1:
21802 
        if ftype == TType.STRUCT:
21803 
          self.ex = TransactionServiceException()
21804 
          self.ex.read(iprot)
21805 
        else:
21806 
          iprot.skip(ftype)
21807 
      else:
21808 
        iprot.skip(ftype)
21809 
      iprot.readFieldEnd()
21810 
    iprot.readStructEnd()
21811 
 
21812 
  def write(self, oprot):
21813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21815 
      return
21816 
    oprot.writeStructBegin('getOrderForAwb_result')
21817 
    if self.success is not None:
21818 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21819 
      self.success.write(oprot)
21820 
      oprot.writeFieldEnd()
21821 
    if self.ex is not None:
21822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21823 
      self.ex.write(oprot)
21824 
      oprot.writeFieldEnd()
21825 
    oprot.writeFieldStop()
21826 
    oprot.writeStructEnd()
21827 
 
21828 
  def validate(self):
21829 
    return
21830 
 
21831 
 
21832 
  def __repr__(self):
21833 
    L = ['%s=%r' % (key, value)
21834 
      for key, value in self.__dict__.iteritems()]
21835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21836 
 
21837 
  def __eq__(self, other):
21838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21839 
 
21840 
  def __ne__(self, other):
21841 
    return not (self == other)
4506 phani.kuma 21842 
 
21843 
class getOrdersForProviderForStatus_args:
21844 
  """
21845 
  Attributes:
21846 
   - logistics_provider_id
4910 phani.kuma 21847 
   - order_status_list
4506 phani.kuma 21848 
  """
21849 
 
21850 
  thrift_spec = (
21851 
    None, # 0
21852 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21853 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21854 
  )
21855 
 
4910 phani.kuma 21856 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21857 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21858 
    self.order_status_list = order_status_list
4506 phani.kuma 21859 
 
21860 
  def read(self, iprot):
21861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21863 
      return
21864 
    iprot.readStructBegin()
21865 
    while True:
21866 
      (fname, ftype, fid) = iprot.readFieldBegin()
21867 
      if ftype == TType.STOP:
21868 
        break
21869 
      if fid == 1:
21870 
        if ftype == TType.I64:
21871 
          self.logistics_provider_id = iprot.readI64();
21872 
        else:
21873 
          iprot.skip(ftype)
21874 
      elif fid == 2:
4910 phani.kuma 21875 
        if ftype == TType.LIST:
21876 
          self.order_status_list = []
6031 rajveer 21877 
          (_etype470, _size467) = iprot.readListBegin()
21878 
          for _i471 in xrange(_size467):
21879 
            _elem472 = iprot.readI32();
21880 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21881 
          iprot.readListEnd()
4506 phani.kuma 21882 
        else:
21883 
          iprot.skip(ftype)
21884 
      else:
21885 
        iprot.skip(ftype)
21886 
      iprot.readFieldEnd()
21887 
    iprot.readStructEnd()
21888 
 
21889 
  def write(self, oprot):
21890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21892 
      return
21893 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21894 
    if self.logistics_provider_id is not None:
21895 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21896 
      oprot.writeI64(self.logistics_provider_id)
21897 
      oprot.writeFieldEnd()
4910 phani.kuma 21898 
    if self.order_status_list is not None:
21899 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21900 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21901 
      for iter473 in self.order_status_list:
21902 
        oprot.writeI32(iter473)
4910 phani.kuma 21903 
      oprot.writeListEnd()
4506 phani.kuma 21904 
      oprot.writeFieldEnd()
21905 
    oprot.writeFieldStop()
21906 
    oprot.writeStructEnd()
21907 
 
21908 
  def validate(self):
21909 
    return
21910 
 
21911 
 
21912 
  def __repr__(self):
21913 
    L = ['%s=%r' % (key, value)
21914 
      for key, value in self.__dict__.iteritems()]
21915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21916 
 
21917 
  def __eq__(self, other):
21918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21919 
 
21920 
  def __ne__(self, other):
21921 
    return not (self == other)
21922 
 
21923 
class getOrdersForProviderForStatus_result:
21924 
  """
21925 
  Attributes:
21926 
   - success
21927 
   - ex
21928 
  """
21929 
 
21930 
  thrift_spec = (
21931 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21933 
  )
21934 
 
21935 
  def __init__(self, success=None, ex=None,):
21936 
    self.success = success
21937 
    self.ex = ex
21938 
 
21939 
  def read(self, iprot):
21940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21942 
      return
21943 
    iprot.readStructBegin()
21944 
    while True:
21945 
      (fname, ftype, fid) = iprot.readFieldBegin()
21946 
      if ftype == TType.STOP:
21947 
        break
21948 
      if fid == 0:
21949 
        if ftype == TType.LIST:
21950 
          self.success = []
6031 rajveer 21951 
          (_etype477, _size474) = iprot.readListBegin()
21952 
          for _i478 in xrange(_size474):
21953 
            _elem479 = Order()
21954 
            _elem479.read(iprot)
21955 
            self.success.append(_elem479)
4506 phani.kuma 21956 
          iprot.readListEnd()
21957 
        else:
21958 
          iprot.skip(ftype)
21959 
      elif fid == 1:
21960 
        if ftype == TType.STRUCT:
21961 
          self.ex = TransactionServiceException()
21962 
          self.ex.read(iprot)
21963 
        else:
21964 
          iprot.skip(ftype)
21965 
      else:
21966 
        iprot.skip(ftype)
21967 
      iprot.readFieldEnd()
21968 
    iprot.readStructEnd()
21969 
 
21970 
  def write(self, oprot):
21971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21973 
      return
21974 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21975 
    if self.success is not None:
21976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21977 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21978 
      for iter480 in self.success:
21979 
        iter480.write(oprot)
4506 phani.kuma 21980 
      oprot.writeListEnd()
21981 
      oprot.writeFieldEnd()
21982 
    if self.ex is not None:
21983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21984 
      self.ex.write(oprot)
21985 
      oprot.writeFieldEnd()
21986 
    oprot.writeFieldStop()
21987 
    oprot.writeStructEnd()
21988 
 
21989 
  def validate(self):
21990 
    return
21991 
 
21992 
 
21993 
  def __repr__(self):
21994 
    L = ['%s=%r' % (key, value)
21995 
      for key, value in self.__dict__.iteritems()]
21996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21997 
 
21998 
  def __eq__(self, other):
21999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22000 
 
22001 
  def __ne__(self, other):
22002 
    return not (self == other)
4600 varun.gupt 22003 
 
22004 
class getBilledOrdersForVendor_args:
22005 
  """
22006 
  Attributes:
22007 
   - vendorId
22008 
   - billingDateFrom
22009 
   - billingDateTo
22010 
  """
22011 
 
22012 
  thrift_spec = (
22013 
    None, # 0
22014 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22015 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22016 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22017 
  )
22018 
 
22019 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22020 
    self.vendorId = vendorId
22021 
    self.billingDateFrom = billingDateFrom
22022 
    self.billingDateTo = billingDateTo
22023 
 
22024 
  def read(self, iprot):
22025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22027 
      return
22028 
    iprot.readStructBegin()
22029 
    while True:
22030 
      (fname, ftype, fid) = iprot.readFieldBegin()
22031 
      if ftype == TType.STOP:
22032 
        break
22033 
      if fid == 1:
22034 
        if ftype == TType.I64:
22035 
          self.vendorId = iprot.readI64();
22036 
        else:
22037 
          iprot.skip(ftype)
22038 
      elif fid == 2:
22039 
        if ftype == TType.I64:
22040 
          self.billingDateFrom = iprot.readI64();
22041 
        else:
22042 
          iprot.skip(ftype)
22043 
      elif fid == 3:
22044 
        if ftype == TType.I64:
22045 
          self.billingDateTo = iprot.readI64();
22046 
        else:
22047 
          iprot.skip(ftype)
22048 
      else:
22049 
        iprot.skip(ftype)
22050 
      iprot.readFieldEnd()
22051 
    iprot.readStructEnd()
22052 
 
22053 
  def write(self, oprot):
22054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22056 
      return
22057 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22058 
    if self.vendorId is not None:
22059 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22060 
      oprot.writeI64(self.vendorId)
22061 
      oprot.writeFieldEnd()
22062 
    if self.billingDateFrom is not None:
22063 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22064 
      oprot.writeI64(self.billingDateFrom)
22065 
      oprot.writeFieldEnd()
22066 
    if self.billingDateTo is not None:
22067 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22068 
      oprot.writeI64(self.billingDateTo)
22069 
      oprot.writeFieldEnd()
22070 
    oprot.writeFieldStop()
22071 
    oprot.writeStructEnd()
22072 
 
22073 
  def validate(self):
22074 
    return
22075 
 
22076 
 
22077 
  def __repr__(self):
22078 
    L = ['%s=%r' % (key, value)
22079 
      for key, value in self.__dict__.iteritems()]
22080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22081 
 
22082 
  def __eq__(self, other):
22083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22084 
 
22085 
  def __ne__(self, other):
22086 
    return not (self == other)
22087 
 
22088 
class getBilledOrdersForVendor_result:
22089 
  """
22090 
  Attributes:
22091 
   - success
22092 
   - ex
22093 
  """
22094 
 
22095 
  thrift_spec = (
22096 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22098 
  )
22099 
 
22100 
  def __init__(self, success=None, ex=None,):
22101 
    self.success = success
22102 
    self.ex = ex
22103 
 
22104 
  def read(self, iprot):
22105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22107 
      return
22108 
    iprot.readStructBegin()
22109 
    while True:
22110 
      (fname, ftype, fid) = iprot.readFieldBegin()
22111 
      if ftype == TType.STOP:
22112 
        break
22113 
      if fid == 0:
22114 
        if ftype == TType.LIST:
22115 
          self.success = []
6031 rajveer 22116 
          (_etype484, _size481) = iprot.readListBegin()
22117 
          for _i485 in xrange(_size481):
22118 
            _elem486 = Order()
22119 
            _elem486.read(iprot)
22120 
            self.success.append(_elem486)
4600 varun.gupt 22121 
          iprot.readListEnd()
22122 
        else:
22123 
          iprot.skip(ftype)
22124 
      elif fid == 1:
22125 
        if ftype == TType.STRUCT:
22126 
          self.ex = TransactionServiceException()
22127 
          self.ex.read(iprot)
22128 
        else:
22129 
          iprot.skip(ftype)
22130 
      else:
22131 
        iprot.skip(ftype)
22132 
      iprot.readFieldEnd()
22133 
    iprot.readStructEnd()
22134 
 
22135 
  def write(self, oprot):
22136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22138 
      return
22139 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22140 
    if self.success is not None:
22141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22143 
      for iter487 in self.success:
22144 
        iter487.write(oprot)
4600 varun.gupt 22145 
      oprot.writeListEnd()
22146 
      oprot.writeFieldEnd()
22147 
    if self.ex is not None:
22148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22149 
      self.ex.write(oprot)
22150 
      oprot.writeFieldEnd()
22151 
    oprot.writeFieldStop()
22152 
    oprot.writeStructEnd()
22153 
 
22154 
  def validate(self):
22155 
    return
22156 
 
22157 
 
22158 
  def __repr__(self):
22159 
    L = ['%s=%r' % (key, value)
22160 
      for key, value in self.__dict__.iteritems()]
22161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22162 
 
22163 
  def __eq__(self, other):
22164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22165 
 
22166 
  def __ne__(self, other):
22167 
    return not (self == other)
22168 
 
4607 rajveer 22169 
class getSlippedSippingDateOrders_args:
22170 
 
22171 
  thrift_spec = (
22172 
  )
22173 
 
22174 
  def read(self, iprot):
22175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22177 
      return
22178 
    iprot.readStructBegin()
22179 
    while True:
22180 
      (fname, ftype, fid) = iprot.readFieldBegin()
22181 
      if ftype == TType.STOP:
22182 
        break
22183 
      else:
22184 
        iprot.skip(ftype)
22185 
      iprot.readFieldEnd()
22186 
    iprot.readStructEnd()
22187 
 
22188 
  def write(self, oprot):
22189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22191 
      return
22192 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22193 
    oprot.writeFieldStop()
22194 
    oprot.writeStructEnd()
22195 
 
22196 
  def validate(self):
22197 
    return
22198 
 
22199 
 
22200 
  def __repr__(self):
22201 
    L = ['%s=%r' % (key, value)
22202 
      for key, value in self.__dict__.iteritems()]
22203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22204 
 
22205 
  def __eq__(self, other):
22206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22207 
 
22208 
  def __ne__(self, other):
22209 
    return not (self == other)
22210 
 
22211 
class getSlippedSippingDateOrders_result:
22212 
  """
22213 
  Attributes:
22214 
   - success
22215 
   - ex
22216 
  """
22217 
 
22218 
  thrift_spec = (
22219 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22221 
  )
22222 
 
22223 
  def __init__(self, success=None, ex=None,):
22224 
    self.success = success
22225 
    self.ex = ex
22226 
 
22227 
  def read(self, iprot):
22228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22230 
      return
22231 
    iprot.readStructBegin()
22232 
    while True:
22233 
      (fname, ftype, fid) = iprot.readFieldBegin()
22234 
      if ftype == TType.STOP:
22235 
        break
22236 
      if fid == 0:
22237 
        if ftype == TType.LIST:
22238 
          self.success = []
6031 rajveer 22239 
          (_etype491, _size488) = iprot.readListBegin()
22240 
          for _i492 in xrange(_size488):
22241 
            _elem493 = Order()
22242 
            _elem493.read(iprot)
22243 
            self.success.append(_elem493)
4607 rajveer 22244 
          iprot.readListEnd()
22245 
        else:
22246 
          iprot.skip(ftype)
22247 
      elif fid == 1:
22248 
        if ftype == TType.STRUCT:
22249 
          self.ex = TransactionServiceException()
22250 
          self.ex.read(iprot)
22251 
        else:
22252 
          iprot.skip(ftype)
22253 
      else:
22254 
        iprot.skip(ftype)
22255 
      iprot.readFieldEnd()
22256 
    iprot.readStructEnd()
22257 
 
22258 
  def write(self, oprot):
22259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22261 
      return
22262 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22263 
    if self.success is not None:
22264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22266 
      for iter494 in self.success:
22267 
        iter494.write(oprot)
4607 rajveer 22268 
      oprot.writeListEnd()
22269 
      oprot.writeFieldEnd()
22270 
    if self.ex is not None:
22271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22272 
      self.ex.write(oprot)
22273 
      oprot.writeFieldEnd()
22274 
    oprot.writeFieldStop()
22275 
    oprot.writeStructEnd()
22276 
 
22277 
  def validate(self):
22278 
    return
22279 
 
22280 
 
22281 
  def __repr__(self):
22282 
    L = ['%s=%r' % (key, value)
22283 
      for key, value in self.__dict__.iteritems()]
22284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22285 
 
22286 
  def __eq__(self, other):
22287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22288 
 
22289 
  def __ne__(self, other):
22290 
    return not (self == other)
22291 
 
4709 rajveer 22292 
class getCancelledOrders_args:
22293 
  """
22294 
  Attributes:
22295 
   - cancelDateFrom
22296 
   - cancelDateTo
22297 
  """
22298 
 
22299 
  thrift_spec = (
22300 
    None, # 0
22301 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22302 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22303 
  )
22304 
 
22305 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22306 
    self.cancelDateFrom = cancelDateFrom
22307 
    self.cancelDateTo = cancelDateTo
22308 
 
22309 
  def read(self, iprot):
22310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22312 
      return
22313 
    iprot.readStructBegin()
22314 
    while True:
22315 
      (fname, ftype, fid) = iprot.readFieldBegin()
22316 
      if ftype == TType.STOP:
22317 
        break
22318 
      if fid == 1:
22319 
        if ftype == TType.I64:
22320 
          self.cancelDateFrom = iprot.readI64();
22321 
        else:
22322 
          iprot.skip(ftype)
22323 
      elif fid == 2:
22324 
        if ftype == TType.I64:
22325 
          self.cancelDateTo = iprot.readI64();
22326 
        else:
22327 
          iprot.skip(ftype)
22328 
      else:
22329 
        iprot.skip(ftype)
22330 
      iprot.readFieldEnd()
22331 
    iprot.readStructEnd()
22332 
 
22333 
  def write(self, oprot):
22334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22336 
      return
22337 
    oprot.writeStructBegin('getCancelledOrders_args')
22338 
    if self.cancelDateFrom is not None:
22339 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22340 
      oprot.writeI64(self.cancelDateFrom)
22341 
      oprot.writeFieldEnd()
22342 
    if self.cancelDateTo is not None:
22343 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22344 
      oprot.writeI64(self.cancelDateTo)
22345 
      oprot.writeFieldEnd()
22346 
    oprot.writeFieldStop()
22347 
    oprot.writeStructEnd()
22348 
 
22349 
  def validate(self):
22350 
    return
22351 
 
22352 
 
22353 
  def __repr__(self):
22354 
    L = ['%s=%r' % (key, value)
22355 
      for key, value in self.__dict__.iteritems()]
22356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22357 
 
22358 
  def __eq__(self, other):
22359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22360 
 
22361 
  def __ne__(self, other):
22362 
    return not (self == other)
22363 
 
22364 
class getCancelledOrders_result:
22365 
  """
22366 
  Attributes:
22367 
   - success
22368 
   - ex
22369 
  """
22370 
 
22371 
  thrift_spec = (
22372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22374 
  )
22375 
 
22376 
  def __init__(self, success=None, ex=None,):
22377 
    self.success = success
22378 
    self.ex = ex
22379 
 
22380 
  def read(self, iprot):
22381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22383 
      return
22384 
    iprot.readStructBegin()
22385 
    while True:
22386 
      (fname, ftype, fid) = iprot.readFieldBegin()
22387 
      if ftype == TType.STOP:
22388 
        break
22389 
      if fid == 0:
22390 
        if ftype == TType.LIST:
22391 
          self.success = []
6031 rajveer 22392 
          (_etype498, _size495) = iprot.readListBegin()
22393 
          for _i499 in xrange(_size495):
22394 
            _elem500 = Order()
22395 
            _elem500.read(iprot)
22396 
            self.success.append(_elem500)
4709 rajveer 22397 
          iprot.readListEnd()
22398 
        else:
22399 
          iprot.skip(ftype)
22400 
      elif fid == 1:
22401 
        if ftype == TType.STRUCT:
22402 
          self.ex = TransactionServiceException()
22403 
          self.ex.read(iprot)
22404 
        else:
22405 
          iprot.skip(ftype)
22406 
      else:
22407 
        iprot.skip(ftype)
22408 
      iprot.readFieldEnd()
22409 
    iprot.readStructEnd()
22410 
 
22411 
  def write(self, oprot):
22412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22414 
      return
22415 
    oprot.writeStructBegin('getCancelledOrders_result')
22416 
    if self.success is not None:
22417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22419 
      for iter501 in self.success:
22420 
        iter501.write(oprot)
4709 rajveer 22421 
      oprot.writeListEnd()
22422 
      oprot.writeFieldEnd()
22423 
    if self.ex is not None:
22424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22425 
      self.ex.write(oprot)
22426 
      oprot.writeFieldEnd()
22427 
    oprot.writeFieldStop()
22428 
    oprot.writeStructEnd()
22429 
 
22430 
  def validate(self):
22431 
    return
22432 
 
22433 
 
22434 
  def __repr__(self):
22435 
    L = ['%s=%r' % (key, value)
22436 
      for key, value in self.__dict__.iteritems()]
22437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22438 
 
22439 
  def __eq__(self, other):
22440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22441 
 
22442 
  def __ne__(self, other):
22443 
    return not (self == other)
22444 
 
4600 varun.gupt 22445 
class saveBluedartSettlements_args:
22446 
  """
22447 
  Attributes:
22448 
   - mapAWBAndAmount
22449 
  """
22450 
 
22451 
  thrift_spec = (
22452 
    None, # 0
22453 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22454 
  )
22455 
 
22456 
  def __init__(self, mapAWBAndAmount=None,):
22457 
    self.mapAWBAndAmount = mapAWBAndAmount
22458 
 
22459 
  def read(self, iprot):
22460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22462 
      return
22463 
    iprot.readStructBegin()
22464 
    while True:
22465 
      (fname, ftype, fid) = iprot.readFieldBegin()
22466 
      if ftype == TType.STOP:
22467 
        break
22468 
      if fid == 1:
22469 
        if ftype == TType.MAP:
22470 
          self.mapAWBAndAmount = {}
6031 rajveer 22471 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22472 
          for _i506 in xrange(_size502):
22473 
            _key507 = iprot.readI64();
22474 
            _val508 = iprot.readDouble();
22475 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22476 
          iprot.readMapEnd()
22477 
        else:
22478 
          iprot.skip(ftype)
22479 
      else:
22480 
        iprot.skip(ftype)
22481 
      iprot.readFieldEnd()
22482 
    iprot.readStructEnd()
22483 
 
22484 
  def write(self, oprot):
22485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22487 
      return
22488 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22489 
    if self.mapAWBAndAmount is not None:
22490 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22491 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22492 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22493 
        oprot.writeI64(kiter509)
22494 
        oprot.writeDouble(viter510)
4600 varun.gupt 22495 
      oprot.writeMapEnd()
22496 
      oprot.writeFieldEnd()
22497 
    oprot.writeFieldStop()
22498 
    oprot.writeStructEnd()
22499 
 
22500 
  def validate(self):
22501 
    return
22502 
 
22503 
 
22504 
  def __repr__(self):
22505 
    L = ['%s=%r' % (key, value)
22506 
      for key, value in self.__dict__.iteritems()]
22507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22508 
 
22509 
  def __eq__(self, other):
22510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22511 
 
22512 
  def __ne__(self, other):
22513 
    return not (self == other)
22514 
 
22515 
class saveBluedartSettlements_result:
22516 
  """
22517 
  Attributes:
22518 
   - ex
22519 
  """
22520 
 
22521 
  thrift_spec = (
22522 
    None, # 0
22523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22524 
  )
22525 
 
22526 
  def __init__(self, ex=None,):
22527 
    self.ex = ex
22528 
 
22529 
  def read(self, iprot):
22530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22532 
      return
22533 
    iprot.readStructBegin()
22534 
    while True:
22535 
      (fname, ftype, fid) = iprot.readFieldBegin()
22536 
      if ftype == TType.STOP:
22537 
        break
22538 
      if fid == 1:
22539 
        if ftype == TType.STRUCT:
22540 
          self.ex = TransactionServiceException()
22541 
          self.ex.read(iprot)
22542 
        else:
22543 
          iprot.skip(ftype)
22544 
      else:
22545 
        iprot.skip(ftype)
22546 
      iprot.readFieldEnd()
22547 
    iprot.readStructEnd()
22548 
 
22549 
  def write(self, oprot):
22550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22552 
      return
22553 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22554 
    if self.ex is not None:
22555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22556 
      self.ex.write(oprot)
22557 
      oprot.writeFieldEnd()
22558 
    oprot.writeFieldStop()
22559 
    oprot.writeStructEnd()
22560 
 
22561 
  def validate(self):
22562 
    return
22563 
 
22564 
 
22565 
  def __repr__(self):
22566 
    L = ['%s=%r' % (key, value)
22567 
      for key, value in self.__dict__.iteritems()]
22568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22569 
 
22570 
  def __eq__(self, other):
22571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22572 
 
22573 
  def __ne__(self, other):
22574 
    return not (self == other)
22575 
 
22576 
class savePaymentSettlements_args:
22577 
  """
22578 
  Attributes:
22579 
   - settlementDate
22580 
   - paymentGatewayId
4905 varun.gupt 22581 
   - referenceId
4600 varun.gupt 22582 
   - serviceTax
22583 
   - otherCharges
22584 
   - netCollection
22585 
  """
22586 
 
22587 
  thrift_spec = (
22588 
    None, # 0
22589 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22590 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22591 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22592 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22593 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22594 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22595 
  )
22596 
 
4905 varun.gupt 22597 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22598 
    self.settlementDate = settlementDate
22599 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22600 
    self.referenceId = referenceId
4600 varun.gupt 22601 
    self.serviceTax = serviceTax
22602 
    self.otherCharges = otherCharges
22603 
    self.netCollection = netCollection
22604 
 
22605 
  def read(self, iprot):
22606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22608 
      return
22609 
    iprot.readStructBegin()
22610 
    while True:
22611 
      (fname, ftype, fid) = iprot.readFieldBegin()
22612 
      if ftype == TType.STOP:
22613 
        break
22614 
      if fid == 1:
22615 
        if ftype == TType.I64:
22616 
          self.settlementDate = iprot.readI64();
22617 
        else:
22618 
          iprot.skip(ftype)
22619 
      elif fid == 2:
22620 
        if ftype == TType.I64:
22621 
          self.paymentGatewayId = iprot.readI64();
22622 
        else:
22623 
          iprot.skip(ftype)
22624 
      elif fid == 3:
22625 
        if ftype == TType.I64:
4905 varun.gupt 22626 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22627 
        else:
22628 
          iprot.skip(ftype)
22629 
      elif fid == 4:
22630 
        if ftype == TType.DOUBLE:
22631 
          self.serviceTax = iprot.readDouble();
22632 
        else:
22633 
          iprot.skip(ftype)
22634 
      elif fid == 5:
22635 
        if ftype == TType.DOUBLE:
22636 
          self.otherCharges = iprot.readDouble();
22637 
        else:
22638 
          iprot.skip(ftype)
22639 
      elif fid == 6:
22640 
        if ftype == TType.DOUBLE:
22641 
          self.netCollection = iprot.readDouble();
22642 
        else:
22643 
          iprot.skip(ftype)
22644 
      else:
22645 
        iprot.skip(ftype)
22646 
      iprot.readFieldEnd()
22647 
    iprot.readStructEnd()
22648 
 
22649 
  def write(self, oprot):
22650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22652 
      return
22653 
    oprot.writeStructBegin('savePaymentSettlements_args')
22654 
    if self.settlementDate is not None:
22655 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22656 
      oprot.writeI64(self.settlementDate)
22657 
      oprot.writeFieldEnd()
22658 
    if self.paymentGatewayId is not None:
22659 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22660 
      oprot.writeI64(self.paymentGatewayId)
22661 
      oprot.writeFieldEnd()
4905 varun.gupt 22662 
    if self.referenceId is not None:
22663 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22664 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22665 
      oprot.writeFieldEnd()
22666 
    if self.serviceTax is not None:
22667 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22668 
      oprot.writeDouble(self.serviceTax)
22669 
      oprot.writeFieldEnd()
22670 
    if self.otherCharges is not None:
22671 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22672 
      oprot.writeDouble(self.otherCharges)
22673 
      oprot.writeFieldEnd()
22674 
    if self.netCollection is not None:
22675 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22676 
      oprot.writeDouble(self.netCollection)
22677 
      oprot.writeFieldEnd()
22678 
    oprot.writeFieldStop()
22679 
    oprot.writeStructEnd()
22680 
 
22681 
  def validate(self):
22682 
    return
22683 
 
22684 
 
22685 
  def __repr__(self):
22686 
    L = ['%s=%r' % (key, value)
22687 
      for key, value in self.__dict__.iteritems()]
22688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22689 
 
22690 
  def __eq__(self, other):
22691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22692 
 
22693 
  def __ne__(self, other):
22694 
    return not (self == other)
22695 
 
22696 
class savePaymentSettlements_result:
22697 
  """
22698 
  Attributes:
22699 
   - ex
22700 
  """
22701 
 
22702 
  thrift_spec = (
22703 
    None, # 0
22704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22705 
  )
22706 
 
22707 
  def __init__(self, ex=None,):
22708 
    self.ex = ex
22709 
 
22710 
  def read(self, iprot):
22711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22713 
      return
22714 
    iprot.readStructBegin()
22715 
    while True:
22716 
      (fname, ftype, fid) = iprot.readFieldBegin()
22717 
      if ftype == TType.STOP:
22718 
        break
22719 
      if fid == 1:
22720 
        if ftype == TType.STRUCT:
22721 
          self.ex = TransactionServiceException()
22722 
          self.ex.read(iprot)
22723 
        else:
22724 
          iprot.skip(ftype)
22725 
      else:
22726 
        iprot.skip(ftype)
22727 
      iprot.readFieldEnd()
22728 
    iprot.readStructEnd()
22729 
 
22730 
  def write(self, oprot):
22731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22733 
      return
22734 
    oprot.writeStructBegin('savePaymentSettlements_result')
22735 
    if self.ex is not None:
22736 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22737 
      self.ex.write(oprot)
22738 
      oprot.writeFieldEnd()
22739 
    oprot.writeFieldStop()
22740 
    oprot.writeStructEnd()
22741 
 
22742 
  def validate(self):
22743 
    return
22744 
 
22745 
 
22746 
  def __repr__(self):
22747 
    L = ['%s=%r' % (key, value)
22748 
      for key, value in self.__dict__.iteritems()]
22749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22750 
 
22751 
  def __eq__(self, other):
22752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22753 
 
22754 
  def __ne__(self, other):
22755 
    return not (self == other)
22756 
 
22757 
class saveEBSSettlementSummary_args:
22758 
  """
22759 
  Attributes:
22760 
   - settlementId
22761 
   - settlementDate
22762 
   - transactionDateFrom
22763 
   - transactionDateTo
22764 
   - amount
22765 
  """
22766 
 
22767 
  thrift_spec = (
22768 
    None, # 0
22769 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22770 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22771 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22772 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22773 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22774 
  )
22775 
 
22776 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22777 
    self.settlementId = settlementId
22778 
    self.settlementDate = settlementDate
22779 
    self.transactionDateFrom = transactionDateFrom
22780 
    self.transactionDateTo = transactionDateTo
22781 
    self.amount = amount
22782 
 
22783 
  def read(self, iprot):
22784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22786 
      return
22787 
    iprot.readStructBegin()
22788 
    while True:
22789 
      (fname, ftype, fid) = iprot.readFieldBegin()
22790 
      if ftype == TType.STOP:
22791 
        break
22792 
      if fid == 1:
22793 
        if ftype == TType.I64:
22794 
          self.settlementId = iprot.readI64();
22795 
        else:
22796 
          iprot.skip(ftype)
22797 
      elif fid == 2:
22798 
        if ftype == TType.I64:
22799 
          self.settlementDate = iprot.readI64();
22800 
        else:
22801 
          iprot.skip(ftype)
22802 
      elif fid == 3:
22803 
        if ftype == TType.I64:
22804 
          self.transactionDateFrom = iprot.readI64();
22805 
        else:
22806 
          iprot.skip(ftype)
22807 
      elif fid == 4:
22808 
        if ftype == TType.I64:
22809 
          self.transactionDateTo = iprot.readI64();
22810 
        else:
22811 
          iprot.skip(ftype)
22812 
      elif fid == 5:
22813 
        if ftype == TType.DOUBLE:
22814 
          self.amount = iprot.readDouble();
22815 
        else:
22816 
          iprot.skip(ftype)
22817 
      else:
22818 
        iprot.skip(ftype)
22819 
      iprot.readFieldEnd()
22820 
    iprot.readStructEnd()
22821 
 
22822 
  def write(self, oprot):
22823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22825 
      return
22826 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22827 
    if self.settlementId is not None:
22828 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22829 
      oprot.writeI64(self.settlementId)
22830 
      oprot.writeFieldEnd()
22831 
    if self.settlementDate is not None:
22832 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22833 
      oprot.writeI64(self.settlementDate)
22834 
      oprot.writeFieldEnd()
22835 
    if self.transactionDateFrom is not None:
22836 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22837 
      oprot.writeI64(self.transactionDateFrom)
22838 
      oprot.writeFieldEnd()
22839 
    if self.transactionDateTo is not None:
22840 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22841 
      oprot.writeI64(self.transactionDateTo)
22842 
      oprot.writeFieldEnd()
22843 
    if self.amount is not None:
22844 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22845 
      oprot.writeDouble(self.amount)
22846 
      oprot.writeFieldEnd()
22847 
    oprot.writeFieldStop()
22848 
    oprot.writeStructEnd()
22849 
 
22850 
  def validate(self):
22851 
    return
22852 
 
22853 
 
22854 
  def __repr__(self):
22855 
    L = ['%s=%r' % (key, value)
22856 
      for key, value in self.__dict__.iteritems()]
22857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22858 
 
22859 
  def __eq__(self, other):
22860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22861 
 
22862 
  def __ne__(self, other):
22863 
    return not (self == other)
22864 
 
22865 
class saveEBSSettlementSummary_result:
22866 
  """
22867 
  Attributes:
22868 
   - ex
22869 
  """
22870 
 
22871 
  thrift_spec = (
22872 
    None, # 0
22873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22874 
  )
22875 
 
22876 
  def __init__(self, ex=None,):
22877 
    self.ex = ex
22878 
 
22879 
  def read(self, iprot):
22880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22882 
      return
22883 
    iprot.readStructBegin()
22884 
    while True:
22885 
      (fname, ftype, fid) = iprot.readFieldBegin()
22886 
      if ftype == TType.STOP:
22887 
        break
22888 
      if fid == 1:
22889 
        if ftype == TType.STRUCT:
22890 
          self.ex = TransactionServiceException()
22891 
          self.ex.read(iprot)
22892 
        else:
22893 
          iprot.skip(ftype)
22894 
      else:
22895 
        iprot.skip(ftype)
22896 
      iprot.readFieldEnd()
22897 
    iprot.readStructEnd()
22898 
 
22899 
  def write(self, oprot):
22900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22902 
      return
22903 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22904 
    if self.ex is not None:
22905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22906 
      self.ex.write(oprot)
22907 
      oprot.writeFieldEnd()
22908 
    oprot.writeFieldStop()
22909 
    oprot.writeStructEnd()
22910 
 
22911 
  def validate(self):
22912 
    return
22913 
 
22914 
 
22915 
  def __repr__(self):
22916 
    L = ['%s=%r' % (key, value)
22917 
      for key, value in self.__dict__.iteritems()]
22918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22919 
 
22920 
  def __eq__(self, other):
22921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22922 
 
22923 
  def __ne__(self, other):
22924 
    return not (self == other)
22925 
 
5386 phani.kuma 22926 
class getSettlementForPrepaid_args:
4600 varun.gupt 22927 
  """
22928 
  Attributes:
5189 varun.gupt 22929 
   - referenceId
22930 
   - isRefund
4600 varun.gupt 22931 
  """
22932 
 
22933 
  thrift_spec = (
22934 
    None, # 0
5189 varun.gupt 22935 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22936 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22937 
  )
22938 
 
5386 phani.kuma 22939 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22940 
    self.referenceId = referenceId
22941 
    self.isRefund = isRefund
4600 varun.gupt 22942 
 
22943 
  def read(self, iprot):
22944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22946 
      return
22947 
    iprot.readStructBegin()
22948 
    while True:
22949 
      (fname, ftype, fid) = iprot.readFieldBegin()
22950 
      if ftype == TType.STOP:
22951 
        break
22952 
      if fid == 1:
22953 
        if ftype == TType.I64:
5189 varun.gupt 22954 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22955 
        else:
22956 
          iprot.skip(ftype)
5189 varun.gupt 22957 
      elif fid == 2:
22958 
        if ftype == TType.BOOL:
22959 
          self.isRefund = iprot.readBool();
22960 
        else:
22961 
          iprot.skip(ftype)
4600 varun.gupt 22962 
      else:
22963 
        iprot.skip(ftype)
22964 
      iprot.readFieldEnd()
22965 
    iprot.readStructEnd()
22966 
 
22967 
  def write(self, oprot):
22968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22970 
      return
5386 phani.kuma 22971 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22972 
    if self.referenceId is not None:
22973 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22974 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22975 
      oprot.writeFieldEnd()
5386 phani.kuma 22976 
    if self.isRefund is not None:
22977 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22978 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22979 
      oprot.writeFieldEnd()
5386 phani.kuma 22980 
    oprot.writeFieldStop()
22981 
    oprot.writeStructEnd()
22982 
 
22983 
  def validate(self):
22984 
    return
22985 
 
22986 
 
22987 
  def __repr__(self):
22988 
    L = ['%s=%r' % (key, value)
22989 
      for key, value in self.__dict__.iteritems()]
22990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22991 
 
22992 
  def __eq__(self, other):
22993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22994 
 
22995 
  def __ne__(self, other):
22996 
    return not (self == other)
22997 
 
22998 
class getSettlementForPrepaid_result:
22999 
  """
23000 
  Attributes:
23001 
   - success
23002 
   - ex
23003 
  """
23004 
 
23005 
  thrift_spec = (
23006 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23008 
  )
23009 
 
23010 
  def __init__(self, success=None, ex=None,):
23011 
    self.success = success
23012 
    self.ex = ex
23013 
 
23014 
  def read(self, iprot):
23015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23017 
      return
23018 
    iprot.readStructBegin()
23019 
    while True:
23020 
      (fname, ftype, fid) = iprot.readFieldBegin()
23021 
      if ftype == TType.STOP:
23022 
        break
23023 
      if fid == 0:
23024 
        if ftype == TType.STRUCT:
23025 
          self.success = PaymentSettlement()
23026 
          self.success.read(iprot)
23027 
        else:
23028 
          iprot.skip(ftype)
23029 
      elif fid == 1:
23030 
        if ftype == TType.STRUCT:
23031 
          self.ex = TransactionServiceException()
23032 
          self.ex.read(iprot)
23033 
        else:
23034 
          iprot.skip(ftype)
23035 
      else:
23036 
        iprot.skip(ftype)
23037 
      iprot.readFieldEnd()
23038 
    iprot.readStructEnd()
23039 
 
23040 
  def write(self, oprot):
23041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23043 
      return
23044 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23045 
    if self.success is not None:
23046 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23047 
      self.success.write(oprot)
23048 
      oprot.writeFieldEnd()
23049 
    if self.ex is not None:
23050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23051 
      self.ex.write(oprot)
23052 
      oprot.writeFieldEnd()
23053 
    oprot.writeFieldStop()
23054 
    oprot.writeStructEnd()
23055 
 
23056 
  def validate(self):
23057 
    return
23058 
 
23059 
 
23060 
  def __repr__(self):
23061 
    L = ['%s=%r' % (key, value)
23062 
      for key, value in self.__dict__.iteritems()]
23063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23064 
 
23065 
  def __eq__(self, other):
23066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23067 
 
23068 
  def __ne__(self, other):
23069 
    return not (self == other)
23070 
 
23071 
class getSettlementForCod_args:
23072 
  """
23073 
  Attributes:
23074 
   - orderId
23075 
   - isRefund
23076 
  """
23077 
 
23078 
  thrift_spec = (
23079 
    None, # 0
23080 
    (1, TType.I64, 'orderId', None, None, ), # 1
23081 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23082 
  )
23083 
 
23084 
  def __init__(self, orderId=None, isRefund=None,):
23085 
    self.orderId = orderId
23086 
    self.isRefund = isRefund
23087 
 
23088 
  def read(self, iprot):
23089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23091 
      return
23092 
    iprot.readStructBegin()
23093 
    while True:
23094 
      (fname, ftype, fid) = iprot.readFieldBegin()
23095 
      if ftype == TType.STOP:
23096 
        break
23097 
      if fid == 1:
23098 
        if ftype == TType.I64:
23099 
          self.orderId = iprot.readI64();
23100 
        else:
23101 
          iprot.skip(ftype)
23102 
      elif fid == 2:
23103 
        if ftype == TType.BOOL:
23104 
          self.isRefund = iprot.readBool();
23105 
        else:
23106 
          iprot.skip(ftype)
23107 
      else:
23108 
        iprot.skip(ftype)
23109 
      iprot.readFieldEnd()
23110 
    iprot.readStructEnd()
23111 
 
23112 
  def write(self, oprot):
23113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23115 
      return
23116 
    oprot.writeStructBegin('getSettlementForCod_args')
23117 
    if self.orderId is not None:
23118 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23119 
      oprot.writeI64(self.orderId)
23120 
      oprot.writeFieldEnd()
5189 varun.gupt 23121 
    if self.isRefund is not None:
5386 phani.kuma 23122 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23123 
      oprot.writeBool(self.isRefund)
23124 
      oprot.writeFieldEnd()
4600 varun.gupt 23125 
    oprot.writeFieldStop()
23126 
    oprot.writeStructEnd()
23127 
 
23128 
  def validate(self):
23129 
    return
23130 
 
23131 
 
23132 
  def __repr__(self):
23133 
    L = ['%s=%r' % (key, value)
23134 
      for key, value in self.__dict__.iteritems()]
23135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23136 
 
23137 
  def __eq__(self, other):
23138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23139 
 
23140 
  def __ne__(self, other):
23141 
    return not (self == other)
23142 
 
5386 phani.kuma 23143 
class getSettlementForCod_result:
4600 varun.gupt 23144 
  """
23145 
  Attributes:
23146 
   - success
23147 
   - ex
23148 
  """
23149 
 
23150 
  thrift_spec = (
23151 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23153 
  )
23154 
 
23155 
  def __init__(self, success=None, ex=None,):
23156 
    self.success = success
23157 
    self.ex = ex
23158 
 
23159 
  def read(self, iprot):
23160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23162 
      return
23163 
    iprot.readStructBegin()
23164 
    while True:
23165 
      (fname, ftype, fid) = iprot.readFieldBegin()
23166 
      if ftype == TType.STOP:
23167 
        break
23168 
      if fid == 0:
23169 
        if ftype == TType.STRUCT:
23170 
          self.success = PaymentSettlement()
23171 
          self.success.read(iprot)
23172 
        else:
23173 
          iprot.skip(ftype)
23174 
      elif fid == 1:
23175 
        if ftype == TType.STRUCT:
23176 
          self.ex = TransactionServiceException()
23177 
          self.ex.read(iprot)
23178 
        else:
23179 
          iprot.skip(ftype)
23180 
      else:
23181 
        iprot.skip(ftype)
23182 
      iprot.readFieldEnd()
23183 
    iprot.readStructEnd()
23184 
 
23185 
  def write(self, oprot):
23186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23188 
      return
5386 phani.kuma 23189 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23190 
    if self.success is not None:
23191 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23192 
      self.success.write(oprot)
23193 
      oprot.writeFieldEnd()
23194 
    if self.ex is not None:
23195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23196 
      self.ex.write(oprot)
23197 
      oprot.writeFieldEnd()
23198 
    oprot.writeFieldStop()
23199 
    oprot.writeStructEnd()
23200 
 
23201 
  def validate(self):
23202 
    return
23203 
 
23204 
 
23205 
  def __repr__(self):
23206 
    L = ['%s=%r' % (key, value)
23207 
      for key, value in self.__dict__.iteritems()]
23208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23209 
 
23210 
  def __eq__(self, other):
23211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23212 
 
23213 
  def __ne__(self, other):
23214 
    return not (self == other)
23215 
 
23216 
class getEBSSettlementSummaries_args:
23217 
 
23218 
  thrift_spec = (
23219 
  )
23220 
 
23221 
  def read(self, iprot):
23222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23224 
      return
23225 
    iprot.readStructBegin()
23226 
    while True:
23227 
      (fname, ftype, fid) = iprot.readFieldBegin()
23228 
      if ftype == TType.STOP:
23229 
        break
23230 
      else:
23231 
        iprot.skip(ftype)
23232 
      iprot.readFieldEnd()
23233 
    iprot.readStructEnd()
23234 
 
23235 
  def write(self, oprot):
23236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23238 
      return
23239 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23240 
    oprot.writeFieldStop()
23241 
    oprot.writeStructEnd()
23242 
 
23243 
  def validate(self):
23244 
    return
23245 
 
23246 
 
23247 
  def __repr__(self):
23248 
    L = ['%s=%r' % (key, value)
23249 
      for key, value in self.__dict__.iteritems()]
23250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23251 
 
23252 
  def __eq__(self, other):
23253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23254 
 
23255 
  def __ne__(self, other):
23256 
    return not (self == other)
23257 
 
23258 
class getEBSSettlementSummaries_result:
23259 
  """
23260 
  Attributes:
23261 
   - success
23262 
   - ex
23263 
  """
23264 
 
23265 
  thrift_spec = (
23266 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23268 
  )
23269 
 
23270 
  def __init__(self, success=None, ex=None,):
23271 
    self.success = success
23272 
    self.ex = ex
23273 
 
23274 
  def read(self, iprot):
23275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23277 
      return
23278 
    iprot.readStructBegin()
23279 
    while True:
23280 
      (fname, ftype, fid) = iprot.readFieldBegin()
23281 
      if ftype == TType.STOP:
23282 
        break
23283 
      if fid == 0:
23284 
        if ftype == TType.MAP:
23285 
          self.success = {}
6031 rajveer 23286 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
23287 
          for _i515 in xrange(_size511):
23288 
            _key516 = iprot.readI64();
23289 
            _val517 = iprot.readString();
23290 
            self.success[_key516] = _val517
4600 varun.gupt 23291 
          iprot.readMapEnd()
23292 
        else:
23293 
          iprot.skip(ftype)
23294 
      elif fid == 1:
23295 
        if ftype == TType.STRUCT:
23296 
          self.ex = TransactionServiceException()
23297 
          self.ex.read(iprot)
23298 
        else:
23299 
          iprot.skip(ftype)
23300 
      else:
23301 
        iprot.skip(ftype)
23302 
      iprot.readFieldEnd()
23303 
    iprot.readStructEnd()
23304 
 
23305 
  def write(self, oprot):
23306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23308 
      return
23309 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23310 
    if self.success is not None:
23311 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23312 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 23313 
      for kiter518,viter519 in self.success.items():
23314 
        oprot.writeI64(kiter518)
23315 
        oprot.writeString(viter519)
4600 varun.gupt 23316 
      oprot.writeMapEnd()
23317 
      oprot.writeFieldEnd()
23318 
    if self.ex is not None:
23319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23320 
      self.ex.write(oprot)
23321 
      oprot.writeFieldEnd()
23322 
    oprot.writeFieldStop()
23323 
    oprot.writeStructEnd()
23324 
 
23325 
  def validate(self):
23326 
    return
23327 
 
23328 
 
23329 
  def __repr__(self):
23330 
    L = ['%s=%r' % (key, value)
23331 
      for key, value in self.__dict__.iteritems()]
23332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23333 
 
23334 
  def __eq__(self, other):
23335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23336 
 
23337 
  def __ne__(self, other):
23338 
    return not (self == other)
23339 
 
23340 
class markEBSSettlementUploaded_args:
23341 
  """
23342 
  Attributes:
23343 
   - settlementId
23344 
  """
23345 
 
23346 
  thrift_spec = (
23347 
    None, # 0
23348 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23349 
  )
23350 
 
23351 
  def __init__(self, settlementId=None,):
23352 
    self.settlementId = settlementId
23353 
 
23354 
  def read(self, iprot):
23355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23357 
      return
23358 
    iprot.readStructBegin()
23359 
    while True:
23360 
      (fname, ftype, fid) = iprot.readFieldBegin()
23361 
      if ftype == TType.STOP:
23362 
        break
23363 
      if fid == 1:
23364 
        if ftype == TType.I64:
23365 
          self.settlementId = iprot.readI64();
23366 
        else:
23367 
          iprot.skip(ftype)
23368 
      else:
23369 
        iprot.skip(ftype)
23370 
      iprot.readFieldEnd()
23371 
    iprot.readStructEnd()
23372 
 
23373 
  def write(self, oprot):
23374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23376 
      return
23377 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23378 
    if self.settlementId is not None:
23379 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23380 
      oprot.writeI64(self.settlementId)
23381 
      oprot.writeFieldEnd()
23382 
    oprot.writeFieldStop()
23383 
    oprot.writeStructEnd()
23384 
 
23385 
  def validate(self):
23386 
    return
23387 
 
23388 
 
23389 
  def __repr__(self):
23390 
    L = ['%s=%r' % (key, value)
23391 
      for key, value in self.__dict__.iteritems()]
23392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23393 
 
23394 
  def __eq__(self, other):
23395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23396 
 
23397 
  def __ne__(self, other):
23398 
    return not (self == other)
23399 
 
23400 
class markEBSSettlementUploaded_result:
23401 
  """
23402 
  Attributes:
23403 
   - ex
23404 
  """
23405 
 
23406 
  thrift_spec = (
23407 
    None, # 0
23408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23409 
  )
23410 
 
23411 
  def __init__(self, ex=None,):
23412 
    self.ex = ex
23413 
 
23414 
  def read(self, iprot):
23415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23417 
      return
23418 
    iprot.readStructBegin()
23419 
    while True:
23420 
      (fname, ftype, fid) = iprot.readFieldBegin()
23421 
      if ftype == TType.STOP:
23422 
        break
23423 
      if fid == 1:
23424 
        if ftype == TType.STRUCT:
23425 
          self.ex = TransactionServiceException()
23426 
          self.ex.read(iprot)
23427 
        else:
23428 
          iprot.skip(ftype)
23429 
      else:
23430 
        iprot.skip(ftype)
23431 
      iprot.readFieldEnd()
23432 
    iprot.readStructEnd()
23433 
 
23434 
  def write(self, oprot):
23435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23437 
      return
23438 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23439 
    if self.ex is not None:
23440 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23441 
      self.ex.write(oprot)
23442 
      oprot.writeFieldEnd()
23443 
    oprot.writeFieldStop()
23444 
    oprot.writeStructEnd()
23445 
 
23446 
  def validate(self):
23447 
    return
23448 
 
23449 
 
23450 
  def __repr__(self):
23451 
    L = ['%s=%r' % (key, value)
23452 
      for key, value in self.__dict__.iteritems()]
23453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23454 
 
23455 
  def __eq__(self, other):
23456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23457 
 
23458 
  def __ne__(self, other):
23459 
    return not (self == other)
23460 
 
23461 
class getEBSSettlementDate_args:
23462 
  """
23463 
  Attributes:
23464 
   - settlementId
23465 
  """
23466 
 
23467 
  thrift_spec = (
23468 
    None, # 0
23469 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23470 
  )
23471 
 
23472 
  def __init__(self, settlementId=None,):
23473 
    self.settlementId = settlementId
23474 
 
23475 
  def read(self, iprot):
23476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23478 
      return
23479 
    iprot.readStructBegin()
23480 
    while True:
23481 
      (fname, ftype, fid) = iprot.readFieldBegin()
23482 
      if ftype == TType.STOP:
23483 
        break
23484 
      if fid == 1:
23485 
        if ftype == TType.I64:
23486 
          self.settlementId = iprot.readI64();
23487 
        else:
23488 
          iprot.skip(ftype)
23489 
      else:
23490 
        iprot.skip(ftype)
23491 
      iprot.readFieldEnd()
23492 
    iprot.readStructEnd()
23493 
 
23494 
  def write(self, oprot):
23495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23497 
      return
23498 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23499 
    if self.settlementId is not None:
23500 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23501 
      oprot.writeI64(self.settlementId)
23502 
      oprot.writeFieldEnd()
23503 
    oprot.writeFieldStop()
23504 
    oprot.writeStructEnd()
23505 
 
23506 
  def validate(self):
23507 
    return
23508 
 
23509 
 
23510 
  def __repr__(self):
23511 
    L = ['%s=%r' % (key, value)
23512 
      for key, value in self.__dict__.iteritems()]
23513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23514 
 
23515 
  def __eq__(self, other):
23516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23517 
 
23518 
  def __ne__(self, other):
23519 
    return not (self == other)
23520 
 
23521 
class getEBSSettlementDate_result:
23522 
  """
23523 
  Attributes:
23524 
   - success
23525 
   - ex
23526 
  """
23527 
 
23528 
  thrift_spec = (
23529 
    (0, TType.I64, 'success', None, None, ), # 0
23530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23531 
  )
23532 
 
23533 
  def __init__(self, success=None, ex=None,):
23534 
    self.success = success
23535 
    self.ex = ex
23536 
 
23537 
  def read(self, iprot):
23538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23540 
      return
23541 
    iprot.readStructBegin()
23542 
    while True:
23543 
      (fname, ftype, fid) = iprot.readFieldBegin()
23544 
      if ftype == TType.STOP:
23545 
        break
23546 
      if fid == 0:
23547 
        if ftype == TType.I64:
23548 
          self.success = iprot.readI64();
23549 
        else:
23550 
          iprot.skip(ftype)
23551 
      elif fid == 1:
23552 
        if ftype == TType.STRUCT:
23553 
          self.ex = TransactionServiceException()
23554 
          self.ex.read(iprot)
23555 
        else:
23556 
          iprot.skip(ftype)
23557 
      else:
23558 
        iprot.skip(ftype)
23559 
      iprot.readFieldEnd()
23560 
    iprot.readStructEnd()
23561 
 
23562 
  def write(self, oprot):
23563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23565 
      return
23566 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23567 
    if self.success is not None:
23568 
      oprot.writeFieldBegin('success', TType.I64, 0)
23569 
      oprot.writeI64(self.success)
23570 
      oprot.writeFieldEnd()
23571 
    if self.ex is not None:
23572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23573 
      self.ex.write(oprot)
23574 
      oprot.writeFieldEnd()
23575 
    oprot.writeFieldStop()
23576 
    oprot.writeStructEnd()
23577 
 
23578 
  def validate(self):
23579 
    return
23580 
 
23581 
 
23582 
  def __repr__(self):
23583 
    L = ['%s=%r' % (key, value)
23584 
      for key, value in self.__dict__.iteritems()]
23585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23586 
 
23587 
  def __eq__(self, other):
23588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23589 
 
23590 
  def __ne__(self, other):
23591 
    return not (self == other)
4715 varun.gupt 23592 
 
23593 
class getSettlementsByDate_args:
23594 
  """
23595 
  Attributes:
23596 
   - settlementDateFrom
23597 
   - settlementDateTo
23598 
   - isRefund
23599 
  """
23600 
 
23601 
  thrift_spec = (
23602 
    None, # 0
23603 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23604 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23605 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23606 
  )
23607 
 
23608 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23609 
    self.settlementDateFrom = settlementDateFrom
23610 
    self.settlementDateTo = settlementDateTo
23611 
    self.isRefund = isRefund
23612 
 
23613 
  def read(self, iprot):
23614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23616 
      return
23617 
    iprot.readStructBegin()
23618 
    while True:
23619 
      (fname, ftype, fid) = iprot.readFieldBegin()
23620 
      if ftype == TType.STOP:
23621 
        break
23622 
      if fid == 1:
23623 
        if ftype == TType.I64:
23624 
          self.settlementDateFrom = iprot.readI64();
23625 
        else:
23626 
          iprot.skip(ftype)
23627 
      elif fid == 2:
23628 
        if ftype == TType.I64:
23629 
          self.settlementDateTo = iprot.readI64();
23630 
        else:
23631 
          iprot.skip(ftype)
23632 
      elif fid == 3:
23633 
        if ftype == TType.BOOL:
23634 
          self.isRefund = iprot.readBool();
23635 
        else:
23636 
          iprot.skip(ftype)
23637 
      else:
23638 
        iprot.skip(ftype)
23639 
      iprot.readFieldEnd()
23640 
    iprot.readStructEnd()
23641 
 
23642 
  def write(self, oprot):
23643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23645 
      return
23646 
    oprot.writeStructBegin('getSettlementsByDate_args')
23647 
    if self.settlementDateFrom is not None:
23648 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23649 
      oprot.writeI64(self.settlementDateFrom)
23650 
      oprot.writeFieldEnd()
23651 
    if self.settlementDateTo is not None:
23652 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23653 
      oprot.writeI64(self.settlementDateTo)
23654 
      oprot.writeFieldEnd()
23655 
    if self.isRefund is not None:
23656 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23657 
      oprot.writeBool(self.isRefund)
23658 
      oprot.writeFieldEnd()
23659 
    oprot.writeFieldStop()
23660 
    oprot.writeStructEnd()
23661 
 
23662 
  def validate(self):
23663 
    return
23664 
 
23665 
 
23666 
  def __repr__(self):
23667 
    L = ['%s=%r' % (key, value)
23668 
      for key, value in self.__dict__.iteritems()]
23669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23670 
 
23671 
  def __eq__(self, other):
23672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23673 
 
23674 
  def __ne__(self, other):
23675 
    return not (self == other)
23676 
 
23677 
class getSettlementsByDate_result:
23678 
  """
23679 
  Attributes:
23680 
   - success
23681 
   - ex
23682 
  """
23683 
 
23684 
  thrift_spec = (
23685 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23687 
  )
23688 
 
23689 
  def __init__(self, success=None, ex=None,):
23690 
    self.success = success
23691 
    self.ex = ex
23692 
 
23693 
  def read(self, iprot):
23694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23696 
      return
23697 
    iprot.readStructBegin()
23698 
    while True:
23699 
      (fname, ftype, fid) = iprot.readFieldBegin()
23700 
      if ftype == TType.STOP:
23701 
        break
23702 
      if fid == 0:
23703 
        if ftype == TType.LIST:
23704 
          self.success = []
6031 rajveer 23705 
          (_etype523, _size520) = iprot.readListBegin()
23706 
          for _i524 in xrange(_size520):
23707 
            _elem525 = PaymentSettlement()
23708 
            _elem525.read(iprot)
23709 
            self.success.append(_elem525)
4715 varun.gupt 23710 
          iprot.readListEnd()
23711 
        else:
23712 
          iprot.skip(ftype)
23713 
      elif fid == 1:
23714 
        if ftype == TType.STRUCT:
23715 
          self.ex = TransactionServiceException()
23716 
          self.ex.read(iprot)
23717 
        else:
23718 
          iprot.skip(ftype)
23719 
      else:
23720 
        iprot.skip(ftype)
23721 
      iprot.readFieldEnd()
23722 
    iprot.readStructEnd()
23723 
 
23724 
  def write(self, oprot):
23725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23727 
      return
23728 
    oprot.writeStructBegin('getSettlementsByDate_result')
23729 
    if self.success is not None:
23730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23732 
      for iter526 in self.success:
23733 
        iter526.write(oprot)
4715 varun.gupt 23734 
      oprot.writeListEnd()
23735 
      oprot.writeFieldEnd()
23736 
    if self.ex is not None:
23737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23738 
      self.ex.write(oprot)
23739 
      oprot.writeFieldEnd()
23740 
    oprot.writeFieldStop()
23741 
    oprot.writeStructEnd()
23742 
 
23743 
  def validate(self):
23744 
    return
23745 
 
23746 
 
23747 
  def __repr__(self):
23748 
    L = ['%s=%r' % (key, value)
23749 
      for key, value in self.__dict__.iteritems()]
23750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23751 
 
23752 
  def __eq__(self, other):
23753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23754 
 
23755 
  def __ne__(self, other):
23756 
    return not (self == other)
23757 
 
23758 
class getReshippedOrderIds_args:
23759 
  """
23760 
  Attributes:
23761 
   - orderIds
23762 
  """
23763 
 
23764 
  thrift_spec = (
23765 
    None, # 0
23766 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23767 
  )
23768 
 
23769 
  def __init__(self, orderIds=None,):
23770 
    self.orderIds = orderIds
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.LIST:
23783 
          self.orderIds = []
6031 rajveer 23784 
          (_etype530, _size527) = iprot.readListBegin()
23785 
          for _i531 in xrange(_size527):
23786 
            _elem532 = iprot.readI64();
23787 
            self.orderIds.append(_elem532)
4715 varun.gupt 23788 
          iprot.readListEnd()
23789 
        else:
23790 
          iprot.skip(ftype)
23791 
      else:
23792 
        iprot.skip(ftype)
23793 
      iprot.readFieldEnd()
23794 
    iprot.readStructEnd()
23795 
 
23796 
  def write(self, oprot):
23797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23799 
      return
23800 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23801 
    if self.orderIds is not None:
23802 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23803 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23804 
      for iter533 in self.orderIds:
23805 
        oprot.writeI64(iter533)
4715 varun.gupt 23806 
      oprot.writeListEnd()
23807 
      oprot.writeFieldEnd()
23808 
    oprot.writeFieldStop()
23809 
    oprot.writeStructEnd()
23810 
 
23811 
  def validate(self):
23812 
    return
23813 
 
23814 
 
23815 
  def __repr__(self):
23816 
    L = ['%s=%r' % (key, value)
23817 
      for key, value in self.__dict__.iteritems()]
23818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23819 
 
23820 
  def __eq__(self, other):
23821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23822 
 
23823 
  def __ne__(self, other):
23824 
    return not (self == other)
23825 
 
23826 
class getReshippedOrderIds_result:
23827 
  """
23828 
  Attributes:
23829 
   - success
23830 
   - ex
23831 
  """
23832 
 
23833 
  thrift_spec = (
23834 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23836 
  )
23837 
 
23838 
  def __init__(self, success=None, ex=None,):
23839 
    self.success = success
23840 
    self.ex = ex
23841 
 
23842 
  def read(self, iprot):
23843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23845 
      return
23846 
    iprot.readStructBegin()
23847 
    while True:
23848 
      (fname, ftype, fid) = iprot.readFieldBegin()
23849 
      if ftype == TType.STOP:
23850 
        break
23851 
      if fid == 0:
23852 
        if ftype == TType.LIST:
23853 
          self.success = []
6031 rajveer 23854 
          (_etype537, _size534) = iprot.readListBegin()
23855 
          for _i538 in xrange(_size534):
23856 
            _elem539 = iprot.readI64();
23857 
            self.success.append(_elem539)
4715 varun.gupt 23858 
          iprot.readListEnd()
23859 
        else:
23860 
          iprot.skip(ftype)
23861 
      elif fid == 1:
23862 
        if ftype == TType.STRUCT:
23863 
          self.ex = TransactionServiceException()
23864 
          self.ex.read(iprot)
23865 
        else:
23866 
          iprot.skip(ftype)
23867 
      else:
23868 
        iprot.skip(ftype)
23869 
      iprot.readFieldEnd()
23870 
    iprot.readStructEnd()
23871 
 
23872 
  def write(self, oprot):
23873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23875 
      return
23876 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23877 
    if self.success is not None:
23878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23879 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23880 
      for iter540 in self.success:
23881 
        oprot.writeI64(iter540)
4715 varun.gupt 23882 
      oprot.writeListEnd()
23883 
      oprot.writeFieldEnd()
23884 
    if self.ex is not None:
23885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23886 
      self.ex.write(oprot)
23887 
      oprot.writeFieldEnd()
23888 
    oprot.writeFieldStop()
23889 
    oprot.writeStructEnd()
23890 
 
23891 
  def validate(self):
23892 
    return
23893 
 
23894 
 
23895 
  def __repr__(self):
23896 
    L = ['%s=%r' % (key, value)
23897 
      for key, value in self.__dict__.iteritems()]
23898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23899 
 
23900 
  def __eq__(self, other):
23901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23902 
 
23903 
  def __ne__(self, other):
23904 
    return not (self == other)
4757 mandeep.dh 23905 
 
5481 phani.kuma 23906 
class getBilledOrders_args:
4875 varun.gupt 23907 
  """
23908 
  Attributes:
23909 
   - vendorId
5481 phani.kuma 23910 
   - onlyVendorNotPaid
23911 
   - billingDateFrom
23912 
   - billingDateTo
4875 varun.gupt 23913 
  """
23914 
 
23915 
  thrift_spec = (
23916 
    None, # 0
23917 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23918 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23919 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23920 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23921 
  )
23922 
 
5481 phani.kuma 23923 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23924 
    self.vendorId = vendorId
5481 phani.kuma 23925 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23926 
    self.billingDateFrom = billingDateFrom
23927 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23928 
 
23929 
  def read(self, iprot):
23930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23932 
      return
23933 
    iprot.readStructBegin()
23934 
    while True:
23935 
      (fname, ftype, fid) = iprot.readFieldBegin()
23936 
      if ftype == TType.STOP:
23937 
        break
23938 
      if fid == 1:
23939 
        if ftype == TType.I64:
23940 
          self.vendorId = iprot.readI64();
23941 
        else:
23942 
          iprot.skip(ftype)
5481 phani.kuma 23943 
      elif fid == 2:
23944 
        if ftype == TType.BOOL:
23945 
          self.onlyVendorNotPaid = iprot.readBool();
23946 
        else:
23947 
          iprot.skip(ftype)
23948 
      elif fid == 3:
23949 
        if ftype == TType.I64:
23950 
          self.billingDateFrom = iprot.readI64();
23951 
        else:
23952 
          iprot.skip(ftype)
23953 
      elif fid == 4:
23954 
        if ftype == TType.I64:
23955 
          self.billingDateTo = iprot.readI64();
23956 
        else:
23957 
          iprot.skip(ftype)
4875 varun.gupt 23958 
      else:
23959 
        iprot.skip(ftype)
23960 
      iprot.readFieldEnd()
23961 
    iprot.readStructEnd()
23962 
 
23963 
  def write(self, oprot):
23964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23966 
      return
5481 phani.kuma 23967 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23968 
    if self.vendorId is not None:
23969 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23970 
      oprot.writeI64(self.vendorId)
23971 
      oprot.writeFieldEnd()
5481 phani.kuma 23972 
    if self.onlyVendorNotPaid is not None:
23973 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23974 
      oprot.writeBool(self.onlyVendorNotPaid)
23975 
      oprot.writeFieldEnd()
23976 
    if self.billingDateFrom is not None:
23977 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23978 
      oprot.writeI64(self.billingDateFrom)
23979 
      oprot.writeFieldEnd()
23980 
    if self.billingDateTo is not None:
23981 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23982 
      oprot.writeI64(self.billingDateTo)
23983 
      oprot.writeFieldEnd()
4875 varun.gupt 23984 
    oprot.writeFieldStop()
23985 
    oprot.writeStructEnd()
23986 
 
23987 
  def validate(self):
23988 
    return
23989 
 
23990 
 
23991 
  def __repr__(self):
23992 
    L = ['%s=%r' % (key, value)
23993 
      for key, value in self.__dict__.iteritems()]
23994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23995 
 
23996 
  def __eq__(self, other):
23997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23998 
 
23999 
  def __ne__(self, other):
24000 
    return not (self == other)
24001 
 
5481 phani.kuma 24002 
class getBilledOrders_result:
4875 varun.gupt 24003 
  """
24004 
  Attributes:
24005 
   - success
24006 
   - ex
24007 
  """
24008 
 
24009 
  thrift_spec = (
24010 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24012 
  )
24013 
 
24014 
  def __init__(self, success=None, ex=None,):
24015 
    self.success = success
24016 
    self.ex = ex
24017 
 
24018 
  def read(self, iprot):
24019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24021 
      return
24022 
    iprot.readStructBegin()
24023 
    while True:
24024 
      (fname, ftype, fid) = iprot.readFieldBegin()
24025 
      if ftype == TType.STOP:
24026 
        break
24027 
      if fid == 0:
24028 
        if ftype == TType.LIST:
24029 
          self.success = []
6031 rajveer 24030 
          (_etype544, _size541) = iprot.readListBegin()
24031 
          for _i545 in xrange(_size541):
24032 
            _elem546 = Order()
24033 
            _elem546.read(iprot)
24034 
            self.success.append(_elem546)
4875 varun.gupt 24035 
          iprot.readListEnd()
24036 
        else:
24037 
          iprot.skip(ftype)
24038 
      elif fid == 1:
24039 
        if ftype == TType.STRUCT:
24040 
          self.ex = TransactionServiceException()
24041 
          self.ex.read(iprot)
24042 
        else:
24043 
          iprot.skip(ftype)
24044 
      else:
24045 
        iprot.skip(ftype)
24046 
      iprot.readFieldEnd()
24047 
    iprot.readStructEnd()
24048 
 
24049 
  def write(self, oprot):
24050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24052 
      return
5481 phani.kuma 24053 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24054 
    if self.success is not None:
24055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24056 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24057 
      for iter547 in self.success:
24058 
        iter547.write(oprot)
4875 varun.gupt 24059 
      oprot.writeListEnd()
24060 
      oprot.writeFieldEnd()
24061 
    if self.ex is not None:
24062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24063 
      self.ex.write(oprot)
24064 
      oprot.writeFieldEnd()
24065 
    oprot.writeFieldStop()
24066 
    oprot.writeStructEnd()
24067 
 
24068 
  def validate(self):
24069 
    return
24070 
 
24071 
 
24072 
  def __repr__(self):
24073 
    L = ['%s=%r' % (key, value)
24074 
      for key, value in self.__dict__.iteritems()]
24075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24076 
 
24077 
  def __eq__(self, other):
24078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24079 
 
24080 
  def __ne__(self, other):
24081 
    return not (self == other)
5031 varun.gupt 24082 
 
24083 
class getStatusDistributionOfOrders_args:
24084 
  """
24085 
  Attributes:
24086 
   - startDate
24087 
   - endDate
24088 
  """
24089 
 
24090 
  thrift_spec = (
24091 
    None, # 0
24092 
    (1, TType.I64, 'startDate', None, None, ), # 1
24093 
    (2, TType.I64, 'endDate', None, None, ), # 2
24094 
  )
24095 
 
24096 
  def __init__(self, startDate=None, endDate=None,):
24097 
    self.startDate = startDate
24098 
    self.endDate = endDate
24099 
 
24100 
  def read(self, iprot):
24101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24103 
      return
24104 
    iprot.readStructBegin()
24105 
    while True:
24106 
      (fname, ftype, fid) = iprot.readFieldBegin()
24107 
      if ftype == TType.STOP:
24108 
        break
24109 
      if fid == 1:
24110 
        if ftype == TType.I64:
24111 
          self.startDate = iprot.readI64();
24112 
        else:
24113 
          iprot.skip(ftype)
24114 
      elif fid == 2:
24115 
        if ftype == TType.I64:
24116 
          self.endDate = iprot.readI64();
24117 
        else:
24118 
          iprot.skip(ftype)
24119 
      else:
24120 
        iprot.skip(ftype)
24121 
      iprot.readFieldEnd()
24122 
    iprot.readStructEnd()
24123 
 
24124 
  def write(self, oprot):
24125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24127 
      return
24128 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24129 
    if self.startDate is not None:
24130 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24131 
      oprot.writeI64(self.startDate)
24132 
      oprot.writeFieldEnd()
24133 
    if self.endDate is not None:
24134 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24135 
      oprot.writeI64(self.endDate)
24136 
      oprot.writeFieldEnd()
24137 
    oprot.writeFieldStop()
24138 
    oprot.writeStructEnd()
24139 
 
24140 
  def validate(self):
24141 
    return
24142 
 
24143 
 
24144 
  def __repr__(self):
24145 
    L = ['%s=%r' % (key, value)
24146 
      for key, value in self.__dict__.iteritems()]
24147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24148 
 
24149 
  def __eq__(self, other):
24150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24151 
 
24152 
  def __ne__(self, other):
24153 
    return not (self == other)
24154 
 
24155 
class getStatusDistributionOfOrders_result:
24156 
  """
24157 
  Attributes:
24158 
   - success
24159 
   - ex
24160 
  """
24161 
 
24162 
  thrift_spec = (
24163 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24165 
  )
24166 
 
24167 
  def __init__(self, success=None, ex=None,):
24168 
    self.success = success
24169 
    self.ex = ex
24170 
 
24171 
  def read(self, iprot):
24172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24174 
      return
24175 
    iprot.readStructBegin()
24176 
    while True:
24177 
      (fname, ftype, fid) = iprot.readFieldBegin()
24178 
      if ftype == TType.STOP:
24179 
        break
24180 
      if fid == 0:
24181 
        if ftype == TType.MAP:
24182 
          self.success = {}
6031 rajveer 24183 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
24184 
          for _i552 in xrange(_size548):
24185 
            _key553 = iprot.readI64();
24186 
            _val554 = iprot.readI64();
24187 
            self.success[_key553] = _val554
5031 varun.gupt 24188 
          iprot.readMapEnd()
24189 
        else:
24190 
          iprot.skip(ftype)
24191 
      elif fid == 1:
24192 
        if ftype == TType.STRUCT:
24193 
          self.ex = TransactionServiceException()
24194 
          self.ex.read(iprot)
24195 
        else:
24196 
          iprot.skip(ftype)
24197 
      else:
24198 
        iprot.skip(ftype)
24199 
      iprot.readFieldEnd()
24200 
    iprot.readStructEnd()
24201 
 
24202 
  def write(self, oprot):
24203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24205 
      return
24206 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24207 
    if self.success is not None:
24208 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24209 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 24210 
      for kiter555,viter556 in self.success.items():
24211 
        oprot.writeI64(kiter555)
24212 
        oprot.writeI64(viter556)
5031 varun.gupt 24213 
      oprot.writeMapEnd()
24214 
      oprot.writeFieldEnd()
24215 
    if self.ex is not None:
24216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24217 
      self.ex.write(oprot)
24218 
      oprot.writeFieldEnd()
24219 
    oprot.writeFieldStop()
24220 
    oprot.writeStructEnd()
24221 
 
24222 
  def validate(self):
24223 
    return
24224 
 
24225 
 
24226 
  def __repr__(self):
24227 
    L = ['%s=%r' % (key, value)
24228 
      for key, value in self.__dict__.iteritems()]
24229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24230 
 
24231 
  def __eq__(self, other):
24232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24233 
 
24234 
  def __ne__(self, other):
24235 
    return not (self == other)
5067 varun.gupt 24236 
 
24237 
class getOrderIdsForStatus_args:
24238 
  """
24239 
  Attributes:
24240 
   - status
24241 
   - startDatetime
24242 
   - endDatetime
24243 
  """
24244 
 
24245 
  thrift_spec = (
24246 
    None, # 0
24247 
    (1, TType.I64, 'status', None, None, ), # 1
24248 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24249 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24250 
  )
24251 
 
24252 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24253 
    self.status = status
24254 
    self.startDatetime = startDatetime
24255 
    self.endDatetime = endDatetime
24256 
 
24257 
  def read(self, iprot):
24258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24260 
      return
24261 
    iprot.readStructBegin()
24262 
    while True:
24263 
      (fname, ftype, fid) = iprot.readFieldBegin()
24264 
      if ftype == TType.STOP:
24265 
        break
24266 
      if fid == 1:
24267 
        if ftype == TType.I64:
24268 
          self.status = iprot.readI64();
24269 
        else:
24270 
          iprot.skip(ftype)
24271 
      elif fid == 2:
24272 
        if ftype == TType.I64:
24273 
          self.startDatetime = iprot.readI64();
24274 
        else:
24275 
          iprot.skip(ftype)
24276 
      elif fid == 3:
24277 
        if ftype == TType.I64:
24278 
          self.endDatetime = iprot.readI64();
24279 
        else:
24280 
          iprot.skip(ftype)
24281 
      else:
24282 
        iprot.skip(ftype)
24283 
      iprot.readFieldEnd()
24284 
    iprot.readStructEnd()
24285 
 
24286 
  def write(self, oprot):
24287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24289 
      return
24290 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24291 
    if self.status is not None:
24292 
      oprot.writeFieldBegin('status', TType.I64, 1)
24293 
      oprot.writeI64(self.status)
24294 
      oprot.writeFieldEnd()
24295 
    if self.startDatetime is not None:
24296 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24297 
      oprot.writeI64(self.startDatetime)
24298 
      oprot.writeFieldEnd()
24299 
    if self.endDatetime is not None:
24300 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24301 
      oprot.writeI64(self.endDatetime)
24302 
      oprot.writeFieldEnd()
24303 
    oprot.writeFieldStop()
24304 
    oprot.writeStructEnd()
24305 
 
24306 
  def validate(self):
24307 
    return
24308 
 
24309 
 
24310 
  def __repr__(self):
24311 
    L = ['%s=%r' % (key, value)
24312 
      for key, value in self.__dict__.iteritems()]
24313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24314 
 
24315 
  def __eq__(self, other):
24316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24317 
 
24318 
  def __ne__(self, other):
24319 
    return not (self == other)
24320 
 
24321 
class getOrderIdsForStatus_result:
24322 
  """
24323 
  Attributes:
24324 
   - success
24325 
   - ex
24326 
  """
24327 
 
24328 
  thrift_spec = (
24329 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24331 
  )
24332 
 
24333 
  def __init__(self, success=None, ex=None,):
24334 
    self.success = success
24335 
    self.ex = ex
24336 
 
24337 
  def read(self, iprot):
24338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24340 
      return
24341 
    iprot.readStructBegin()
24342 
    while True:
24343 
      (fname, ftype, fid) = iprot.readFieldBegin()
24344 
      if ftype == TType.STOP:
24345 
        break
24346 
      if fid == 0:
24347 
        if ftype == TType.LIST:
24348 
          self.success = []
6031 rajveer 24349 
          (_etype560, _size557) = iprot.readListBegin()
24350 
          for _i561 in xrange(_size557):
24351 
            _elem562 = iprot.readI64();
24352 
            self.success.append(_elem562)
5067 varun.gupt 24353 
          iprot.readListEnd()
24354 
        else:
24355 
          iprot.skip(ftype)
24356 
      elif fid == 1:
24357 
        if ftype == TType.STRUCT:
24358 
          self.ex = TransactionServiceException()
24359 
          self.ex.read(iprot)
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      else:
24363 
        iprot.skip(ftype)
24364 
      iprot.readFieldEnd()
24365 
    iprot.readStructEnd()
24366 
 
24367 
  def write(self, oprot):
24368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24370 
      return
24371 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24372 
    if self.success is not None:
24373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24374 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24375 
      for iter563 in self.success:
24376 
        oprot.writeI64(iter563)
5067 varun.gupt 24377 
      oprot.writeListEnd()
24378 
      oprot.writeFieldEnd()
24379 
    if self.ex is not None:
24380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24381 
      self.ex.write(oprot)
24382 
      oprot.writeFieldEnd()
24383 
    oprot.writeFieldStop()
24384 
    oprot.writeStructEnd()
24385 
 
24386 
  def validate(self):
24387 
    return
24388 
 
24389 
 
24390 
  def __repr__(self):
24391 
    L = ['%s=%r' % (key, value)
24392 
      for key, value in self.__dict__.iteritems()]
24393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24394 
 
24395 
  def __eq__(self, other):
24396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24397 
 
24398 
  def __ne__(self, other):
24399 
    return not (self == other)
5099 varun.gupt 24400 
 
5348 anupam.sin 24401 
class updateCODAgent_args:
24402 
  """
24403 
  Attributes:
24404 
   - agent
24405 
   - orderId
24406 
  """
24407 
 
24408 
  thrift_spec = (
24409 
    None, # 0
24410 
    (1, TType.STRING, 'agent', None, None, ), # 1
24411 
    (2, TType.I64, 'orderId', None, None, ), # 2
24412 
  )
24413 
 
24414 
  def __init__(self, agent=None, orderId=None,):
24415 
    self.agent = agent
24416 
    self.orderId = orderId
24417 
 
24418 
  def read(self, iprot):
24419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24421 
      return
24422 
    iprot.readStructBegin()
24423 
    while True:
24424 
      (fname, ftype, fid) = iprot.readFieldBegin()
24425 
      if ftype == TType.STOP:
24426 
        break
24427 
      if fid == 1:
24428 
        if ftype == TType.STRING:
24429 
          self.agent = iprot.readString();
24430 
        else:
24431 
          iprot.skip(ftype)
24432 
      elif fid == 2:
24433 
        if ftype == TType.I64:
24434 
          self.orderId = iprot.readI64();
24435 
        else:
24436 
          iprot.skip(ftype)
24437 
      else:
24438 
        iprot.skip(ftype)
24439 
      iprot.readFieldEnd()
24440 
    iprot.readStructEnd()
24441 
 
24442 
  def write(self, oprot):
24443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24445 
      return
24446 
    oprot.writeStructBegin('updateCODAgent_args')
24447 
    if self.agent is not None:
24448 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24449 
      oprot.writeString(self.agent)
24450 
      oprot.writeFieldEnd()
24451 
    if self.orderId is not None:
24452 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24453 
      oprot.writeI64(self.orderId)
24454 
      oprot.writeFieldEnd()
24455 
    oprot.writeFieldStop()
24456 
    oprot.writeStructEnd()
24457 
 
24458 
  def validate(self):
24459 
    return
24460 
 
24461 
 
24462 
  def __repr__(self):
24463 
    L = ['%s=%r' % (key, value)
24464 
      for key, value in self.__dict__.iteritems()]
24465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24466 
 
24467 
  def __eq__(self, other):
24468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24469 
 
24470 
  def __ne__(self, other):
24471 
    return not (self == other)
24472 
 
24473 
class updateCODAgent_result:
24474 
  """
24475 
  Attributes:
24476 
   - ex
24477 
  """
24478 
 
24479 
  thrift_spec = (
24480 
    None, # 0
24481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24482 
  )
24483 
 
24484 
  def __init__(self, ex=None,):
24485 
    self.ex = ex
24486 
 
24487 
  def read(self, iprot):
24488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24490 
      return
24491 
    iprot.readStructBegin()
24492 
    while True:
24493 
      (fname, ftype, fid) = iprot.readFieldBegin()
24494 
      if ftype == TType.STOP:
24495 
        break
24496 
      if fid == 1:
24497 
        if ftype == TType.STRUCT:
24498 
          self.ex = TransactionServiceException()
24499 
          self.ex.read(iprot)
24500 
        else:
24501 
          iprot.skip(ftype)
24502 
      else:
24503 
        iprot.skip(ftype)
24504 
      iprot.readFieldEnd()
24505 
    iprot.readStructEnd()
24506 
 
24507 
  def write(self, oprot):
24508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24510 
      return
24511 
    oprot.writeStructBegin('updateCODAgent_result')
24512 
    if self.ex is not None:
24513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24514 
      self.ex.write(oprot)
24515 
      oprot.writeFieldEnd()
24516 
    oprot.writeFieldStop()
24517 
    oprot.writeStructEnd()
24518 
 
24519 
  def validate(self):
24520 
    return
24521 
 
24522 
 
24523 
  def __repr__(self):
24524 
    L = ['%s=%r' % (key, value)
24525 
      for key, value in self.__dict__.iteritems()]
24526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24527 
 
24528 
  def __eq__(self, other):
24529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24530 
 
24531 
  def __ne__(self, other):
24532 
    return not (self == other)
24533 
 
5099 varun.gupt 24534 
class updateOrderAsPaidToVendor_args:
24535 
  """
24536 
  Attributes:
24537 
   - orderId
24538 
  """
24539 
 
24540 
  thrift_spec = (
24541 
    None, # 0
24542 
    (1, TType.I64, 'orderId', None, None, ), # 1
24543 
  )
24544 
 
24545 
  def __init__(self, orderId=None,):
24546 
    self.orderId = orderId
24547 
 
24548 
  def read(self, iprot):
24549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24551 
      return
24552 
    iprot.readStructBegin()
24553 
    while True:
24554 
      (fname, ftype, fid) = iprot.readFieldBegin()
24555 
      if ftype == TType.STOP:
24556 
        break
24557 
      if fid == 1:
24558 
        if ftype == TType.I64:
24559 
          self.orderId = iprot.readI64();
24560 
        else:
24561 
          iprot.skip(ftype)
24562 
      else:
24563 
        iprot.skip(ftype)
24564 
      iprot.readFieldEnd()
24565 
    iprot.readStructEnd()
24566 
 
24567 
  def write(self, oprot):
24568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24570 
      return
24571 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24572 
    if self.orderId is not None:
24573 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24574 
      oprot.writeI64(self.orderId)
24575 
      oprot.writeFieldEnd()
24576 
    oprot.writeFieldStop()
24577 
    oprot.writeStructEnd()
24578 
 
24579 
  def validate(self):
24580 
    return
24581 
 
24582 
 
24583 
  def __repr__(self):
24584 
    L = ['%s=%r' % (key, value)
24585 
      for key, value in self.__dict__.iteritems()]
24586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24587 
 
24588 
  def __eq__(self, other):
24589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24590 
 
24591 
  def __ne__(self, other):
24592 
    return not (self == other)
24593 
 
24594 
class updateOrderAsPaidToVendor_result:
24595 
  """
24596 
  Attributes:
24597 
   - ex
24598 
  """
24599 
 
24600 
  thrift_spec = (
24601 
    None, # 0
24602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24603 
  )
24604 
 
24605 
  def __init__(self, ex=None,):
24606 
    self.ex = ex
24607 
 
24608 
  def read(self, iprot):
24609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24611 
      return
24612 
    iprot.readStructBegin()
24613 
    while True:
24614 
      (fname, ftype, fid) = iprot.readFieldBegin()
24615 
      if ftype == TType.STOP:
24616 
        break
24617 
      if fid == 1:
24618 
        if ftype == TType.STRUCT:
24619 
          self.ex = TransactionServiceException()
24620 
          self.ex.read(iprot)
24621 
        else:
24622 
          iprot.skip(ftype)
24623 
      else:
24624 
        iprot.skip(ftype)
24625 
      iprot.readFieldEnd()
24626 
    iprot.readStructEnd()
24627 
 
24628 
  def write(self, oprot):
24629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24631 
      return
24632 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24633 
    if self.ex is not None:
24634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24635 
      self.ex.write(oprot)
24636 
      oprot.writeFieldEnd()
24637 
    oprot.writeFieldStop()
24638 
    oprot.writeStructEnd()
24639 
 
24640 
  def validate(self):
24641 
    return
24642 
 
24643 
 
24644 
  def __repr__(self):
24645 
    L = ['%s=%r' % (key, value)
24646 
      for key, value in self.__dict__.iteritems()]
24647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24648 
 
24649 
  def __eq__(self, other):
24650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24651 
 
24652 
  def __ne__(self, other):
24653 
    return not (self == other)
5208 varun.gupt 24654 
 
5386 phani.kuma 24655 
class updateOrderOnlyAsPaidToVendor_args:
24656 
  """
24657 
  Attributes:
24658 
   - orderId
24659 
  """
24660 
 
24661 
  thrift_spec = (
24662 
    None, # 0
24663 
    (1, TType.I64, 'orderId', None, None, ), # 1
24664 
  )
24665 
 
24666 
  def __init__(self, orderId=None,):
24667 
    self.orderId = orderId
24668 
 
24669 
  def read(self, iprot):
24670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24672 
      return
24673 
    iprot.readStructBegin()
24674 
    while True:
24675 
      (fname, ftype, fid) = iprot.readFieldBegin()
24676 
      if ftype == TType.STOP:
24677 
        break
24678 
      if fid == 1:
24679 
        if ftype == TType.I64:
24680 
          self.orderId = iprot.readI64();
24681 
        else:
24682 
          iprot.skip(ftype)
24683 
      else:
24684 
        iprot.skip(ftype)
24685 
      iprot.readFieldEnd()
24686 
    iprot.readStructEnd()
24687 
 
24688 
  def write(self, oprot):
24689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24691 
      return
24692 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24693 
    if self.orderId is not None:
24694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24695 
      oprot.writeI64(self.orderId)
24696 
      oprot.writeFieldEnd()
24697 
    oprot.writeFieldStop()
24698 
    oprot.writeStructEnd()
24699 
 
24700 
  def validate(self):
24701 
    return
24702 
 
24703 
 
24704 
  def __repr__(self):
24705 
    L = ['%s=%r' % (key, value)
24706 
      for key, value in self.__dict__.iteritems()]
24707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24708 
 
24709 
  def __eq__(self, other):
24710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24711 
 
24712 
  def __ne__(self, other):
24713 
    return not (self == other)
24714 
 
24715 
class updateOrderOnlyAsPaidToVendor_result:
24716 
  """
24717 
  Attributes:
24718 
   - ex
24719 
  """
24720 
 
24721 
  thrift_spec = (
24722 
    None, # 0
24723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24724 
  )
24725 
 
24726 
  def __init__(self, ex=None,):
24727 
    self.ex = ex
24728 
 
24729 
  def read(self, iprot):
24730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24732 
      return
24733 
    iprot.readStructBegin()
24734 
    while True:
24735 
      (fname, ftype, fid) = iprot.readFieldBegin()
24736 
      if ftype == TType.STOP:
24737 
        break
24738 
      if fid == 1:
24739 
        if ftype == TType.STRUCT:
24740 
          self.ex = TransactionServiceException()
24741 
          self.ex.read(iprot)
24742 
        else:
24743 
          iprot.skip(ftype)
24744 
      else:
24745 
        iprot.skip(ftype)
24746 
      iprot.readFieldEnd()
24747 
    iprot.readStructEnd()
24748 
 
24749 
  def write(self, oprot):
24750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24752 
      return
24753 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24754 
    if self.ex is not None:
24755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24756 
      self.ex.write(oprot)
24757 
      oprot.writeFieldEnd()
24758 
    oprot.writeFieldStop()
24759 
    oprot.writeStructEnd()
24760 
 
24761 
  def validate(self):
24762 
    return
24763 
 
24764 
 
24765 
  def __repr__(self):
24766 
    L = ['%s=%r' % (key, value)
24767 
      for key, value in self.__dict__.iteritems()]
24768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24769 
 
24770 
  def __eq__(self, other):
24771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24772 
 
24773 
  def __ne__(self, other):
24774 
    return not (self == other)
24775 
 
5208 varun.gupt 24776 
class getRefundedOrdersMarkedPaid_args:
24777 
 
24778 
  thrift_spec = (
24779 
  )
24780 
 
24781 
  def read(self, iprot):
24782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24784 
      return
24785 
    iprot.readStructBegin()
24786 
    while True:
24787 
      (fname, ftype, fid) = iprot.readFieldBegin()
24788 
      if ftype == TType.STOP:
24789 
        break
24790 
      else:
24791 
        iprot.skip(ftype)
24792 
      iprot.readFieldEnd()
24793 
    iprot.readStructEnd()
24794 
 
24795 
  def write(self, oprot):
24796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24798 
      return
24799 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24800 
    oprot.writeFieldStop()
24801 
    oprot.writeStructEnd()
24802 
 
24803 
  def validate(self):
24804 
    return
24805 
 
24806 
 
24807 
  def __repr__(self):
24808 
    L = ['%s=%r' % (key, value)
24809 
      for key, value in self.__dict__.iteritems()]
24810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24811 
 
24812 
  def __eq__(self, other):
24813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24814 
 
24815 
  def __ne__(self, other):
24816 
    return not (self == other)
24817 
 
24818 
class getRefundedOrdersMarkedPaid_result:
24819 
  """
24820 
  Attributes:
24821 
   - success
24822 
   - ex
24823 
  """
24824 
 
24825 
  thrift_spec = (
24826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24828 
  )
24829 
 
24830 
  def __init__(self, success=None, ex=None,):
24831 
    self.success = success
24832 
    self.ex = ex
24833 
 
24834 
  def read(self, iprot):
24835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24837 
      return
24838 
    iprot.readStructBegin()
24839 
    while True:
24840 
      (fname, ftype, fid) = iprot.readFieldBegin()
24841 
      if ftype == TType.STOP:
24842 
        break
24843 
      if fid == 0:
24844 
        if ftype == TType.LIST:
24845 
          self.success = []
6031 rajveer 24846 
          (_etype567, _size564) = iprot.readListBegin()
24847 
          for _i568 in xrange(_size564):
24848 
            _elem569 = Order()
24849 
            _elem569.read(iprot)
24850 
            self.success.append(_elem569)
5208 varun.gupt 24851 
          iprot.readListEnd()
24852 
        else:
24853 
          iprot.skip(ftype)
24854 
      elif fid == 1:
24855 
        if ftype == TType.STRUCT:
24856 
          self.ex = TransactionServiceException()
24857 
          self.ex.read(iprot)
24858 
        else:
24859 
          iprot.skip(ftype)
24860 
      else:
24861 
        iprot.skip(ftype)
24862 
      iprot.readFieldEnd()
24863 
    iprot.readStructEnd()
24864 
 
24865 
  def write(self, oprot):
24866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24868 
      return
24869 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24870 
    if self.success is not None:
24871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24873 
      for iter570 in self.success:
24874 
        iter570.write(oprot)
5208 varun.gupt 24875 
      oprot.writeListEnd()
24876 
      oprot.writeFieldEnd()
24877 
    if self.ex is not None:
24878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24879 
      self.ex.write(oprot)
24880 
      oprot.writeFieldEnd()
24881 
    oprot.writeFieldStop()
24882 
    oprot.writeStructEnd()
24883 
 
24884 
  def validate(self):
24885 
    return
24886 
 
24887 
 
24888 
  def __repr__(self):
24889 
    L = ['%s=%r' % (key, value)
24890 
      for key, value in self.__dict__.iteritems()]
24891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24892 
 
24893 
  def __eq__(self, other):
24894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24895 
 
24896 
  def __ne__(self, other):
24897 
    return not (self == other)
5447 anupam.sin 24898 
 
24899 
class getAllVerificationAgents_args:
24900 
  """
24901 
  Attributes:
24902 
   - minOrderId
24903 
   - maxOrderId
24904 
  """
24905 
 
24906 
  thrift_spec = (
24907 
    None, # 0
24908 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24909 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24910 
  )
24911 
 
24912 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24913 
    self.minOrderId = minOrderId
24914 
    self.maxOrderId = maxOrderId
24915 
 
24916 
  def read(self, iprot):
24917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24919 
      return
24920 
    iprot.readStructBegin()
24921 
    while True:
24922 
      (fname, ftype, fid) = iprot.readFieldBegin()
24923 
      if ftype == TType.STOP:
24924 
        break
24925 
      if fid == 1:
24926 
        if ftype == TType.I64:
24927 
          self.minOrderId = iprot.readI64();
24928 
        else:
24929 
          iprot.skip(ftype)
24930 
      elif fid == 2:
24931 
        if ftype == TType.I64:
24932 
          self.maxOrderId = iprot.readI64();
24933 
        else:
24934 
          iprot.skip(ftype)
24935 
      else:
24936 
        iprot.skip(ftype)
24937 
      iprot.readFieldEnd()
24938 
    iprot.readStructEnd()
24939 
 
24940 
  def write(self, oprot):
24941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24943 
      return
24944 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24945 
    if self.minOrderId is not None:
24946 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24947 
      oprot.writeI64(self.minOrderId)
24948 
      oprot.writeFieldEnd()
24949 
    if self.maxOrderId is not None:
24950 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24951 
      oprot.writeI64(self.maxOrderId)
24952 
      oprot.writeFieldEnd()
24953 
    oprot.writeFieldStop()
24954 
    oprot.writeStructEnd()
24955 
 
24956 
  def validate(self):
24957 
    return
24958 
 
24959 
 
24960 
  def __repr__(self):
24961 
    L = ['%s=%r' % (key, value)
24962 
      for key, value in self.__dict__.iteritems()]
24963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24964 
 
24965 
  def __eq__(self, other):
24966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24967 
 
24968 
  def __ne__(self, other):
24969 
    return not (self == other)
24970 
 
24971 
class getAllVerificationAgents_result:
24972 
  """
24973 
  Attributes:
24974 
   - success
24975 
  """
24976 
 
24977 
  thrift_spec = (
24978 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24979 
  )
24980 
 
24981 
  def __init__(self, success=None,):
24982 
    self.success = success
24983 
 
24984 
  def read(self, iprot):
24985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24987 
      return
24988 
    iprot.readStructBegin()
24989 
    while True:
24990 
      (fname, ftype, fid) = iprot.readFieldBegin()
24991 
      if ftype == TType.STOP:
24992 
        break
24993 
      if fid == 0:
24994 
        if ftype == TType.LIST:
24995 
          self.success = []
6031 rajveer 24996 
          (_etype574, _size571) = iprot.readListBegin()
24997 
          for _i575 in xrange(_size571):
24998 
            _elem576 = CODVerificationAgent()
24999 
            _elem576.read(iprot)
25000 
            self.success.append(_elem576)
5447 anupam.sin 25001 
          iprot.readListEnd()
25002 
        else:
25003 
          iprot.skip(ftype)
25004 
      else:
25005 
        iprot.skip(ftype)
25006 
      iprot.readFieldEnd()
25007 
    iprot.readStructEnd()
25008 
 
25009 
  def write(self, oprot):
25010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25012 
      return
25013 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25014 
    if self.success is not None:
25015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25017 
      for iter577 in self.success:
25018 
        iter577.write(oprot)
5447 anupam.sin 25019 
      oprot.writeListEnd()
25020 
      oprot.writeFieldEnd()
25021 
    oprot.writeFieldStop()
25022 
    oprot.writeStructEnd()
25023 
 
25024 
  def validate(self):
25025 
    return
25026 
 
25027 
 
25028 
  def __repr__(self):
25029 
    L = ['%s=%r' % (key, value)
25030 
      for key, value in self.__dict__.iteritems()]
25031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25032 
 
25033 
  def __eq__(self, other):
25034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25035 
 
25036 
  def __ne__(self, other):
25037 
    return not (self == other)
5527 anupam.sin 25038 
 
25039 
class getAllAttributesForOrderId_args:
25040 
  """
25041 
  Attributes:
25042 
   - orderId
25043 
  """
25044 
 
25045 
  thrift_spec = (
25046 
    None, # 0
25047 
    (1, TType.I64, 'orderId', None, None, ), # 1
25048 
  )
25049 
 
25050 
  def __init__(self, orderId=None,):
25051 
    self.orderId = orderId
25052 
 
25053 
  def read(self, iprot):
25054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25056 
      return
25057 
    iprot.readStructBegin()
25058 
    while True:
25059 
      (fname, ftype, fid) = iprot.readFieldBegin()
25060 
      if ftype == TType.STOP:
25061 
        break
25062 
      if fid == 1:
25063 
        if ftype == TType.I64:
25064 
          self.orderId = iprot.readI64();
25065 
        else:
25066 
          iprot.skip(ftype)
25067 
      else:
25068 
        iprot.skip(ftype)
25069 
      iprot.readFieldEnd()
25070 
    iprot.readStructEnd()
25071 
 
25072 
  def write(self, oprot):
25073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25075 
      return
25076 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25077 
    if self.orderId is not None:
25078 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25079 
      oprot.writeI64(self.orderId)
25080 
      oprot.writeFieldEnd()
25081 
    oprot.writeFieldStop()
25082 
    oprot.writeStructEnd()
25083 
 
25084 
  def validate(self):
25085 
    return
25086 
 
25087 
 
25088 
  def __repr__(self):
25089 
    L = ['%s=%r' % (key, value)
25090 
      for key, value in self.__dict__.iteritems()]
25091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25092 
 
25093 
  def __eq__(self, other):
25094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25095 
 
25096 
  def __ne__(self, other):
25097 
    return not (self == other)
25098 
 
25099 
class getAllAttributesForOrderId_result:
25100 
  """
25101 
  Attributes:
25102 
   - success
25103 
  """
25104 
 
25105 
  thrift_spec = (
25106 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25107 
  )
25108 
 
25109 
  def __init__(self, success=None,):
25110 
    self.success = success
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 0:
25122 
        if ftype == TType.LIST:
25123 
          self.success = []
6031 rajveer 25124 
          (_etype581, _size578) = iprot.readListBegin()
25125 
          for _i582 in xrange(_size578):
25126 
            _elem583 = Attribute()
25127 
            _elem583.read(iprot)
25128 
            self.success.append(_elem583)
5527 anupam.sin 25129 
          iprot.readListEnd()
25130 
        else:
25131 
          iprot.skip(ftype)
25132 
      else:
25133 
        iprot.skip(ftype)
25134 
      iprot.readFieldEnd()
25135 
    iprot.readStructEnd()
25136 
 
25137 
  def write(self, oprot):
25138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25140 
      return
25141 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25142 
    if self.success is not None:
25143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25144 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25145 
      for iter584 in self.success:
25146 
        iter584.write(oprot)
5527 anupam.sin 25147 
      oprot.writeListEnd()
25148 
      oprot.writeFieldEnd()
25149 
    oprot.writeFieldStop()
25150 
    oprot.writeStructEnd()
25151 
 
25152 
  def validate(self):
25153 
    return
25154 
 
25155 
 
25156 
  def __repr__(self):
25157 
    L = ['%s=%r' % (key, value)
25158 
      for key, value in self.__dict__.iteritems()]
25159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25160 
 
25161 
  def __eq__(self, other):
25162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25163 
 
25164 
  def __ne__(self, other):
25165 
    return not (self == other)
25166 
 
5676 rajveer 25167 
class setOrderAttributes_args:
25168 
  """
25169 
  Attributes:
25170 
   - orderId
25171 
   - attributes
25172 
  """
25173 
 
25174 
  thrift_spec = None
25175 
  def __init__(self, orderId=None, attributes=None,):
25176 
    self.orderId = orderId
25177 
    self.attributes = attributes
25178 
 
25179 
  def read(self, iprot):
25180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25182 
      return
25183 
    iprot.readStructBegin()
25184 
    while True:
25185 
      (fname, ftype, fid) = iprot.readFieldBegin()
25186 
      if ftype == TType.STOP:
25187 
        break
25188 
      if fid == 1:
25189 
        if ftype == TType.I64:
25190 
          self.orderId = iprot.readI64();
25191 
        else:
25192 
          iprot.skip(ftype)
25193 
      elif fid == -1:
25194 
        if ftype == TType.LIST:
25195 
          self.attributes = []
6031 rajveer 25196 
          (_etype588, _size585) = iprot.readListBegin()
25197 
          for _i589 in xrange(_size585):
25198 
            _elem590 = Attribute()
25199 
            _elem590.read(iprot)
25200 
            self.attributes.append(_elem590)
5676 rajveer 25201 
          iprot.readListEnd()
25202 
        else:
25203 
          iprot.skip(ftype)
25204 
      else:
25205 
        iprot.skip(ftype)
25206 
      iprot.readFieldEnd()
25207 
    iprot.readStructEnd()
25208 
 
25209 
  def write(self, oprot):
25210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25212 
      return
25213 
    oprot.writeStructBegin('setOrderAttributes_args')
25214 
    if self.attributes is not None:
25215 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25216 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 25217 
      for iter591 in self.attributes:
25218 
        iter591.write(oprot)
5676 rajveer 25219 
      oprot.writeListEnd()
25220 
      oprot.writeFieldEnd()
25221 
    if self.orderId is not None:
25222 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25223 
      oprot.writeI64(self.orderId)
25224 
      oprot.writeFieldEnd()
25225 
    oprot.writeFieldStop()
25226 
    oprot.writeStructEnd()
25227 
 
25228 
  def validate(self):
25229 
    return
25230 
 
25231 
 
25232 
  def __repr__(self):
25233 
    L = ['%s=%r' % (key, value)
25234 
      for key, value in self.__dict__.iteritems()]
25235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25236 
 
25237 
  def __eq__(self, other):
25238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25239 
 
25240 
  def __ne__(self, other):
25241 
    return not (self == other)
25242 
 
25243 
class setOrderAttributes_result:
25244 
 
25245 
  thrift_spec = (
25246 
  )
25247 
 
25248 
  def read(self, iprot):
25249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25251 
      return
25252 
    iprot.readStructBegin()
25253 
    while True:
25254 
      (fname, ftype, fid) = iprot.readFieldBegin()
25255 
      if ftype == TType.STOP:
25256 
        break
25257 
      else:
25258 
        iprot.skip(ftype)
25259 
      iprot.readFieldEnd()
25260 
    iprot.readStructEnd()
25261 
 
25262 
  def write(self, oprot):
25263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25265 
      return
25266 
    oprot.writeStructBegin('setOrderAttributes_result')
25267 
    oprot.writeFieldStop()
25268 
    oprot.writeStructEnd()
25269 
 
25270 
  def validate(self):
25271 
    return
25272 
 
25273 
 
25274 
  def __repr__(self):
25275 
    L = ['%s=%r' % (key, value)
25276 
      for key, value in self.__dict__.iteritems()]
25277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25278 
 
25279 
  def __eq__(self, other):
25280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25281 
 
25282 
  def __ne__(self, other):
25283 
    return not (self == other)
25284 
 
5527 anupam.sin 25285 
class setOrderAttributeForTransaction_args:
25286 
  """
25287 
  Attributes:
25288 
   - transactionId
25289 
   - attribute
25290 
  """
25291 
 
25292 
  thrift_spec = None
25293 
  def __init__(self, transactionId=None, attribute=None,):
25294 
    self.transactionId = transactionId
25295 
    self.attribute = attribute
25296 
 
25297 
  def read(self, iprot):
25298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25300 
      return
25301 
    iprot.readStructBegin()
25302 
    while True:
25303 
      (fname, ftype, fid) = iprot.readFieldBegin()
25304 
      if ftype == TType.STOP:
25305 
        break
25306 
      if fid == 1:
25307 
        if ftype == TType.I64:
25308 
          self.transactionId = iprot.readI64();
25309 
        else:
25310 
          iprot.skip(ftype)
25311 
      elif fid == -1:
25312 
        if ftype == TType.STRUCT:
25313 
          self.attribute = Attribute()
25314 
          self.attribute.read(iprot)
25315 
        else:
25316 
          iprot.skip(ftype)
25317 
      else:
25318 
        iprot.skip(ftype)
25319 
      iprot.readFieldEnd()
25320 
    iprot.readStructEnd()
25321 
 
25322 
  def write(self, oprot):
25323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25325 
      return
25326 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25327 
    if self.attribute is not None:
25328 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25329 
      self.attribute.write(oprot)
25330 
      oprot.writeFieldEnd()
25331 
    if self.transactionId is not None:
25332 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25333 
      oprot.writeI64(self.transactionId)
25334 
      oprot.writeFieldEnd()
25335 
    oprot.writeFieldStop()
25336 
    oprot.writeStructEnd()
25337 
 
25338 
  def validate(self):
25339 
    return
25340 
 
25341 
 
25342 
  def __repr__(self):
25343 
    L = ['%s=%r' % (key, value)
25344 
      for key, value in self.__dict__.iteritems()]
25345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25346 
 
25347 
  def __eq__(self, other):
25348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25349 
 
25350 
  def __ne__(self, other):
25351 
    return not (self == other)
25352 
 
25353 
class setOrderAttributeForTransaction_result:
25354 
 
25355 
  thrift_spec = (
25356 
  )
25357 
 
25358 
  def read(self, iprot):
25359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25361 
      return
25362 
    iprot.readStructBegin()
25363 
    while True:
25364 
      (fname, ftype, fid) = iprot.readFieldBegin()
25365 
      if ftype == TType.STOP:
25366 
        break
25367 
      else:
25368 
        iprot.skip(ftype)
25369 
      iprot.readFieldEnd()
25370 
    iprot.readStructEnd()
25371 
 
25372 
  def write(self, oprot):
25373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25375 
      return
25376 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25377 
    oprot.writeFieldStop()
25378 
    oprot.writeStructEnd()
25379 
 
25380 
  def validate(self):
25381 
    return
25382 
 
25383 
 
25384 
  def __repr__(self):
25385 
    L = ['%s=%r' % (key, value)
25386 
      for key, value in self.__dict__.iteritems()]
25387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25388 
 
25389 
  def __eq__(self, other):
25390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25391 
 
25392 
  def __ne__(self, other):
25393 
    return not (self == other)
5553 rajveer 25394 
 
25395 
class getReceivePendingOrders_args:
25396 
  """
25397 
  Attributes:
25398 
   - storeId
25399 
  """
25400 
 
25401 
  thrift_spec = (
25402 
    None, # 0
25403 
    (1, TType.I64, 'storeId', None, None, ), # 1
25404 
  )
25405 
 
25406 
  def __init__(self, storeId=None,):
25407 
    self.storeId = storeId
25408 
 
25409 
  def read(self, iprot):
25410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25412 
      return
25413 
    iprot.readStructBegin()
25414 
    while True:
25415 
      (fname, ftype, fid) = iprot.readFieldBegin()
25416 
      if ftype == TType.STOP:
25417 
        break
25418 
      if fid == 1:
25419 
        if ftype == TType.I64:
25420 
          self.storeId = iprot.readI64();
25421 
        else:
25422 
          iprot.skip(ftype)
25423 
      else:
25424 
        iprot.skip(ftype)
25425 
      iprot.readFieldEnd()
25426 
    iprot.readStructEnd()
25427 
 
25428 
  def write(self, oprot):
25429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25431 
      return
25432 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25433 
    if self.storeId is not None:
25434 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25435 
      oprot.writeI64(self.storeId)
25436 
      oprot.writeFieldEnd()
25437 
    oprot.writeFieldStop()
25438 
    oprot.writeStructEnd()
25439 
 
25440 
  def validate(self):
25441 
    return
25442 
 
25443 
 
25444 
  def __repr__(self):
25445 
    L = ['%s=%r' % (key, value)
25446 
      for key, value in self.__dict__.iteritems()]
25447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25448 
 
25449 
  def __eq__(self, other):
25450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25451 
 
25452 
  def __ne__(self, other):
25453 
    return not (self == other)
25454 
 
25455 
class getReceivePendingOrders_result:
25456 
  """
25457 
  Attributes:
25458 
   - success
25459 
  """
25460 
 
25461 
  thrift_spec = (
25462 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25463 
  )
25464 
 
25465 
  def __init__(self, success=None,):
25466 
    self.success = success
25467 
 
25468 
  def read(self, iprot):
25469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25471 
      return
25472 
    iprot.readStructBegin()
25473 
    while True:
25474 
      (fname, ftype, fid) = iprot.readFieldBegin()
25475 
      if ftype == TType.STOP:
25476 
        break
25477 
      if fid == 0:
25478 
        if ftype == TType.LIST:
25479 
          self.success = []
6031 rajveer 25480 
          (_etype595, _size592) = iprot.readListBegin()
25481 
          for _i596 in xrange(_size592):
25482 
            _elem597 = Order()
25483 
            _elem597.read(iprot)
25484 
            self.success.append(_elem597)
5553 rajveer 25485 
          iprot.readListEnd()
25486 
        else:
25487 
          iprot.skip(ftype)
25488 
      else:
25489 
        iprot.skip(ftype)
25490 
      iprot.readFieldEnd()
25491 
    iprot.readStructEnd()
25492 
 
25493 
  def write(self, oprot):
25494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25496 
      return
25497 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25498 
    if self.success is not None:
25499 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25500 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25501 
      for iter598 in self.success:
25502 
        iter598.write(oprot)
5553 rajveer 25503 
      oprot.writeListEnd()
25504 
      oprot.writeFieldEnd()
25505 
    oprot.writeFieldStop()
25506 
    oprot.writeStructEnd()
25507 
 
25508 
  def validate(self):
25509 
    return
25510 
 
25511 
 
25512 
  def __repr__(self):
25513 
    L = ['%s=%r' % (key, value)
25514 
      for key, value in self.__dict__.iteritems()]
25515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25516 
 
25517 
  def __eq__(self, other):
25518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25519 
 
25520 
  def __ne__(self, other):
25521 
    return not (self == other)
25522 
 
25523 
class getReceivedAtStoreOrders_args:
25524 
  """
25525 
  Attributes:
25526 
   - storeId
25527 
  """
25528 
 
25529 
  thrift_spec = (
25530 
    None, # 0
25531 
    (1, TType.I64, 'storeId', None, None, ), # 1
25532 
  )
25533 
 
25534 
  def __init__(self, storeId=None,):
25535 
    self.storeId = storeId
25536 
 
25537 
  def read(self, iprot):
25538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25540 
      return
25541 
    iprot.readStructBegin()
25542 
    while True:
25543 
      (fname, ftype, fid) = iprot.readFieldBegin()
25544 
      if ftype == TType.STOP:
25545 
        break
25546 
      if fid == 1:
25547 
        if ftype == TType.I64:
25548 
          self.storeId = iprot.readI64();
25549 
        else:
25550 
          iprot.skip(ftype)
25551 
      else:
25552 
        iprot.skip(ftype)
25553 
      iprot.readFieldEnd()
25554 
    iprot.readStructEnd()
25555 
 
25556 
  def write(self, oprot):
25557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25559 
      return
25560 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25561 
    if self.storeId is not None:
25562 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25563 
      oprot.writeI64(self.storeId)
25564 
      oprot.writeFieldEnd()
25565 
    oprot.writeFieldStop()
25566 
    oprot.writeStructEnd()
25567 
 
25568 
  def validate(self):
25569 
    return
25570 
 
25571 
 
25572 
  def __repr__(self):
25573 
    L = ['%s=%r' % (key, value)
25574 
      for key, value in self.__dict__.iteritems()]
25575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25576 
 
25577 
  def __eq__(self, other):
25578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25579 
 
25580 
  def __ne__(self, other):
25581 
    return not (self == other)
25582 
 
25583 
class getReceivedAtStoreOrders_result:
25584 
  """
25585 
  Attributes:
25586 
   - success
25587 
  """
25588 
 
25589 
  thrift_spec = (
25590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25591 
  )
25592 
 
25593 
  def __init__(self, success=None,):
25594 
    self.success = success
25595 
 
25596 
  def read(self, iprot):
25597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25599 
      return
25600 
    iprot.readStructBegin()
25601 
    while True:
25602 
      (fname, ftype, fid) = iprot.readFieldBegin()
25603 
      if ftype == TType.STOP:
25604 
        break
25605 
      if fid == 0:
25606 
        if ftype == TType.LIST:
25607 
          self.success = []
6031 rajveer 25608 
          (_etype602, _size599) = iprot.readListBegin()
25609 
          for _i603 in xrange(_size599):
25610 
            _elem604 = Order()
25611 
            _elem604.read(iprot)
25612 
            self.success.append(_elem604)
5553 rajveer 25613 
          iprot.readListEnd()
25614 
        else:
25615 
          iprot.skip(ftype)
25616 
      else:
25617 
        iprot.skip(ftype)
25618 
      iprot.readFieldEnd()
25619 
    iprot.readStructEnd()
25620 
 
25621 
  def write(self, oprot):
25622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25624 
      return
25625 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25626 
    if self.success is not None:
25627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25629 
      for iter605 in self.success:
25630 
        iter605.write(oprot)
5553 rajveer 25631 
      oprot.writeListEnd()
25632 
      oprot.writeFieldEnd()
25633 
    oprot.writeFieldStop()
25634 
    oprot.writeStructEnd()
25635 
 
25636 
  def validate(self):
25637 
    return
25638 
 
25639 
 
25640 
  def __repr__(self):
25641 
    L = ['%s=%r' % (key, value)
25642 
      for key, value in self.__dict__.iteritems()]
25643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25644 
 
25645 
  def __eq__(self, other):
25646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25647 
 
25648 
  def __ne__(self, other):
25649 
    return not (self == other)
5593 mandeep.dh 25650 
 
5713 rajveer 25651 
class getOrdersCollectionAtStore_args:
25652 
  """
25653 
  Attributes:
25654 
   - storeId
25655 
   - fromDate
25656 
   - toDate
25657 
   - onlyCod
25658 
  """
25659 
 
25660 
  thrift_spec = (
25661 
    None, # 0
25662 
    (1, TType.I64, 'storeId', None, None, ), # 1
25663 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25664 
    (3, TType.I64, 'toDate', None, None, ), # 3
25665 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25666 
  )
25667 
 
25668 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25669 
    self.storeId = storeId
25670 
    self.fromDate = fromDate
25671 
    self.toDate = toDate
25672 
    self.onlyCod = onlyCod
25673 
 
25674 
  def read(self, iprot):
25675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25677 
      return
25678 
    iprot.readStructBegin()
25679 
    while True:
25680 
      (fname, ftype, fid) = iprot.readFieldBegin()
25681 
      if ftype == TType.STOP:
25682 
        break
25683 
      if fid == 1:
25684 
        if ftype == TType.I64:
25685 
          self.storeId = iprot.readI64();
25686 
        else:
25687 
          iprot.skip(ftype)
25688 
      elif fid == 2:
25689 
        if ftype == TType.I64:
25690 
          self.fromDate = iprot.readI64();
25691 
        else:
25692 
          iprot.skip(ftype)
25693 
      elif fid == 3:
25694 
        if ftype == TType.I64:
25695 
          self.toDate = iprot.readI64();
25696 
        else:
25697 
          iprot.skip(ftype)
25698 
      elif fid == 4:
25699 
        if ftype == TType.BOOL:
25700 
          self.onlyCod = iprot.readBool();
25701 
        else:
25702 
          iprot.skip(ftype)
25703 
      else:
25704 
        iprot.skip(ftype)
25705 
      iprot.readFieldEnd()
25706 
    iprot.readStructEnd()
25707 
 
25708 
  def write(self, oprot):
25709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25711 
      return
25712 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25713 
    if self.storeId is not None:
25714 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25715 
      oprot.writeI64(self.storeId)
25716 
      oprot.writeFieldEnd()
25717 
    if self.fromDate is not None:
25718 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25719 
      oprot.writeI64(self.fromDate)
25720 
      oprot.writeFieldEnd()
25721 
    if self.toDate is not None:
25722 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25723 
      oprot.writeI64(self.toDate)
25724 
      oprot.writeFieldEnd()
25725 
    if self.onlyCod is not None:
25726 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25727 
      oprot.writeBool(self.onlyCod)
25728 
      oprot.writeFieldEnd()
25729 
    oprot.writeFieldStop()
25730 
    oprot.writeStructEnd()
25731 
 
25732 
  def validate(self):
25733 
    return
25734 
 
25735 
 
25736 
  def __repr__(self):
25737 
    L = ['%s=%r' % (key, value)
25738 
      for key, value in self.__dict__.iteritems()]
25739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25740 
 
25741 
  def __eq__(self, other):
25742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25743 
 
25744 
  def __ne__(self, other):
25745 
    return not (self == other)
25746 
 
25747 
class getOrdersCollectionAtStore_result:
25748 
  """
25749 
  Attributes:
25750 
   - success
25751 
  """
25752 
 
25753 
  thrift_spec = (
25754 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25755 
  )
25756 
 
25757 
  def __init__(self, success=None,):
25758 
    self.success = success
25759 
 
25760 
  def read(self, iprot):
25761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25763 
      return
25764 
    iprot.readStructBegin()
25765 
    while True:
25766 
      (fname, ftype, fid) = iprot.readFieldBegin()
25767 
      if ftype == TType.STOP:
25768 
        break
25769 
      if fid == 0:
25770 
        if ftype == TType.LIST:
25771 
          self.success = []
6031 rajveer 25772 
          (_etype609, _size606) = iprot.readListBegin()
25773 
          for _i610 in xrange(_size606):
25774 
            _elem611 = Order()
25775 
            _elem611.read(iprot)
25776 
            self.success.append(_elem611)
5713 rajveer 25777 
          iprot.readListEnd()
25778 
        else:
25779 
          iprot.skip(ftype)
25780 
      else:
25781 
        iprot.skip(ftype)
25782 
      iprot.readFieldEnd()
25783 
    iprot.readStructEnd()
25784 
 
25785 
  def write(self, oprot):
25786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25788 
      return
25789 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25790 
    if self.success is not None:
25791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25792 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25793 
      for iter612 in self.success:
25794 
        iter612.write(oprot)
5713 rajveer 25795 
      oprot.writeListEnd()
25796 
      oprot.writeFieldEnd()
25797 
    oprot.writeFieldStop()
25798 
    oprot.writeStructEnd()
25799 
 
25800 
  def validate(self):
25801 
    return
25802 
 
25803 
 
25804 
  def __repr__(self):
25805 
    L = ['%s=%r' % (key, value)
25806 
      for key, value in self.__dict__.iteritems()]
25807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25808 
 
25809 
  def __eq__(self, other):
25810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25811 
 
25812 
  def __ne__(self, other):
25813 
    return not (self == other)
25814 
 
5833 rajveer 25815 
class getOrderAttributeValue_args:
25816 
  """
25817 
  Attributes:
25818 
   - orderId
25819 
   - attributeName
25820 
  """
25821 
 
25822 
  thrift_spec = None
25823 
  def __init__(self, orderId=None, attributeName=None,):
25824 
    self.orderId = orderId
25825 
    self.attributeName = attributeName
25826 
 
25827 
  def read(self, iprot):
25828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25830 
      return
25831 
    iprot.readStructBegin()
25832 
    while True:
25833 
      (fname, ftype, fid) = iprot.readFieldBegin()
25834 
      if ftype == TType.STOP:
25835 
        break
25836 
      if fid == 1:
25837 
        if ftype == TType.I64:
25838 
          self.orderId = iprot.readI64();
25839 
        else:
25840 
          iprot.skip(ftype)
25841 
      elif fid == -1:
25842 
        if ftype == TType.STRING:
25843 
          self.attributeName = iprot.readString();
25844 
        else:
25845 
          iprot.skip(ftype)
25846 
      else:
25847 
        iprot.skip(ftype)
25848 
      iprot.readFieldEnd()
25849 
    iprot.readStructEnd()
25850 
 
25851 
  def write(self, oprot):
25852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25854 
      return
25855 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25856 
    if self.attributeName is not None:
25857 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25858 
      oprot.writeString(self.attributeName)
25859 
      oprot.writeFieldEnd()
25860 
    if self.orderId is not None:
25861 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25862 
      oprot.writeI64(self.orderId)
25863 
      oprot.writeFieldEnd()
25864 
    oprot.writeFieldStop()
25865 
    oprot.writeStructEnd()
25866 
 
25867 
  def validate(self):
25868 
    return
25869 
 
25870 
 
25871 
  def __repr__(self):
25872 
    L = ['%s=%r' % (key, value)
25873 
      for key, value in self.__dict__.iteritems()]
25874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25875 
 
25876 
  def __eq__(self, other):
25877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25878 
 
25879 
  def __ne__(self, other):
25880 
    return not (self == other)
25881 
 
25882 
class getOrderAttributeValue_result:
25883 
  """
25884 
  Attributes:
25885 
   - success
25886 
  """
25887 
 
25888 
  thrift_spec = (
25889 
    (0, TType.STRING, 'success', None, None, ), # 0
25890 
  )
25891 
 
25892 
  def __init__(self, success=None,):
25893 
    self.success = success
25894 
 
25895 
  def read(self, iprot):
25896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25898 
      return
25899 
    iprot.readStructBegin()
25900 
    while True:
25901 
      (fname, ftype, fid) = iprot.readFieldBegin()
25902 
      if ftype == TType.STOP:
25903 
        break
25904 
      if fid == 0:
25905 
        if ftype == TType.STRING:
25906 
          self.success = iprot.readString();
25907 
        else:
25908 
          iprot.skip(ftype)
25909 
      else:
25910 
        iprot.skip(ftype)
25911 
      iprot.readFieldEnd()
25912 
    iprot.readStructEnd()
25913 
 
25914 
  def write(self, oprot):
25915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25917 
      return
25918 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25919 
    if self.success is not None:
25920 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25921 
      oprot.writeString(self.success)
25922 
      oprot.writeFieldEnd()
25923 
    oprot.writeFieldStop()
25924 
    oprot.writeStructEnd()
25925 
 
25926 
  def validate(self):
25927 
    return
25928 
 
25929 
 
25930 
  def __repr__(self):
25931 
    L = ['%s=%r' % (key, value)
25932 
      for key, value in self.__dict__.iteritems()]
25933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25934 
 
25935 
  def __eq__(self, other):
25936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25937 
 
25938 
  def __ne__(self, other):
25939 
    return not (self == other)
25940 
 
6019 rajveer 25941 
class changeJacketNumber_args:
25942 
  """
25943 
  Attributes:
25944 
   - orderId
25945 
   - jacketNumber
25946 
  """
25947 
 
25948 
  thrift_spec = (
25949 
    None, # 0
25950 
    (1, TType.I64, 'orderId', None, None, ), # 1
25951 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25952 
  )
25953 
 
25954 
  def __init__(self, orderId=None, jacketNumber=None,):
25955 
    self.orderId = orderId
25956 
    self.jacketNumber = jacketNumber
25957 
 
25958 
  def read(self, iprot):
25959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25961 
      return
25962 
    iprot.readStructBegin()
25963 
    while True:
25964 
      (fname, ftype, fid) = iprot.readFieldBegin()
25965 
      if ftype == TType.STOP:
25966 
        break
25967 
      if fid == 1:
25968 
        if ftype == TType.I64:
25969 
          self.orderId = iprot.readI64();
25970 
        else:
25971 
          iprot.skip(ftype)
25972 
      elif fid == 2:
25973 
        if ftype == TType.I64:
25974 
          self.jacketNumber = iprot.readI64();
25975 
        else:
25976 
          iprot.skip(ftype)
25977 
      else:
25978 
        iprot.skip(ftype)
25979 
      iprot.readFieldEnd()
25980 
    iprot.readStructEnd()
25981 
 
25982 
  def write(self, oprot):
25983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25985 
      return
25986 
    oprot.writeStructBegin('changeJacketNumber_args')
25987 
    if self.orderId is not None:
25988 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25989 
      oprot.writeI64(self.orderId)
25990 
      oprot.writeFieldEnd()
25991 
    if self.jacketNumber is not None:
25992 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25993 
      oprot.writeI64(self.jacketNumber)
25994 
      oprot.writeFieldEnd()
25995 
    oprot.writeFieldStop()
25996 
    oprot.writeStructEnd()
25997 
 
25998 
  def validate(self):
25999 
    return
26000 
 
26001 
 
26002 
  def __repr__(self):
26003 
    L = ['%s=%r' % (key, value)
26004 
      for key, value in self.__dict__.iteritems()]
26005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26006 
 
26007 
  def __eq__(self, other):
26008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26009 
 
26010 
  def __ne__(self, other):
26011 
    return not (self == other)
26012 
 
26013 
class changeJacketNumber_result:
26014 
  """
26015 
  Attributes:
26016 
   - success
26017 
  """
26018 
 
26019 
  thrift_spec = (
26020 
    (0, TType.BOOL, 'success', None, None, ), # 0
26021 
  )
26022 
 
26023 
  def __init__(self, success=None,):
26024 
    self.success = success
26025 
 
26026 
  def read(self, iprot):
26027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26029 
      return
26030 
    iprot.readStructBegin()
26031 
    while True:
26032 
      (fname, ftype, fid) = iprot.readFieldBegin()
26033 
      if ftype == TType.STOP:
26034 
        break
26035 
      if fid == 0:
26036 
        if ftype == TType.BOOL:
26037 
          self.success = iprot.readBool();
26038 
        else:
26039 
          iprot.skip(ftype)
26040 
      else:
26041 
        iprot.skip(ftype)
26042 
      iprot.readFieldEnd()
26043 
    iprot.readStructEnd()
26044 
 
26045 
  def write(self, oprot):
26046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26048 
      return
26049 
    oprot.writeStructBegin('changeJacketNumber_result')
26050 
    if self.success is not None:
26051 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26052 
      oprot.writeBool(self.success)
26053 
      oprot.writeFieldEnd()
26054 
    oprot.writeFieldStop()
26055 
    oprot.writeStructEnd()
26056 
 
26057 
  def validate(self):
26058 
    return
26059 
 
26060 
 
26061 
  def __repr__(self):
26062 
    L = ['%s=%r' % (key, value)
26063 
      for key, value in self.__dict__.iteritems()]
26064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26065 
 
26066 
  def __eq__(self, other):
26067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26068 
 
26069 
  def __ne__(self, other):
26070 
    return not (self == other)
26071 
 
26072 
class markOrderAsRtoInTransit_args:
26073 
  """
26074 
  Attributes:
26075 
   - orderId
26076 
  """
26077 
 
26078 
  thrift_spec = (
26079 
    None, # 0
26080 
    (1, TType.I64, 'orderId', None, None, ), # 1
26081 
  )
26082 
 
26083 
  def __init__(self, orderId=None,):
26084 
    self.orderId = orderId
26085 
 
26086 
  def read(self, iprot):
26087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26089 
      return
26090 
    iprot.readStructBegin()
26091 
    while True:
26092 
      (fname, ftype, fid) = iprot.readFieldBegin()
26093 
      if ftype == TType.STOP:
26094 
        break
26095 
      if fid == 1:
26096 
        if ftype == TType.I64:
26097 
          self.orderId = iprot.readI64();
26098 
        else:
26099 
          iprot.skip(ftype)
26100 
      else:
26101 
        iprot.skip(ftype)
26102 
      iprot.readFieldEnd()
26103 
    iprot.readStructEnd()
26104 
 
26105 
  def write(self, oprot):
26106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26108 
      return
26109 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26110 
    if self.orderId is not None:
26111 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26112 
      oprot.writeI64(self.orderId)
26113 
      oprot.writeFieldEnd()
26114 
    oprot.writeFieldStop()
26115 
    oprot.writeStructEnd()
26116 
 
26117 
  def validate(self):
26118 
    return
26119 
 
26120 
 
26121 
  def __repr__(self):
26122 
    L = ['%s=%r' % (key, value)
26123 
      for key, value in self.__dict__.iteritems()]
26124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26125 
 
26126 
  def __eq__(self, other):
26127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26128 
 
26129 
  def __ne__(self, other):
26130 
    return not (self == other)
26131 
 
26132 
class markOrderAsRtoInTransit_result:
26133 
  """
26134 
  Attributes:
26135 
   - success
26136 
  """
26137 
 
26138 
  thrift_spec = (
26139 
    (0, TType.BOOL, 'success', None, None, ), # 0
26140 
  )
26141 
 
26142 
  def __init__(self, success=None,):
26143 
    self.success = success
26144 
 
26145 
  def read(self, iprot):
26146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26148 
      return
26149 
    iprot.readStructBegin()
26150 
    while True:
26151 
      (fname, ftype, fid) = iprot.readFieldBegin()
26152 
      if ftype == TType.STOP:
26153 
        break
26154 
      if fid == 0:
26155 
        if ftype == TType.BOOL:
26156 
          self.success = iprot.readBool();
26157 
        else:
26158 
          iprot.skip(ftype)
26159 
      else:
26160 
        iprot.skip(ftype)
26161 
      iprot.readFieldEnd()
26162 
    iprot.readStructEnd()
26163 
 
26164 
  def write(self, oprot):
26165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26167 
      return
26168 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26169 
    if self.success is not None:
26170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26171 
      oprot.writeBool(self.success)
26172 
      oprot.writeFieldEnd()
26173 
    oprot.writeFieldStop()
26174 
    oprot.writeStructEnd()
26175 
 
26176 
  def validate(self):
26177 
    return
26178 
 
26179 
 
26180 
  def __repr__(self):
26181 
    L = ['%s=%r' % (key, value)
26182 
      for key, value in self.__dict__.iteritems()]
26183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26184 
 
26185 
  def __eq__(self, other):
26186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26187 
 
26188 
  def __ne__(self, other):
26189 
    return not (self == other)
26190 
 
5593 mandeep.dh 26191 
class acceptOrderForItem_args:
26192 
  """
26193 
  Attributes:
26194 
   - itemId
26195 
   - quantity
26196 
   - fulfilmentWarehouseId
26197 
   - billingWarehouseId
26198 
  """
26199 
 
26200 
  thrift_spec = (
26201 
    None, # 0
26202 
    (1, TType.I64, 'itemId', None, None, ), # 1
26203 
    (2, TType.I64, 'quantity', None, None, ), # 2
26204 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26205 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26206 
  )
26207 
 
26208 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26209 
    self.itemId = itemId
26210 
    self.quantity = quantity
26211 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26212 
    self.billingWarehouseId = billingWarehouseId
26213 
 
26214 
  def read(self, iprot):
26215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26217 
      return
26218 
    iprot.readStructBegin()
26219 
    while True:
26220 
      (fname, ftype, fid) = iprot.readFieldBegin()
26221 
      if ftype == TType.STOP:
26222 
        break
26223 
      if fid == 1:
26224 
        if ftype == TType.I64:
26225 
          self.itemId = iprot.readI64();
26226 
        else:
26227 
          iprot.skip(ftype)
26228 
      elif fid == 2:
26229 
        if ftype == TType.I64:
26230 
          self.quantity = iprot.readI64();
26231 
        else:
26232 
          iprot.skip(ftype)
26233 
      elif fid == 3:
26234 
        if ftype == TType.I64:
26235 
          self.fulfilmentWarehouseId = iprot.readI64();
26236 
        else:
26237 
          iprot.skip(ftype)
26238 
      elif fid == 4:
26239 
        if ftype == TType.I64:
26240 
          self.billingWarehouseId = iprot.readI64();
26241 
        else:
26242 
          iprot.skip(ftype)
26243 
      else:
26244 
        iprot.skip(ftype)
26245 
      iprot.readFieldEnd()
26246 
    iprot.readStructEnd()
26247 
 
26248 
  def write(self, oprot):
26249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26251 
      return
26252 
    oprot.writeStructBegin('acceptOrderForItem_args')
26253 
    if self.itemId is not None:
26254 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26255 
      oprot.writeI64(self.itemId)
26256 
      oprot.writeFieldEnd()
26257 
    if self.quantity is not None:
26258 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26259 
      oprot.writeI64(self.quantity)
26260 
      oprot.writeFieldEnd()
26261 
    if self.fulfilmentWarehouseId is not None:
26262 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26263 
      oprot.writeI64(self.fulfilmentWarehouseId)
26264 
      oprot.writeFieldEnd()
26265 
    if self.billingWarehouseId is not None:
26266 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26267 
      oprot.writeI64(self.billingWarehouseId)
26268 
      oprot.writeFieldEnd()
26269 
    oprot.writeFieldStop()
26270 
    oprot.writeStructEnd()
26271 
 
26272 
  def validate(self):
26273 
    return
26274 
 
26275 
 
26276 
  def __repr__(self):
26277 
    L = ['%s=%r' % (key, value)
26278 
      for key, value in self.__dict__.iteritems()]
26279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26280 
 
26281 
  def __eq__(self, other):
26282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26283 
 
26284 
  def __ne__(self, other):
26285 
    return not (self == other)
26286 
 
26287 
class acceptOrderForItem_result:
26288 
 
26289 
  thrift_spec = (
26290 
  )
26291 
 
26292 
  def read(self, iprot):
26293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26295 
      return
26296 
    iprot.readStructBegin()
26297 
    while True:
26298 
      (fname, ftype, fid) = iprot.readFieldBegin()
26299 
      if ftype == TType.STOP:
26300 
        break
26301 
      else:
26302 
        iprot.skip(ftype)
26303 
      iprot.readFieldEnd()
26304 
    iprot.readStructEnd()
26305 
 
26306 
  def write(self, oprot):
26307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26309 
      return
26310 
    oprot.writeStructBegin('acceptOrderForItem_result')
26311 
    oprot.writeFieldStop()
26312 
    oprot.writeStructEnd()
26313 
 
26314 
  def validate(self):
26315 
    return
26316 
 
26317 
 
26318 
  def __repr__(self):
26319 
    L = ['%s=%r' % (key, value)
26320 
      for key, value in self.__dict__.iteritems()]
26321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26322 
 
26323 
  def __eq__(self, other):
26324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26325 
 
26326 
  def __ne__(self, other):
26327 
    return not (self == other)
6000 mandeep.dh 26328 
 
26329 
class createRechargeOrder_args:
26330 
  """
26331 
  Attributes:
26332 
   - rechargeOrder
26333 
  """
26334 
 
26335 
  thrift_spec = (
26336 
    None, # 0
26337 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26338 
  )
26339 
 
26340 
  def __init__(self, rechargeOrder=None,):
26341 
    self.rechargeOrder = rechargeOrder
26342 
 
26343 
  def read(self, iprot):
26344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26346 
      return
26347 
    iprot.readStructBegin()
26348 
    while True:
26349 
      (fname, ftype, fid) = iprot.readFieldBegin()
26350 
      if ftype == TType.STOP:
26351 
        break
26352 
      if fid == 1:
26353 
        if ftype == TType.STRUCT:
26354 
          self.rechargeOrder = RechargeOrder()
26355 
          self.rechargeOrder.read(iprot)
26356 
        else:
26357 
          iprot.skip(ftype)
26358 
      else:
26359 
        iprot.skip(ftype)
26360 
      iprot.readFieldEnd()
26361 
    iprot.readStructEnd()
26362 
 
26363 
  def write(self, oprot):
26364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26366 
      return
26367 
    oprot.writeStructBegin('createRechargeOrder_args')
26368 
    if self.rechargeOrder is not None:
26369 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26370 
      self.rechargeOrder.write(oprot)
26371 
      oprot.writeFieldEnd()
26372 
    oprot.writeFieldStop()
26373 
    oprot.writeStructEnd()
26374 
 
26375 
  def validate(self):
26376 
    return
26377 
 
26378 
 
26379 
  def __repr__(self):
26380 
    L = ['%s=%r' % (key, value)
26381 
      for key, value in self.__dict__.iteritems()]
26382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26383 
 
26384 
  def __eq__(self, other):
26385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26386 
 
26387 
  def __ne__(self, other):
26388 
    return not (self == other)
26389 
 
26390 
class createRechargeOrder_result:
26391 
  """
26392 
  Attributes:
26393 
   - success
26394 
   - ex
26395 
  """
26396 
 
26397 
  thrift_spec = (
26398 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26400 
  )
26401 
 
26402 
  def __init__(self, success=None, ex=None,):
26403 
    self.success = success
26404 
    self.ex = ex
26405 
 
26406 
  def read(self, iprot):
26407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26409 
      return
26410 
    iprot.readStructBegin()
26411 
    while True:
26412 
      (fname, ftype, fid) = iprot.readFieldBegin()
26413 
      if ftype == TType.STOP:
26414 
        break
26415 
      if fid == 0:
26416 
        if ftype == TType.STRUCT:
26417 
          self.success = RechargeOrder()
26418 
          self.success.read(iprot)
26419 
        else:
26420 
          iprot.skip(ftype)
26421 
      elif fid == 1:
26422 
        if ftype == TType.STRUCT:
26423 
          self.ex = TransactionServiceException()
26424 
          self.ex.read(iprot)
26425 
        else:
26426 
          iprot.skip(ftype)
26427 
      else:
26428 
        iprot.skip(ftype)
26429 
      iprot.readFieldEnd()
26430 
    iprot.readStructEnd()
26431 
 
26432 
  def write(self, oprot):
26433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26435 
      return
26436 
    oprot.writeStructBegin('createRechargeOrder_result')
26437 
    if self.success is not None:
26438 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26439 
      self.success.write(oprot)
26440 
      oprot.writeFieldEnd()
26441 
    if self.ex is not None:
26442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26443 
      self.ex.write(oprot)
26444 
      oprot.writeFieldEnd()
26445 
    oprot.writeFieldStop()
26446 
    oprot.writeStructEnd()
26447 
 
26448 
  def validate(self):
26449 
    return
26450 
 
26451 
 
26452 
  def __repr__(self):
26453 
    L = ['%s=%r' % (key, value)
26454 
      for key, value in self.__dict__.iteritems()]
26455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26456 
 
26457 
  def __eq__(self, other):
26458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26459 
 
26460 
  def __ne__(self, other):
26461 
    return not (self == other)
26462 
 
6031 rajveer 26463 
class getRechargeOrder_args:
26464 
  """
26465 
  Attributes:
26466 
   - rechargeRrderId
26467 
  """
26468 
 
26469 
  thrift_spec = (
26470 
    None, # 0
26471 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26472 
  )
26473 
 
26474 
  def __init__(self, rechargeRrderId=None,):
26475 
    self.rechargeRrderId = rechargeRrderId
26476 
 
26477 
  def read(self, iprot):
26478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26480 
      return
26481 
    iprot.readStructBegin()
26482 
    while True:
26483 
      (fname, ftype, fid) = iprot.readFieldBegin()
26484 
      if ftype == TType.STOP:
26485 
        break
26486 
      if fid == 1:
26487 
        if ftype == TType.I64:
26488 
          self.rechargeRrderId = iprot.readI64();
26489 
        else:
26490 
          iprot.skip(ftype)
26491 
      else:
26492 
        iprot.skip(ftype)
26493 
      iprot.readFieldEnd()
26494 
    iprot.readStructEnd()
26495 
 
26496 
  def write(self, oprot):
26497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26499 
      return
26500 
    oprot.writeStructBegin('getRechargeOrder_args')
26501 
    if self.rechargeRrderId is not None:
26502 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26503 
      oprot.writeI64(self.rechargeRrderId)
26504 
      oprot.writeFieldEnd()
26505 
    oprot.writeFieldStop()
26506 
    oprot.writeStructEnd()
26507 
 
26508 
  def validate(self):
26509 
    return
26510 
 
26511 
 
26512 
  def __repr__(self):
26513 
    L = ['%s=%r' % (key, value)
26514 
      for key, value in self.__dict__.iteritems()]
26515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26516 
 
26517 
  def __eq__(self, other):
26518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26519 
 
26520 
  def __ne__(self, other):
26521 
    return not (self == other)
26522 
 
26523 
class getRechargeOrder_result:
26524 
  """
26525 
  Attributes:
26526 
   - success
26527 
   - ex
26528 
  """
26529 
 
26530 
  thrift_spec = (
26531 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26533 
  )
26534 
 
26535 
  def __init__(self, success=None, ex=None,):
26536 
    self.success = success
26537 
    self.ex = ex
26538 
 
26539 
  def read(self, iprot):
26540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26542 
      return
26543 
    iprot.readStructBegin()
26544 
    while True:
26545 
      (fname, ftype, fid) = iprot.readFieldBegin()
26546 
      if ftype == TType.STOP:
26547 
        break
26548 
      if fid == 0:
26549 
        if ftype == TType.STRUCT:
26550 
          self.success = RechargeOrder()
26551 
          self.success.read(iprot)
26552 
        else:
26553 
          iprot.skip(ftype)
26554 
      elif fid == 1:
26555 
        if ftype == TType.STRUCT:
26556 
          self.ex = TransactionServiceException()
26557 
          self.ex.read(iprot)
26558 
        else:
26559 
          iprot.skip(ftype)
26560 
      else:
26561 
        iprot.skip(ftype)
26562 
      iprot.readFieldEnd()
26563 
    iprot.readStructEnd()
26564 
 
26565 
  def write(self, oprot):
26566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26568 
      return
26569 
    oprot.writeStructBegin('getRechargeOrder_result')
26570 
    if self.success is not None:
26571 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26572 
      self.success.write(oprot)
26573 
      oprot.writeFieldEnd()
26574 
    if self.ex is not None:
26575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26576 
      self.ex.write(oprot)
26577 
      oprot.writeFieldEnd()
26578 
    oprot.writeFieldStop()
26579 
    oprot.writeStructEnd()
26580 
 
26581 
  def validate(self):
26582 
    return
26583 
 
26584 
 
26585 
  def __repr__(self):
26586 
    L = ['%s=%r' % (key, value)
26587 
      for key, value in self.__dict__.iteritems()]
26588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26589 
 
26590 
  def __eq__(self, other):
26591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26592 
 
26593 
  def __ne__(self, other):
26594 
    return not (self == other)
26595 
 
26596 
class getRechargeOrders_args:
26597 
  """
26598 
  Attributes:
26599 
   - userId
26600 
  """
26601 
 
26602 
  thrift_spec = (
26603 
    None, # 0
26604 
    (1, TType.I64, 'userId', None, None, ), # 1
26605 
  )
26606 
 
26607 
  def __init__(self, userId=None,):
26608 
    self.userId = userId
26609 
 
26610 
  def read(self, iprot):
26611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26613 
      return
26614 
    iprot.readStructBegin()
26615 
    while True:
26616 
      (fname, ftype, fid) = iprot.readFieldBegin()
26617 
      if ftype == TType.STOP:
26618 
        break
26619 
      if fid == 1:
26620 
        if ftype == TType.I64:
26621 
          self.userId = iprot.readI64();
26622 
        else:
26623 
          iprot.skip(ftype)
26624 
      else:
26625 
        iprot.skip(ftype)
26626 
      iprot.readFieldEnd()
26627 
    iprot.readStructEnd()
26628 
 
26629 
  def write(self, oprot):
26630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26632 
      return
26633 
    oprot.writeStructBegin('getRechargeOrders_args')
26634 
    if self.userId is not None:
26635 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26636 
      oprot.writeI64(self.userId)
26637 
      oprot.writeFieldEnd()
26638 
    oprot.writeFieldStop()
26639 
    oprot.writeStructEnd()
26640 
 
26641 
  def validate(self):
26642 
    return
26643 
 
26644 
 
26645 
  def __repr__(self):
26646 
    L = ['%s=%r' % (key, value)
26647 
      for key, value in self.__dict__.iteritems()]
26648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26649 
 
26650 
  def __eq__(self, other):
26651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26652 
 
26653 
  def __ne__(self, other):
26654 
    return not (self == other)
26655 
 
26656 
class getRechargeOrders_result:
26657 
  """
26658 
  Attributes:
26659 
   - success
26660 
  """
26661 
 
26662 
  thrift_spec = (
26663 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26664 
  )
26665 
 
26666 
  def __init__(self, success=None,):
26667 
    self.success = success
26668 
 
26669 
  def read(self, iprot):
26670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26672 
      return
26673 
    iprot.readStructBegin()
26674 
    while True:
26675 
      (fname, ftype, fid) = iprot.readFieldBegin()
26676 
      if ftype == TType.STOP:
26677 
        break
26678 
      if fid == 0:
26679 
        if ftype == TType.LIST:
26680 
          self.success = []
26681 
          (_etype616, _size613) = iprot.readListBegin()
26682 
          for _i617 in xrange(_size613):
26683 
            _elem618 = RechargeOrder()
26684 
            _elem618.read(iprot)
26685 
            self.success.append(_elem618)
26686 
          iprot.readListEnd()
26687 
        else:
26688 
          iprot.skip(ftype)
26689 
      else:
26690 
        iprot.skip(ftype)
26691 
      iprot.readFieldEnd()
26692 
    iprot.readStructEnd()
26693 
 
26694 
  def write(self, oprot):
26695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26697 
      return
26698 
    oprot.writeStructBegin('getRechargeOrders_result')
26699 
    if self.success is not None:
26700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26702 
      for iter619 in self.success:
26703 
        iter619.write(oprot)
26704 
      oprot.writeListEnd()
26705 
      oprot.writeFieldEnd()
26706 
    oprot.writeFieldStop()
26707 
    oprot.writeStructEnd()
26708 
 
26709 
  def validate(self):
26710 
    return
26711 
 
26712 
 
26713 
  def __repr__(self):
26714 
    L = ['%s=%r' % (key, value)
26715 
      for key, value in self.__dict__.iteritems()]
26716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26717 
 
26718 
  def __eq__(self, other):
26719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26720 
 
26721 
  def __ne__(self, other):
26722 
    return not (self == other)
26723 
 
6000 mandeep.dh 26724 
class updateRechargeOrderStatus_args:
26725 
  """
26726 
  Attributes:
26727 
   - rechargeOrderId
26728 
   - rechargeOrderStatus
26729 
  """
26730 
 
26731 
  thrift_spec = (
26732 
    None, # 0
26733 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26734 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26735 
  )
26736 
 
26737 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26738 
    self.rechargeOrderId = rechargeOrderId
26739 
    self.rechargeOrderStatus = rechargeOrderStatus
26740 
 
26741 
  def read(self, iprot):
26742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26744 
      return
26745 
    iprot.readStructBegin()
26746 
    while True:
26747 
      (fname, ftype, fid) = iprot.readFieldBegin()
26748 
      if ftype == TType.STOP:
26749 
        break
26750 
      if fid == 1:
26751 
        if ftype == TType.I64:
26752 
          self.rechargeOrderId = iprot.readI64();
26753 
        else:
26754 
          iprot.skip(ftype)
26755 
      elif fid == 2:
26756 
        if ftype == TType.I32:
26757 
          self.rechargeOrderStatus = iprot.readI32();
26758 
        else:
26759 
          iprot.skip(ftype)
26760 
      else:
26761 
        iprot.skip(ftype)
26762 
      iprot.readFieldEnd()
26763 
    iprot.readStructEnd()
26764 
 
26765 
  def write(self, oprot):
26766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26768 
      return
26769 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26770 
    if self.rechargeOrderId is not None:
26771 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26772 
      oprot.writeI64(self.rechargeOrderId)
26773 
      oprot.writeFieldEnd()
26774 
    if self.rechargeOrderStatus is not None:
26775 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26776 
      oprot.writeI32(self.rechargeOrderStatus)
26777 
      oprot.writeFieldEnd()
26778 
    oprot.writeFieldStop()
26779 
    oprot.writeStructEnd()
26780 
 
26781 
  def validate(self):
26782 
    return
26783 
 
26784 
 
26785 
  def __repr__(self):
26786 
    L = ['%s=%r' % (key, value)
26787 
      for key, value in self.__dict__.iteritems()]
26788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26789 
 
26790 
  def __eq__(self, other):
26791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26792 
 
26793 
  def __ne__(self, other):
26794 
    return not (self == other)
26795 
 
26796 
class updateRechargeOrderStatus_result:
26797 
  """
26798 
  Attributes:
6031 rajveer 26799 
   - success
6000 mandeep.dh 26800 
   - ex
26801 
  """
26802 
 
26803 
  thrift_spec = (
6031 rajveer 26804 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26806 
  )
26807 
 
6031 rajveer 26808 
  def __init__(self, success=None, ex=None,):
26809 
    self.success = success
6000 mandeep.dh 26810 
    self.ex = ex
26811 
 
26812 
  def read(self, iprot):
26813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26815 
      return
26816 
    iprot.readStructBegin()
26817 
    while True:
26818 
      (fname, ftype, fid) = iprot.readFieldBegin()
26819 
      if ftype == TType.STOP:
26820 
        break
6031 rajveer 26821 
      if fid == 0:
26822 
        if ftype == TType.BOOL:
26823 
          self.success = iprot.readBool();
26824 
        else:
26825 
          iprot.skip(ftype)
26826 
      elif fid == 1:
6000 mandeep.dh 26827 
        if ftype == TType.STRUCT:
26828 
          self.ex = TransactionServiceException()
26829 
          self.ex.read(iprot)
26830 
        else:
26831 
          iprot.skip(ftype)
26832 
      else:
26833 
        iprot.skip(ftype)
26834 
      iprot.readFieldEnd()
26835 
    iprot.readStructEnd()
26836 
 
26837 
  def write(self, oprot):
26838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26840 
      return
26841 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26842 
    if self.success is not None:
26843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26844 
      oprot.writeBool(self.success)
26845 
      oprot.writeFieldEnd()
6000 mandeep.dh 26846 
    if self.ex is not None:
26847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26848 
      self.ex.write(oprot)
26849 
      oprot.writeFieldEnd()
26850 
    oprot.writeFieldStop()
26851 
    oprot.writeStructEnd()
26852 
 
26853 
  def validate(self):
26854 
    return
26855 
 
26856 
 
26857 
  def __repr__(self):
26858 
    L = ['%s=%r' % (key, value)
26859 
      for key, value in self.__dict__.iteritems()]
26860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26861 
 
26862 
  def __eq__(self, other):
26863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26864 
 
26865 
  def __ne__(self, other):
26866 
    return not (self == other)
26867 
 
26868 
class activateRechargeTxn_args:
26869 
  """
26870 
  Attributes:
6031 rajveer 26871 
   - rechargeOrderId
6000 mandeep.dh 26872 
  """
26873 
 
26874 
  thrift_spec = (
26875 
    None, # 0
6031 rajveer 26876 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26877 
  )
26878 
 
6031 rajveer 26879 
  def __init__(self, rechargeOrderId=None,):
26880 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26881 
 
26882 
  def read(self, iprot):
26883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26885 
      return
26886 
    iprot.readStructBegin()
26887 
    while True:
26888 
      (fname, ftype, fid) = iprot.readFieldBegin()
26889 
      if ftype == TType.STOP:
26890 
        break
26891 
      if fid == 1:
6031 rajveer 26892 
        if ftype == TType.I64:
26893 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26894 
        else:
26895 
          iprot.skip(ftype)
26896 
      else:
26897 
        iprot.skip(ftype)
26898 
      iprot.readFieldEnd()
26899 
    iprot.readStructEnd()
26900 
 
26901 
  def write(self, oprot):
26902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26904 
      return
26905 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26906 
    if self.rechargeOrderId is not None:
26907 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26908 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26909 
      oprot.writeFieldEnd()
26910 
    oprot.writeFieldStop()
26911 
    oprot.writeStructEnd()
26912 
 
26913 
  def validate(self):
26914 
    return
26915 
 
26916 
 
26917 
  def __repr__(self):
26918 
    L = ['%s=%r' % (key, value)
26919 
      for key, value in self.__dict__.iteritems()]
26920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26921 
 
26922 
  def __eq__(self, other):
26923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26924 
 
26925 
  def __ne__(self, other):
26926 
    return not (self == other)
26927 
 
26928 
class activateRechargeTxn_result:
26929 
  """
26930 
  Attributes:
26931 
   - success
26932 
   - ex
26933 
  """
26934 
 
26935 
  thrift_spec = (
6031 rajveer 26936 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26938 
  )
26939 
 
26940 
  def __init__(self, success=None, ex=None,):
26941 
    self.success = success
26942 
    self.ex = ex
26943 
 
26944 
  def read(self, iprot):
26945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26947 
      return
26948 
    iprot.readStructBegin()
26949 
    while True:
26950 
      (fname, ftype, fid) = iprot.readFieldBegin()
26951 
      if ftype == TType.STOP:
26952 
        break
26953 
      if fid == 0:
6031 rajveer 26954 
        if ftype == TType.BOOL:
26955 
          self.success = iprot.readBool();
6000 mandeep.dh 26956 
        else:
26957 
          iprot.skip(ftype)
26958 
      elif fid == 1:
26959 
        if ftype == TType.STRUCT:
26960 
          self.ex = TransactionServiceException()
26961 
          self.ex.read(iprot)
26962 
        else:
26963 
          iprot.skip(ftype)
26964 
      else:
26965 
        iprot.skip(ftype)
26966 
      iprot.readFieldEnd()
26967 
    iprot.readStructEnd()
26968 
 
26969 
  def write(self, oprot):
26970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26972 
      return
26973 
    oprot.writeStructBegin('activateRechargeTxn_result')
26974 
    if self.success is not None:
6031 rajveer 26975 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26976 
      oprot.writeBool(self.success)
6000 mandeep.dh 26977 
      oprot.writeFieldEnd()
26978 
    if self.ex is not None:
26979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26980 
      self.ex.write(oprot)
26981 
      oprot.writeFieldEnd()
26982 
    oprot.writeFieldStop()
26983 
    oprot.writeStructEnd()
26984 
 
26985 
  def validate(self):
26986 
    return
26987 
 
26988 
 
26989 
  def __repr__(self):
26990 
    L = ['%s=%r' % (key, value)
26991 
      for key, value in self.__dict__.iteritems()]
26992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26993 
 
26994 
  def __eq__(self, other):
26995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26996 
 
26997 
  def __ne__(self, other):
26998 
    return not (self == other)
26999 
 
6031 rajveer 27000 
class getUserWallet_args:
6000 mandeep.dh 27001 
  """
27002 
  Attributes:
6031 rajveer 27003 
   - userId
6000 mandeep.dh 27004 
  """
27005 
 
27006 
  thrift_spec = (
27007 
    None, # 0
6031 rajveer 27008 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27009 
  )
27010 
 
6031 rajveer 27011 
  def __init__(self, userId=None,):
27012 
    self.userId = userId
6000 mandeep.dh 27013 
 
27014 
  def read(self, iprot):
27015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27017 
      return
27018 
    iprot.readStructBegin()
27019 
    while True:
27020 
      (fname, ftype, fid) = iprot.readFieldBegin()
27021 
      if ftype == TType.STOP:
27022 
        break
27023 
      if fid == 1:
27024 
        if ftype == TType.I64:
6031 rajveer 27025 
          self.userId = iprot.readI64();
6000 mandeep.dh 27026 
        else:
27027 
          iprot.skip(ftype)
27028 
      else:
27029 
        iprot.skip(ftype)
27030 
      iprot.readFieldEnd()
27031 
    iprot.readStructEnd()
27032 
 
27033 
  def write(self, oprot):
27034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27036 
      return
6031 rajveer 27037 
    oprot.writeStructBegin('getUserWallet_args')
27038 
    if self.userId is not None:
27039 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27040 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27041 
      oprot.writeFieldEnd()
27042 
    oprot.writeFieldStop()
27043 
    oprot.writeStructEnd()
27044 
 
27045 
  def validate(self):
27046 
    return
27047 
 
27048 
 
27049 
  def __repr__(self):
27050 
    L = ['%s=%r' % (key, value)
27051 
      for key, value in self.__dict__.iteritems()]
27052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27053 
 
27054 
  def __eq__(self, other):
27055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27056 
 
27057 
  def __ne__(self, other):
27058 
    return not (self == other)
27059 
 
6031 rajveer 27060 
class getUserWallet_result:
6000 mandeep.dh 27061 
  """
27062 
  Attributes:
27063 
   - success
27064 
  """
27065 
 
27066 
  thrift_spec = (
6031 rajveer 27067 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27068 
  )
27069 
 
27070 
  def __init__(self, success=None,):
27071 
    self.success = success
27072 
 
27073 
  def read(self, iprot):
27074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27076 
      return
27077 
    iprot.readStructBegin()
27078 
    while True:
27079 
      (fname, ftype, fid) = iprot.readFieldBegin()
27080 
      if ftype == TType.STOP:
27081 
        break
27082 
      if fid == 0:
6031 rajveer 27083 
        if ftype == TType.STRUCT:
27084 
          self.success = UserWallet()
27085 
          self.success.read(iprot)
6000 mandeep.dh 27086 
        else:
27087 
          iprot.skip(ftype)
27088 
      else:
27089 
        iprot.skip(ftype)
27090 
      iprot.readFieldEnd()
27091 
    iprot.readStructEnd()
27092 
 
27093 
  def write(self, oprot):
27094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27096 
      return
6031 rajveer 27097 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27098 
    if self.success is not None:
6031 rajveer 27099 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27100 
      self.success.write(oprot)
6000 mandeep.dh 27101 
      oprot.writeFieldEnd()
27102 
    oprot.writeFieldStop()
27103 
    oprot.writeStructEnd()
27104 
 
27105 
  def validate(self):
27106 
    return
27107 
 
27108 
 
27109 
  def __repr__(self):
27110 
    L = ['%s=%r' % (key, value)
27111 
      for key, value in self.__dict__.iteritems()]
27112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27113 
 
27114 
  def __eq__(self, other):
27115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27116 
 
27117 
  def __ne__(self, other):
27118 
    return not (self == other)
27119 
 
6031 rajveer 27120 
class getUserWalletHistory_args:
6000 mandeep.dh 27121 
  """
27122 
  Attributes:
6031 rajveer 27123 
   - userId
6000 mandeep.dh 27124 
  """
27125 
 
27126 
  thrift_spec = (
27127 
    None, # 0
6031 rajveer 27128 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27129 
  )
27130 
 
6031 rajveer 27131 
  def __init__(self, userId=None,):
27132 
    self.userId = userId
6000 mandeep.dh 27133 
 
27134 
  def read(self, iprot):
27135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27137 
      return
27138 
    iprot.readStructBegin()
27139 
    while True:
27140 
      (fname, ftype, fid) = iprot.readFieldBegin()
27141 
      if ftype == TType.STOP:
27142 
        break
27143 
      if fid == 1:
27144 
        if ftype == TType.I64:
6031 rajveer 27145 
          self.userId = iprot.readI64();
6000 mandeep.dh 27146 
        else:
27147 
          iprot.skip(ftype)
27148 
      else:
27149 
        iprot.skip(ftype)
27150 
      iprot.readFieldEnd()
27151 
    iprot.readStructEnd()
27152 
 
27153 
  def write(self, oprot):
27154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27156 
      return
6031 rajveer 27157 
    oprot.writeStructBegin('getUserWalletHistory_args')
27158 
    if self.userId is not None:
27159 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27160 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27161 
      oprot.writeFieldEnd()
27162 
    oprot.writeFieldStop()
27163 
    oprot.writeStructEnd()
27164 
 
27165 
  def validate(self):
27166 
    return
27167 
 
27168 
 
27169 
  def __repr__(self):
27170 
    L = ['%s=%r' % (key, value)
27171 
      for key, value in self.__dict__.iteritems()]
27172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27173 
 
27174 
  def __eq__(self, other):
27175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27176 
 
27177 
  def __ne__(self, other):
27178 
    return not (self == other)
27179 
 
6031 rajveer 27180 
class getUserWalletHistory_result:
6000 mandeep.dh 27181 
  """
27182 
  Attributes:
27183 
   - success
27184 
  """
27185 
 
27186 
  thrift_spec = (
6031 rajveer 27187 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27188 
  )
27189 
 
27190 
  def __init__(self, success=None,):
27191 
    self.success = success
27192 
 
27193 
  def read(self, iprot):
27194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27196 
      return
27197 
    iprot.readStructBegin()
27198 
    while True:
27199 
      (fname, ftype, fid) = iprot.readFieldBegin()
27200 
      if ftype == TType.STOP:
27201 
        break
27202 
      if fid == 0:
27203 
        if ftype == TType.LIST:
27204 
          self.success = []
6031 rajveer 27205 
          (_etype623, _size620) = iprot.readListBegin()
27206 
          for _i624 in xrange(_size620):
27207 
            _elem625 = UserWalletHistory()
27208 
            _elem625.read(iprot)
27209 
            self.success.append(_elem625)
6000 mandeep.dh 27210 
          iprot.readListEnd()
27211 
        else:
27212 
          iprot.skip(ftype)
27213 
      else:
27214 
        iprot.skip(ftype)
27215 
      iprot.readFieldEnd()
27216 
    iprot.readStructEnd()
27217 
 
27218 
  def write(self, oprot):
27219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27221 
      return
6031 rajveer 27222 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27223 
    if self.success is not None:
27224 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27225 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 27226 
      for iter626 in self.success:
27227 
        iter626.write(oprot)
6000 mandeep.dh 27228 
      oprot.writeListEnd()
27229 
      oprot.writeFieldEnd()
27230 
    oprot.writeFieldStop()
27231 
    oprot.writeStructEnd()
27232 
 
27233 
  def validate(self):
27234 
    return
27235 
 
27236 
 
27237 
  def __repr__(self):
27238 
    L = ['%s=%r' % (key, value)
27239 
      for key, value in self.__dict__.iteritems()]
27240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27241 
 
27242 
  def __eq__(self, other):
27243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27244 
 
27245 
  def __ne__(self, other):
27246 
    return not (self == other)
6048 rajveer 27247 
 
6050 anupam.sin 27248 
class getRechargeOrdersForTransaction_args:
27249 
  """
27250 
  Attributes:
27251 
   - txnId
27252 
  """
27253 
 
27254 
  thrift_spec = (
27255 
    None, # 0
27256 
    (1, TType.I64, 'txnId', None, None, ), # 1
27257 
  )
27258 
 
27259 
  def __init__(self, txnId=None,):
27260 
    self.txnId = txnId
27261 
 
27262 
  def read(self, iprot):
27263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27265 
      return
27266 
    iprot.readStructBegin()
27267 
    while True:
27268 
      (fname, ftype, fid) = iprot.readFieldBegin()
27269 
      if ftype == TType.STOP:
27270 
        break
27271 
      if fid == 1:
27272 
        if ftype == TType.I64:
27273 
          self.txnId = iprot.readI64();
27274 
        else:
27275 
          iprot.skip(ftype)
27276 
      else:
27277 
        iprot.skip(ftype)
27278 
      iprot.readFieldEnd()
27279 
    iprot.readStructEnd()
27280 
 
27281 
  def write(self, oprot):
27282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27284 
      return
27285 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27286 
    if self.txnId is not None:
27287 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27288 
      oprot.writeI64(self.txnId)
27289 
      oprot.writeFieldEnd()
27290 
    oprot.writeFieldStop()
27291 
    oprot.writeStructEnd()
27292 
 
27293 
  def validate(self):
27294 
    return
27295 
 
27296 
 
27297 
  def __repr__(self):
27298 
    L = ['%s=%r' % (key, value)
27299 
      for key, value in self.__dict__.iteritems()]
27300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27301 
 
27302 
  def __eq__(self, other):
27303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27304 
 
27305 
  def __ne__(self, other):
27306 
    return not (self == other)
27307 
 
27308 
class getRechargeOrdersForTransaction_result:
27309 
  """
27310 
  Attributes:
27311 
   - success
27312 
   - ex
27313 
  """
27314 
 
27315 
  thrift_spec = (
27316 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27317 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27318 
  )
27319 
 
27320 
  def __init__(self, success=None, ex=None,):
27321 
    self.success = success
27322 
    self.ex = ex
27323 
 
27324 
  def read(self, iprot):
27325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27327 
      return
27328 
    iprot.readStructBegin()
27329 
    while True:
27330 
      (fname, ftype, fid) = iprot.readFieldBegin()
27331 
      if ftype == TType.STOP:
27332 
        break
27333 
      if fid == 0:
27334 
        if ftype == TType.STRUCT:
27335 
          self.success = RechargeOrder()
27336 
          self.success.read(iprot)
27337 
        else:
27338 
          iprot.skip(ftype)
27339 
      elif fid == 1:
27340 
        if ftype == TType.STRUCT:
27341 
          self.ex = TransactionServiceException()
27342 
          self.ex.read(iprot)
27343 
        else:
27344 
          iprot.skip(ftype)
27345 
      else:
27346 
        iprot.skip(ftype)
27347 
      iprot.readFieldEnd()
27348 
    iprot.readStructEnd()
27349 
 
27350 
  def write(self, oprot):
27351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27353 
      return
27354 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27355 
    if self.success is not None:
27356 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27357 
      self.success.write(oprot)
27358 
      oprot.writeFieldEnd()
27359 
    if self.ex is not None:
27360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27361 
      self.ex.write(oprot)
27362 
      oprot.writeFieldEnd()
27363 
    oprot.writeFieldStop()
27364 
    oprot.writeStructEnd()
27365 
 
27366 
  def validate(self):
27367 
    return
27368 
 
27369 
 
27370 
  def __repr__(self):
27371 
    L = ['%s=%r' % (key, value)
27372 
      for key, value in self.__dict__.iteritems()]
27373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27374 
 
27375 
  def __eq__(self, other):
27376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27377 
 
27378 
  def __ne__(self, other):
27379 
    return not (self == other)
27380 
 
6048 rajveer 27381 
class getServiceProviders_args:
27382 
  """
27383 
  Attributes:
27384 
   - rechargeType
27385 
  """
27386 
 
27387 
  thrift_spec = (
27388 
    None, # 0
27389 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27390 
  )
27391 
 
27392 
  def __init__(self, rechargeType=None,):
27393 
    self.rechargeType = rechargeType
27394 
 
27395 
  def read(self, iprot):
27396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27398 
      return
27399 
    iprot.readStructBegin()
27400 
    while True:
27401 
      (fname, ftype, fid) = iprot.readFieldBegin()
27402 
      if ftype == TType.STOP:
27403 
        break
27404 
      if fid == 1:
27405 
        if ftype == TType.I32:
27406 
          self.rechargeType = iprot.readI32();
27407 
        else:
27408 
          iprot.skip(ftype)
27409 
      else:
27410 
        iprot.skip(ftype)
27411 
      iprot.readFieldEnd()
27412 
    iprot.readStructEnd()
27413 
 
27414 
  def write(self, oprot):
27415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27417 
      return
27418 
    oprot.writeStructBegin('getServiceProviders_args')
27419 
    if self.rechargeType is not None:
27420 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27421 
      oprot.writeI32(self.rechargeType)
27422 
      oprot.writeFieldEnd()
27423 
    oprot.writeFieldStop()
27424 
    oprot.writeStructEnd()
27425 
 
27426 
  def validate(self):
27427 
    return
27428 
 
27429 
 
27430 
  def __repr__(self):
27431 
    L = ['%s=%r' % (key, value)
27432 
      for key, value in self.__dict__.iteritems()]
27433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27434 
 
27435 
  def __eq__(self, other):
27436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27437 
 
27438 
  def __ne__(self, other):
27439 
    return not (self == other)
27440 
 
27441 
class getServiceProviders_result:
27442 
  """
27443 
  Attributes:
27444 
   - success
27445 
  """
27446 
 
27447 
  thrift_spec = (
27448 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27449 
  )
27450 
 
27451 
  def __init__(self, success=None,):
27452 
    self.success = success
27453 
 
27454 
  def read(self, iprot):
27455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27457 
      return
27458 
    iprot.readStructBegin()
27459 
    while True:
27460 
      (fname, ftype, fid) = iprot.readFieldBegin()
27461 
      if ftype == TType.STOP:
27462 
        break
27463 
      if fid == 0:
27464 
        if ftype == TType.MAP:
27465 
          self.success = {}
27466 
          (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin()
27467 
          for _i631 in xrange(_size627):
27468 
            _key632 = iprot.readI64();
27469 
            _val633 = iprot.readString();
27470 
            self.success[_key632] = _val633
27471 
          iprot.readMapEnd()
27472 
        else:
27473 
          iprot.skip(ftype)
27474 
      else:
27475 
        iprot.skip(ftype)
27476 
      iprot.readFieldEnd()
27477 
    iprot.readStructEnd()
27478 
 
27479 
  def write(self, oprot):
27480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27482 
      return
27483 
    oprot.writeStructBegin('getServiceProviders_result')
27484 
    if self.success is not None:
27485 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27486 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
27487 
      for kiter634,viter635 in self.success.items():
27488 
        oprot.writeI64(kiter634)
27489 
        oprot.writeString(viter635)
27490 
      oprot.writeMapEnd()
27491 
      oprot.writeFieldEnd()
27492 
    oprot.writeFieldStop()
27493 
    oprot.writeStructEnd()
27494 
 
27495 
  def validate(self):
27496 
    return
27497 
 
27498 
 
27499 
  def __repr__(self):
27500 
    L = ['%s=%r' % (key, value)
27501 
      for key, value in self.__dict__.iteritems()]
27502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27503 
 
27504 
  def __eq__(self, other):
27505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27506 
 
27507 
  def __ne__(self, other):
27508 
    return not (self == other)
27509 
 
27510 
class getServiceProviderForDevice_args:
27511 
  """
27512 
  Attributes:
6049 rajveer 27513 
   - rechargeType
6048 rajveer 27514 
   - deviceNumber
27515 
  """
27516 
 
27517 
  thrift_spec = (
27518 
    None, # 0
6049 rajveer 27519 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27520 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27521 
  )
27522 
 
6049 rajveer 27523 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27524 
    self.rechargeType = rechargeType
6048 rajveer 27525 
    self.deviceNumber = deviceNumber
27526 
 
27527 
  def read(self, iprot):
27528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27530 
      return
27531 
    iprot.readStructBegin()
27532 
    while True:
27533 
      (fname, ftype, fid) = iprot.readFieldBegin()
27534 
      if ftype == TType.STOP:
27535 
        break
27536 
      if fid == 1:
6049 rajveer 27537 
        if ftype == TType.I32:
27538 
          self.rechargeType = iprot.readI32();
27539 
        else:
27540 
          iprot.skip(ftype)
27541 
      elif fid == 2:
6048 rajveer 27542 
        if ftype == TType.STRING:
27543 
          self.deviceNumber = iprot.readString();
27544 
        else:
27545 
          iprot.skip(ftype)
27546 
      else:
27547 
        iprot.skip(ftype)
27548 
      iprot.readFieldEnd()
27549 
    iprot.readStructEnd()
27550 
 
27551 
  def write(self, oprot):
27552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27554 
      return
27555 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27556 
    if self.rechargeType is not None:
27557 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27558 
      oprot.writeI32(self.rechargeType)
27559 
      oprot.writeFieldEnd()
6048 rajveer 27560 
    if self.deviceNumber is not None:
6049 rajveer 27561 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27562 
      oprot.writeString(self.deviceNumber)
27563 
      oprot.writeFieldEnd()
27564 
    oprot.writeFieldStop()
27565 
    oprot.writeStructEnd()
27566 
 
27567 
  def validate(self):
27568 
    return
27569 
 
27570 
 
27571 
  def __repr__(self):
27572 
    L = ['%s=%r' % (key, value)
27573 
      for key, value in self.__dict__.iteritems()]
27574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27575 
 
27576 
  def __eq__(self, other):
27577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27578 
 
27579 
  def __ne__(self, other):
27580 
    return not (self == other)
27581 
 
27582 
class getServiceProviderForDevice_result:
27583 
  """
27584 
  Attributes:
27585 
   - success
27586 
  """
27587 
 
27588 
  thrift_spec = (
27589 
    (0, TType.I64, 'success', None, None, ), # 0
27590 
  )
27591 
 
27592 
  def __init__(self, success=None,):
27593 
    self.success = success
27594 
 
27595 
  def read(self, iprot):
27596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27598 
      return
27599 
    iprot.readStructBegin()
27600 
    while True:
27601 
      (fname, ftype, fid) = iprot.readFieldBegin()
27602 
      if ftype == TType.STOP:
27603 
        break
27604 
      if fid == 0:
27605 
        if ftype == TType.I64:
27606 
          self.success = iprot.readI64();
27607 
        else:
27608 
          iprot.skip(ftype)
27609 
      else:
27610 
        iprot.skip(ftype)
27611 
      iprot.readFieldEnd()
27612 
    iprot.readStructEnd()
27613 
 
27614 
  def write(self, oprot):
27615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27617 
      return
27618 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27619 
    if self.success is not None:
27620 
      oprot.writeFieldBegin('success', TType.I64, 0)
27621 
      oprot.writeI64(self.success)
27622 
      oprot.writeFieldEnd()
27623 
    oprot.writeFieldStop()
27624 
    oprot.writeStructEnd()
27625 
 
27626 
  def validate(self):
27627 
    return
27628 
 
27629 
 
27630 
  def __repr__(self):
27631 
    L = ['%s=%r' % (key, value)
27632 
      for key, value in self.__dict__.iteritems()]
27633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27634 
 
27635 
  def __eq__(self, other):
27636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27637 
 
27638 
  def __ne__(self, other):
27639 
    return not (self == other)
6094 rajveer 27640 
 
27641 
class getRechargeOrdersForDevice_args:
27642 
  """
27643 
  Attributes:
27644 
   - deviceNumber
27645 
  """
27646 
 
27647 
  thrift_spec = (
27648 
    None, # 0
27649 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27650 
  )
27651 
 
27652 
  def __init__(self, deviceNumber=None,):
27653 
    self.deviceNumber = deviceNumber
27654 
 
27655 
  def read(self, iprot):
27656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27658 
      return
27659 
    iprot.readStructBegin()
27660 
    while True:
27661 
      (fname, ftype, fid) = iprot.readFieldBegin()
27662 
      if ftype == TType.STOP:
27663 
        break
27664 
      if fid == 1:
27665 
        if ftype == TType.STRING:
27666 
          self.deviceNumber = iprot.readString();
27667 
        else:
27668 
          iprot.skip(ftype)
27669 
      else:
27670 
        iprot.skip(ftype)
27671 
      iprot.readFieldEnd()
27672 
    iprot.readStructEnd()
27673 
 
27674 
  def write(self, oprot):
27675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27677 
      return
27678 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27679 
    if self.deviceNumber is not None:
27680 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27681 
      oprot.writeString(self.deviceNumber)
27682 
      oprot.writeFieldEnd()
27683 
    oprot.writeFieldStop()
27684 
    oprot.writeStructEnd()
27685 
 
27686 
  def validate(self):
27687 
    return
27688 
 
27689 
 
27690 
  def __repr__(self):
27691 
    L = ['%s=%r' % (key, value)
27692 
      for key, value in self.__dict__.iteritems()]
27693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27694 
 
27695 
  def __eq__(self, other):
27696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27697 
 
27698 
  def __ne__(self, other):
27699 
    return not (self == other)
27700 
 
27701 
class getRechargeOrdersForDevice_result:
27702 
  """
27703 
  Attributes:
27704 
   - success
27705 
  """
27706 
 
27707 
  thrift_spec = (
27708 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27709 
  )
27710 
 
27711 
  def __init__(self, success=None,):
27712 
    self.success = success
27713 
 
27714 
  def read(self, iprot):
27715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27717 
      return
27718 
    iprot.readStructBegin()
27719 
    while True:
27720 
      (fname, ftype, fid) = iprot.readFieldBegin()
27721 
      if ftype == TType.STOP:
27722 
        break
27723 
      if fid == 0:
27724 
        if ftype == TType.LIST:
27725 
          self.success = []
27726 
          (_etype639, _size636) = iprot.readListBegin()
27727 
          for _i640 in xrange(_size636):
27728 
            _elem641 = RechargeOrder()
27729 
            _elem641.read(iprot)
27730 
            self.success.append(_elem641)
27731 
          iprot.readListEnd()
27732 
        else:
27733 
          iprot.skip(ftype)
27734 
      else:
27735 
        iprot.skip(ftype)
27736 
      iprot.readFieldEnd()
27737 
    iprot.readStructEnd()
27738 
 
27739 
  def write(self, oprot):
27740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27742 
      return
27743 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27744 
    if self.success is not None:
27745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27747 
      for iter642 in self.success:
27748 
        iter642.write(oprot)
27749 
      oprot.writeListEnd()
27750 
      oprot.writeFieldEnd()
27751 
    oprot.writeFieldStop()
27752 
    oprot.writeStructEnd()
27753 
 
27754 
  def validate(self):
27755 
    return
27756 
 
27757 
 
27758 
  def __repr__(self):
27759 
    L = ['%s=%r' % (key, value)
27760 
      for key, value in self.__dict__.iteritems()]
27761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27762 
 
27763 
  def __eq__(self, other):
27764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27765 
 
27766 
  def __ne__(self, other):
27767 
    return not (self == other)
27768 
 
27769 
class addAmountToWallet_args:
27770 
  """
27771 
  Attributes:
27772 
   - userId
27773 
   - orderId
27774 
   - amount
27775 
  """
27776 
 
27777 
  thrift_spec = (
27778 
    None, # 0
27779 
    (1, TType.I64, 'userId', None, None, ), # 1
27780 
    (2, TType.I64, 'orderId', None, None, ), # 2
27781 
    (3, TType.I64, 'amount', None, None, ), # 3
27782 
  )
27783 
 
27784 
  def __init__(self, userId=None, orderId=None, amount=None,):
27785 
    self.userId = userId
27786 
    self.orderId = orderId
27787 
    self.amount = amount
27788 
 
27789 
  def read(self, iprot):
27790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27792 
      return
27793 
    iprot.readStructBegin()
27794 
    while True:
27795 
      (fname, ftype, fid) = iprot.readFieldBegin()
27796 
      if ftype == TType.STOP:
27797 
        break
27798 
      if fid == 1:
27799 
        if ftype == TType.I64:
27800 
          self.userId = iprot.readI64();
27801 
        else:
27802 
          iprot.skip(ftype)
27803 
      elif fid == 2:
27804 
        if ftype == TType.I64:
27805 
          self.orderId = iprot.readI64();
27806 
        else:
27807 
          iprot.skip(ftype)
27808 
      elif fid == 3:
27809 
        if ftype == TType.I64:
27810 
          self.amount = iprot.readI64();
27811 
        else:
27812 
          iprot.skip(ftype)
27813 
      else:
27814 
        iprot.skip(ftype)
27815 
      iprot.readFieldEnd()
27816 
    iprot.readStructEnd()
27817 
 
27818 
  def write(self, oprot):
27819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27821 
      return
27822 
    oprot.writeStructBegin('addAmountToWallet_args')
27823 
    if self.userId is not None:
27824 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27825 
      oprot.writeI64(self.userId)
27826 
      oprot.writeFieldEnd()
27827 
    if self.orderId is not None:
27828 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
27829 
      oprot.writeI64(self.orderId)
27830 
      oprot.writeFieldEnd()
27831 
    if self.amount is not None:
27832 
      oprot.writeFieldBegin('amount', TType.I64, 3)
27833 
      oprot.writeI64(self.amount)
27834 
      oprot.writeFieldEnd()
27835 
    oprot.writeFieldStop()
27836 
    oprot.writeStructEnd()
27837 
 
27838 
  def validate(self):
27839 
    return
27840 
 
27841 
 
27842 
  def __repr__(self):
27843 
    L = ['%s=%r' % (key, value)
27844 
      for key, value in self.__dict__.iteritems()]
27845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27846 
 
27847 
  def __eq__(self, other):
27848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27849 
 
27850 
  def __ne__(self, other):
27851 
    return not (self == other)
27852 
 
27853 
class addAmountToWallet_result:
27854 
 
27855 
  thrift_spec = (
27856 
  )
27857 
 
27858 
  def read(self, iprot):
27859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27861 
      return
27862 
    iprot.readStructBegin()
27863 
    while True:
27864 
      (fname, ftype, fid) = iprot.readFieldBegin()
27865 
      if ftype == TType.STOP:
27866 
        break
27867 
      else:
27868 
        iprot.skip(ftype)
27869 
      iprot.readFieldEnd()
27870 
    iprot.readStructEnd()
27871 
 
27872 
  def write(self, oprot):
27873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27875 
      return
27876 
    oprot.writeStructBegin('addAmountToWallet_result')
27877 
    oprot.writeFieldStop()
27878 
    oprot.writeStructEnd()
27879 
 
27880 
  def validate(self):
27881 
    return
27882 
 
27883 
 
27884 
  def __repr__(self):
27885 
    L = ['%s=%r' % (key, value)
27886 
      for key, value in self.__dict__.iteritems()]
27887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27888 
 
27889 
  def __eq__(self, other):
27890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27891 
 
27892 
  def __ne__(self, other):
27893 
    return not (self == other)
6154 rajveer 27894 
 
27895 
class getRechargeOrdersForStatus_args:
27896 
  """
27897 
  Attributes:
27898 
   - status
27899 
  """
27900 
 
27901 
  thrift_spec = (
27902 
    None, # 0
27903 
    (1, TType.I64, 'status', None, None, ), # 1
27904 
  )
27905 
 
27906 
  def __init__(self, status=None,):
27907 
    self.status = status
27908 
 
27909 
  def read(self, iprot):
27910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27912 
      return
27913 
    iprot.readStructBegin()
27914 
    while True:
27915 
      (fname, ftype, fid) = iprot.readFieldBegin()
27916 
      if ftype == TType.STOP:
27917 
        break
27918 
      if fid == 1:
27919 
        if ftype == TType.I64:
27920 
          self.status = iprot.readI64();
27921 
        else:
27922 
          iprot.skip(ftype)
27923 
      else:
27924 
        iprot.skip(ftype)
27925 
      iprot.readFieldEnd()
27926 
    iprot.readStructEnd()
27927 
 
27928 
  def write(self, oprot):
27929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27931 
      return
27932 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
27933 
    if self.status is not None:
27934 
      oprot.writeFieldBegin('status', TType.I64, 1)
27935 
      oprot.writeI64(self.status)
27936 
      oprot.writeFieldEnd()
27937 
    oprot.writeFieldStop()
27938 
    oprot.writeStructEnd()
27939 
 
27940 
  def validate(self):
27941 
    return
27942 
 
27943 
 
27944 
  def __repr__(self):
27945 
    L = ['%s=%r' % (key, value)
27946 
      for key, value in self.__dict__.iteritems()]
27947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27948 
 
27949 
  def __eq__(self, other):
27950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27951 
 
27952 
  def __ne__(self, other):
27953 
    return not (self == other)
27954 
 
27955 
class getRechargeOrdersForStatus_result:
27956 
  """
27957 
  Attributes:
27958 
   - success
27959 
  """
27960 
 
27961 
  thrift_spec = (
27962 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27963 
  )
27964 
 
27965 
  def __init__(self, success=None,):
27966 
    self.success = success
27967 
 
27968 
  def read(self, iprot):
27969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27971 
      return
27972 
    iprot.readStructBegin()
27973 
    while True:
27974 
      (fname, ftype, fid) = iprot.readFieldBegin()
27975 
      if ftype == TType.STOP:
27976 
        break
27977 
      if fid == 0:
27978 
        if ftype == TType.LIST:
27979 
          self.success = []
27980 
          (_etype646, _size643) = iprot.readListBegin()
27981 
          for _i647 in xrange(_size643):
27982 
            _elem648 = RechargeOrder()
27983 
            _elem648.read(iprot)
27984 
            self.success.append(_elem648)
27985 
          iprot.readListEnd()
27986 
        else:
27987 
          iprot.skip(ftype)
27988 
      else:
27989 
        iprot.skip(ftype)
27990 
      iprot.readFieldEnd()
27991 
    iprot.readStructEnd()
27992 
 
27993 
  def write(self, oprot):
27994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27996 
      return
27997 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
27998 
    if self.success is not None:
27999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28001 
      for iter649 in self.success:
28002 
        iter649.write(oprot)
28003 
      oprot.writeListEnd()
28004 
      oprot.writeFieldEnd()
28005 
    oprot.writeFieldStop()
28006 
    oprot.writeStructEnd()
28007 
 
28008 
  def validate(self):
28009 
    return
28010 
 
28011 
 
28012 
  def __repr__(self):
28013 
    L = ['%s=%r' % (key, value)
28014 
      for key, value in self.__dict__.iteritems()]
28015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28016 
 
28017 
  def __eq__(self, other):
28018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28019 
 
28020 
  def __ne__(self, other):
28021 
    return not (self == other)
6159 rajveer 28022 
 
28023 
class getPlansForOperator_args:
28024 
  """
28025 
  Attributes:
28026 
   - operatorId
28027 
  """
28028 
 
28029 
  thrift_spec = (
28030 
    None, # 0
28031 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28032 
  )
28033 
 
28034 
  def __init__(self, operatorId=None,):
28035 
    self.operatorId = operatorId
28036 
 
28037 
  def read(self, iprot):
28038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28040 
      return
28041 
    iprot.readStructBegin()
28042 
    while True:
28043 
      (fname, ftype, fid) = iprot.readFieldBegin()
28044 
      if ftype == TType.STOP:
28045 
        break
28046 
      if fid == 1:
28047 
        if ftype == TType.I64:
28048 
          self.operatorId = iprot.readI64();
28049 
        else:
28050 
          iprot.skip(ftype)
28051 
      else:
28052 
        iprot.skip(ftype)
28053 
      iprot.readFieldEnd()
28054 
    iprot.readStructEnd()
28055 
 
28056 
  def write(self, oprot):
28057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28059 
      return
28060 
    oprot.writeStructBegin('getPlansForOperator_args')
28061 
    if self.operatorId is not None:
28062 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28063 
      oprot.writeI64(self.operatorId)
28064 
      oprot.writeFieldEnd()
28065 
    oprot.writeFieldStop()
28066 
    oprot.writeStructEnd()
28067 
 
28068 
  def validate(self):
28069 
    return
28070 
 
28071 
 
28072 
  def __repr__(self):
28073 
    L = ['%s=%r' % (key, value)
28074 
      for key, value in self.__dict__.iteritems()]
28075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28076 
 
28077 
  def __eq__(self, other):
28078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28079 
 
28080 
  def __ne__(self, other):
28081 
    return not (self == other)
28082 
 
28083 
class getPlansForOperator_result:
28084 
  """
28085 
  Attributes:
28086 
   - success
28087 
  """
28088 
 
28089 
  thrift_spec = (
28090 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28091 
  )
28092 
 
28093 
  def __init__(self, success=None,):
28094 
    self.success = success
28095 
 
28096 
  def read(self, iprot):
28097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28099 
      return
28100 
    iprot.readStructBegin()
28101 
    while True:
28102 
      (fname, ftype, fid) = iprot.readFieldBegin()
28103 
      if ftype == TType.STOP:
28104 
        break
28105 
      if fid == 0:
28106 
        if ftype == TType.LIST:
28107 
          self.success = []
28108 
          (_etype653, _size650) = iprot.readListBegin()
28109 
          for _i654 in xrange(_size650):
28110 
            _elem655 = RechargePlan()
28111 
            _elem655.read(iprot)
28112 
            self.success.append(_elem655)
28113 
          iprot.readListEnd()
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('getPlansForOperator_result')
28126 
    if self.success is not None:
28127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28129 
      for iter656 in self.success:
28130 
        iter656.write(oprot)
28131 
      oprot.writeListEnd()
28132 
      oprot.writeFieldEnd()
28133 
    oprot.writeFieldStop()
28134 
    oprot.writeStructEnd()
28135 
 
28136 
  def validate(self):
28137 
    return
28138 
 
28139 
 
28140 
  def __repr__(self):
28141 
    L = ['%s=%r' % (key, value)
28142 
      for key, value in self.__dict__.iteritems()]
28143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28144 
 
28145 
  def __eq__(self, other):
28146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28147 
 
28148 
  def __ne__(self, other):
28149 
    return not (self == other)