Subversion Repositories SmartDukaan

Rev

Rev 6019 | Rev 6048 | 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 
 
1340 
 
3376 rajveer 1341 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1342 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1343 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1344 
 
1345 
  def createTransaction(self, transaction):
1346 
    """
1347 
    Parameters:
1348 
     - transaction
1349 
    """
1350 
    self.send_createTransaction(transaction)
132 ashish 1351 
    return self.recv_createTransaction()
94 ashish 1352 
 
1353 
  def send_createTransaction(self, transaction):
1354 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1355 
    args = createTransaction_args()
1356 
    args.transaction = transaction
1357 
    args.write(self._oprot)
1358 
    self._oprot.writeMessageEnd()
1359 
    self._oprot.trans.flush()
1360 
 
1361 
  def recv_createTransaction(self, ):
1362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1363 
    if mtype == TMessageType.EXCEPTION:
1364 
      x = TApplicationException()
1365 
      x.read(self._iprot)
1366 
      self._iprot.readMessageEnd()
1367 
      raise x
1368 
    result = createTransaction_result()
1369 
    result.read(self._iprot)
1370 
    self._iprot.readMessageEnd()
3431 rajveer 1371 
    if result.success is not None:
132 ashish 1372 
      return result.success
3431 rajveer 1373 
    if result.ex is not None:
94 ashish 1374 
      raise result.ex
132 ashish 1375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1376 
 
1377 
  def getTransaction(self, id):
1378 
    """
1379 
    Parameters:
1380 
     - id
1381 
    """
1382 
    self.send_getTransaction(id)
1383 
    return self.recv_getTransaction()
1384 
 
1385 
  def send_getTransaction(self, id):
1386 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1387 
    args = getTransaction_args()
1388 
    args.id = id
1389 
    args.write(self._oprot)
1390 
    self._oprot.writeMessageEnd()
1391 
    self._oprot.trans.flush()
1392 
 
1393 
  def recv_getTransaction(self, ):
1394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1395 
    if mtype == TMessageType.EXCEPTION:
1396 
      x = TApplicationException()
1397 
      x.read(self._iprot)
1398 
      self._iprot.readMessageEnd()
1399 
      raise x
1400 
    result = getTransaction_result()
1401 
    result.read(self._iprot)
1402 
    self._iprot.readMessageEnd()
3431 rajveer 1403 
    if result.success is not None:
94 ashish 1404 
      return result.success
3431 rajveer 1405 
    if result.ex is not None:
94 ashish 1406 
      raise result.ex
1407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1408 
 
1409 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1410 
    """
1411 
    Parameters:
1412 
     - customerId
1413 
     - from_date
1414 
     - to_date
1415 
     - status
1416 
    """
1417 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1418 
    return self.recv_getTransactionsForCustomer()
1419 
 
1420 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1421 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1422 
    args = getTransactionsForCustomer_args()
1423 
    args.customerId = customerId
1424 
    args.from_date = from_date
1425 
    args.to_date = to_date
1426 
    args.status = status
1427 
    args.write(self._oprot)
1428 
    self._oprot.writeMessageEnd()
1429 
    self._oprot.trans.flush()
1430 
 
1431 
  def recv_getTransactionsForCustomer(self, ):
1432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1433 
    if mtype == TMessageType.EXCEPTION:
1434 
      x = TApplicationException()
1435 
      x.read(self._iprot)
1436 
      self._iprot.readMessageEnd()
1437 
      raise x
1438 
    result = getTransactionsForCustomer_result()
1439 
    result.read(self._iprot)
1440 
    self._iprot.readMessageEnd()
3431 rajveer 1441 
    if result.success is not None:
94 ashish 1442 
      return result.success
3431 rajveer 1443 
    if result.ex is not None:
94 ashish 1444 
      raise result.ex
1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1446 
 
132 ashish 1447 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1448 
    """
1449 
    Parameters:
1450 
     - shoppingCartId
1451 
    """
1452 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1453 
    return self.recv_getTransactionsForShoppingCartId()
1454 
 
1455 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1456 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1457 
    args = getTransactionsForShoppingCartId_args()
1458 
    args.shoppingCartId = shoppingCartId
1459 
    args.write(self._oprot)
1460 
    self._oprot.writeMessageEnd()
1461 
    self._oprot.trans.flush()
1462 
 
1463 
  def recv_getTransactionsForShoppingCartId(self, ):
1464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1465 
    if mtype == TMessageType.EXCEPTION:
1466 
      x = TApplicationException()
1467 
      x.read(self._iprot)
1468 
      self._iprot.readMessageEnd()
1469 
      raise x
1470 
    result = getTransactionsForShoppingCartId_result()
1471 
    result.read(self._iprot)
1472 
    self._iprot.readMessageEnd()
3431 rajveer 1473 
    if result.success is not None:
132 ashish 1474 
      return result.success
3431 rajveer 1475 
    if result.ex is not None:
132 ashish 1476 
      raise result.ex
1477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1478 
 
94 ashish 1479 
  def getTransactionStatus(self, transactionId):
1480 
    """
1481 
    Parameters:
1482 
     - transactionId
1483 
    """
1484 
    self.send_getTransactionStatus(transactionId)
1485 
    return self.recv_getTransactionStatus()
1486 
 
1487 
  def send_getTransactionStatus(self, transactionId):
1488 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1489 
    args = getTransactionStatus_args()
1490 
    args.transactionId = transactionId
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
1495 
  def recv_getTransactionStatus(self, ):
1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
1502 
    result = getTransactionStatus_result()
1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
3431 rajveer 1505 
    if result.success is not None:
94 ashish 1506 
      return result.success
3431 rajveer 1507 
    if result.ex is not None:
94 ashish 1508 
      raise result.ex
1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1510 
 
5527 anupam.sin 1511 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1512 
    """
1513 
    Parameters:
1514 
     - transactionId
1515 
     - status
1516 
     - description
5527 anupam.sin 1517 
     - pickUp
1518 
     - orderType
94 ashish 1519 
    """
5527 anupam.sin 1520 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1521 
    return self.recv_changeTransactionStatus()
1522 
 
5527 anupam.sin 1523 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1524 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1525 
    args = changeTransactionStatus_args()
1526 
    args.transactionId = transactionId
1527 
    args.status = status
1528 
    args.description = description
5527 anupam.sin 1529 
    args.pickUp = pickUp
1530 
    args.orderType = orderType
94 ashish 1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_changeTransactionStatus(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = changeTransactionStatus_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
3431 rajveer 1545 
    if result.success is not None:
94 ashish 1546 
      return result.success
3431 rajveer 1547 
    if result.ex is not None:
94 ashish 1548 
      raise result.ex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1550 
 
1398 varun.gupt 1551 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1552 
    """
1553 
    Parameters:
1554 
     - transactionId
1555 
    """
1398 varun.gupt 1556 
    self.send_enqueueTransactionInfoEmail(transactionId)
1557 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1558 
 
1398 varun.gupt 1559 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1560 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1561 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1562 
    args.transactionId = transactionId
1563 
    args.write(self._oprot)
1564 
    self._oprot.writeMessageEnd()
1565 
    self._oprot.trans.flush()
1566 
 
1398 varun.gupt 1567 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1569 
    if mtype == TMessageType.EXCEPTION:
1570 
      x = TApplicationException()
1571 
      x.read(self._iprot)
1572 
      self._iprot.readMessageEnd()
1573 
      raise x
1398 varun.gupt 1574 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1575 
    result.read(self._iprot)
1576 
    self._iprot.readMessageEnd()
3431 rajveer 1577 
    if result.success is not None:
1382 varun.gupt 1578 
      return result.success
3431 rajveer 1579 
    if result.ex is not None:
1382 varun.gupt 1580 
      raise result.ex
1398 varun.gupt 1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1582 
 
4801 anupam.sin 1583 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1584 
    """
1585 
    Parameters:
4801 anupam.sin 1586 
     - statuses
483 rajveer 1587 
     - from_date
1588 
     - to_date
1589 
     - warehouse_id
94 ashish 1590 
    """
4801 anupam.sin 1591 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1592 
    return self.recv_getAllOrders()
94 ashish 1593 
 
4801 anupam.sin 1594 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1595 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1596 
    args = getAllOrders_args()
4801 anupam.sin 1597 
    args.statuses = statuses
483 rajveer 1598 
    args.from_date = from_date
1599 
    args.to_date = to_date
1600 
    args.warehouse_id = warehouse_id
94 ashish 1601 
    args.write(self._oprot)
1602 
    self._oprot.writeMessageEnd()
1603 
    self._oprot.trans.flush()
1604 
 
483 rajveer 1605 
  def recv_getAllOrders(self, ):
94 ashish 1606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1607 
    if mtype == TMessageType.EXCEPTION:
1608 
      x = TApplicationException()
1609 
      x.read(self._iprot)
1610 
      self._iprot.readMessageEnd()
1611 
      raise x
483 rajveer 1612 
    result = getAllOrders_result()
94 ashish 1613 
    result.read(self._iprot)
1614 
    self._iprot.readMessageEnd()
3431 rajveer 1615 
    if result.success is not None:
94 ashish 1616 
      return result.success
3431 rajveer 1617 
    if result.ex is not None:
94 ashish 1618 
      raise result.ex
483 rajveer 1619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1620 
 
4133 chandransh 1621 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1622 
    """
1623 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1624 
    Pass the status as null and the limit as 0 to ignore them.
1625 
 
1626 
    Parameters:
1627 
     - statuses
1628 
     - offset
1629 
     - limit
1630 
     - warehouse_id
1631 
    """
1632 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1633 
    return self.recv_getOrdersInBatch()
1634 
 
1635 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1636 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1637 
    args = getOrdersInBatch_args()
1638 
    args.statuses = statuses
1639 
    args.offset = offset
1640 
    args.limit = limit
1641 
    args.warehouse_id = warehouse_id
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getOrdersInBatch(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getOrdersInBatch_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
1656 
    if result.success is not None:
1657 
      return result.success
1658 
    if result.ex is not None:
1659 
      raise result.ex
1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1661 
 
1662 
  def getOrderCount(self, statuses, warehouseId):
1663 
    """
1664 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1665 
 
1666 
    Parameters:
1667 
     - statuses
1668 
     - warehouseId
1669 
    """
1670 
    self.send_getOrderCount(statuses, warehouseId)
1671 
    return self.recv_getOrderCount()
1672 
 
1673 
  def send_getOrderCount(self, statuses, warehouseId):
1674 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1675 
    args = getOrderCount_args()
1676 
    args.statuses = statuses
1677 
    args.warehouseId = warehouseId
1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
1682 
  def recv_getOrderCount(self, ):
1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
1689 
    result = getOrderCount_result()
1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
1692 
    if result.success is not None:
1693 
      return result.success
1694 
    if result.ex is not None:
1695 
      raise result.ex
1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1697 
 
999 varun.gupt 1698 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1699 
    """
1132 chandransh 1700 
    Returns orders within a range of their billing dates
3431 rajveer 1701 
 
999 varun.gupt 1702 
    Parameters:
1703 
     - status
1704 
     - start_billing_date
1705 
     - end_billing_date
1706 
     - warehouse_id
1707 
    """
1708 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1709 
    return self.recv_getOrdersByBillingDate()
1710 
 
1711 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1712 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1713 
    args = getOrdersByBillingDate_args()
1714 
    args.status = status
1715 
    args.start_billing_date = start_billing_date
1716 
    args.end_billing_date = end_billing_date
1717 
    args.warehouse_id = warehouse_id
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getOrdersByBillingDate(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getOrdersByBillingDate_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
3431 rajveer 1732 
    if result.success is not None:
999 varun.gupt 1733 
      return result.success
3431 rajveer 1734 
    if result.ex is not None:
999 varun.gupt 1735 
      raise result.ex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1737 
 
3451 chandransh 1738 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1739 
    """
1740 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1741 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1742 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1743 
 
3427 chandransh 1744 
    Parameters:
1745 
     - fromShippingDate
1746 
     - toShippingDate
1747 
     - providerId
1748 
     - warehouseId
3451 chandransh 1749 
     - cod
3427 chandransh 1750 
    """
3451 chandransh 1751 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1752 
    return self.recv_getOrdersByShippingDate()
1753 
 
3451 chandransh 1754 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1755 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1756 
    args = getOrdersByShippingDate_args()
1757 
    args.fromShippingDate = fromShippingDate
1758 
    args.toShippingDate = toShippingDate
1759 
    args.providerId = providerId
1760 
    args.warehouseId = warehouseId
3451 chandransh 1761 
    args.cod = cod
3427 chandransh 1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_getOrdersByShippingDate(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = getOrdersByShippingDate_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
3427 chandransh 1777 
      return result.success
3431 rajveer 1778 
    if result.ex is not None:
3427 chandransh 1779 
      raise result.ex
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1781 
 
1382 varun.gupt 1782 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1783 
    """
1784 
    Returns order ids for orders which can be returned
3431 rajveer 1785 
 
1382 varun.gupt 1786 
    Parameters:
1787 
     - customer_id
1788 
     - limit
1789 
    """
1790 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1791 
    return self.recv_getReturnableOrdersForCustomer()
1792 
 
1793 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1794 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1795 
    args = getReturnableOrdersForCustomer_args()
1796 
    args.customer_id = customer_id
1797 
    args.limit = limit
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getReturnableOrdersForCustomer(self, ):
1803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1804 
    if mtype == TMessageType.EXCEPTION:
1805 
      x = TApplicationException()
1806 
      x.read(self._iprot)
1807 
      self._iprot.readMessageEnd()
1808 
      raise x
1809 
    result = getReturnableOrdersForCustomer_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
3431 rajveer 1812 
    if result.success is not None:
1382 varun.gupt 1813 
      return result.success
3431 rajveer 1814 
    if result.ex is not None:
1382 varun.gupt 1815 
      raise result.ex
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1817 
 
1818 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1819 
    """
1820 
    Returns order ids for orders which can be cancelled
3431 rajveer 1821 
 
1382 varun.gupt 1822 
    Parameters:
1823 
     - customer_id
1824 
     - limit
1825 
    """
1826 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1827 
    return self.recv_getCancellableOrdersForCustomer()
1828 
 
1829 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1830 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1831 
    args = getCancellableOrdersForCustomer_args()
1832 
    args.customer_id = customer_id
1833 
    args.limit = limit
1834 
    args.write(self._oprot)
1835 
    self._oprot.writeMessageEnd()
1836 
    self._oprot.trans.flush()
1837 
 
1838 
  def recv_getCancellableOrdersForCustomer(self, ):
1839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1840 
    if mtype == TMessageType.EXCEPTION:
1841 
      x = TApplicationException()
1842 
      x.read(self._iprot)
1843 
      self._iprot.readMessageEnd()
1844 
      raise x
1845 
    result = getCancellableOrdersForCustomer_result()
1846 
    result.read(self._iprot)
1847 
    self._iprot.readMessageEnd()
3431 rajveer 1848 
    if result.success is not None:
1382 varun.gupt 1849 
      return result.success
3431 rajveer 1850 
    if result.ex is not None:
1382 varun.gupt 1851 
      raise result.ex
1852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1853 
 
483 rajveer 1854 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1855 
    """
1856 
    Parameters:
483 rajveer 1857 
     - orderId
1858 
     - status
1859 
     - description
94 ashish 1860 
    """
483 rajveer 1861 
    self.send_changeOrderStatus(orderId, status, description)
1862 
    return self.recv_changeOrderStatus()
94 ashish 1863 
 
483 rajveer 1864 
  def send_changeOrderStatus(self, orderId, status, description):
1865 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1866 
    args = changeOrderStatus_args()
1867 
    args.orderId = orderId
1868 
    args.status = status
1869 
    args.description = description
94 ashish 1870 
    args.write(self._oprot)
1871 
    self._oprot.writeMessageEnd()
1872 
    self._oprot.trans.flush()
1873 
 
483 rajveer 1874 
  def recv_changeOrderStatus(self, ):
94 ashish 1875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1876 
    if mtype == TMessageType.EXCEPTION:
1877 
      x = TApplicationException()
1878 
      x.read(self._iprot)
1879 
      self._iprot.readMessageEnd()
1880 
      raise x
483 rajveer 1881 
    result = changeOrderStatus_result()
94 ashish 1882 
    result.read(self._iprot)
1883 
    self._iprot.readMessageEnd()
3431 rajveer 1884 
    if result.success is not None:
94 ashish 1885 
      return result.success
3431 rajveer 1886 
    if result.ex is not None:
94 ashish 1887 
      raise result.ex
483 rajveer 1888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1889 
 
1528 ankur.sing 1890 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1891 
    """
1528 ankur.sing 1892 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1893 
    only user who owns the transaction can view its order details.
3431 rajveer 1894 
 
94 ashish 1895 
    Parameters:
1896 
     - transactionId
1528 ankur.sing 1897 
     - customerId
94 ashish 1898 
    """
1528 ankur.sing 1899 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1900 
    return self.recv_getOrdersForTransaction()
94 ashish 1901 
 
1528 ankur.sing 1902 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1903 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1904 
    args = getOrdersForTransaction_args()
94 ashish 1905 
    args.transactionId = transactionId
1528 ankur.sing 1906 
    args.customerId = customerId
94 ashish 1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
483 rajveer 1911 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
483 rajveer 1918 
    result = getOrdersForTransaction_result()
94 ashish 1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
94 ashish 1922 
      return result.success
3431 rajveer 1923 
    if result.ex is not None:
94 ashish 1924 
      raise result.ex
483 rajveer 1925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1926 
 
3014 chandransh 1927 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1928 
    """
3014 chandransh 1929 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1930 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1931 
 
94 ashish 1932 
    Parameters:
483 rajveer 1933 
     - customerId
1934 
     - from_date
1935 
     - to_date
3014 chandransh 1936 
     - statuses
94 ashish 1937 
    """
3014 chandransh 1938 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1939 
    return self.recv_getOrdersForCustomer()
94 ashish 1940 
 
3014 chandransh 1941 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1942 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1943 
    args = getOrdersForCustomer_args()
1944 
    args.customerId = customerId
1945 
    args.from_date = from_date
1946 
    args.to_date = to_date
3014 chandransh 1947 
    args.statuses = statuses
94 ashish 1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
483 rajveer 1952 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
483 rajveer 1959 
    result = getOrdersForCustomer_result()
94 ashish 1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
3431 rajveer 1962 
    if result.success is not None:
94 ashish 1963 
      return result.success
3431 rajveer 1964 
    if result.ex is not None:
94 ashish 1965 
      raise result.ex
483 rajveer 1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1967 
 
483 rajveer 1968 
  def createOrder(self, order):
94 ashish 1969 
    """
1970 
    Parameters:
483 rajveer 1971 
     - order
94 ashish 1972 
    """
483 rajveer 1973 
    self.send_createOrder(order)
1974 
    return self.recv_createOrder()
94 ashish 1975 
 
483 rajveer 1976 
  def send_createOrder(self, order):
1977 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1978 
    args = createOrder_args()
1979 
    args.order = order
94 ashish 1980 
    args.write(self._oprot)
1981 
    self._oprot.writeMessageEnd()
1982 
    self._oprot.trans.flush()
1983 
 
483 rajveer 1984 
  def recv_createOrder(self, ):
94 ashish 1985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1986 
    if mtype == TMessageType.EXCEPTION:
1987 
      x = TApplicationException()
1988 
      x.read(self._iprot)
1989 
      self._iprot.readMessageEnd()
1990 
      raise x
483 rajveer 1991 
    result = createOrder_result()
94 ashish 1992 
    result.read(self._iprot)
1993 
    self._iprot.readMessageEnd()
3431 rajveer 1994 
    if result.success is not None:
94 ashish 1995 
      return result.success
3431 rajveer 1996 
    if result.ex is not None:
94 ashish 1997 
      raise result.ex
483 rajveer 1998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1999 
 
483 rajveer 2000 
  def getOrder(self, id):
94 ashish 2001 
    """
2002 
    Parameters:
483 rajveer 2003 
     - id
94 ashish 2004 
    """
483 rajveer 2005 
    self.send_getOrder(id)
2006 
    return self.recv_getOrder()
94 ashish 2007 
 
483 rajveer 2008 
  def send_getOrder(self, id):
2009 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2010 
    args = getOrder_args()
2011 
    args.id = id
94 ashish 2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
483 rajveer 2016 
  def recv_getOrder(self, ):
94 ashish 2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
483 rajveer 2023 
    result = getOrder_result()
94 ashish 2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
3431 rajveer 2026 
    if result.success is not None:
94 ashish 2027 
      return result.success
3431 rajveer 2028 
    if result.ex is not None:
94 ashish 2029 
      raise result.ex
483 rajveer 2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2031 
 
483 rajveer 2032 
  def getLineItemsForOrder(self, orderId):
94 ashish 2033 
    """
2034 
    Parameters:
483 rajveer 2035 
     - orderId
94 ashish 2036 
    """
483 rajveer 2037 
    self.send_getLineItemsForOrder(orderId)
2038 
    return self.recv_getLineItemsForOrder()
94 ashish 2039 
 
483 rajveer 2040 
  def send_getLineItemsForOrder(self, orderId):
2041 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2042 
    args = getLineItemsForOrder_args()
2043 
    args.orderId = orderId
94 ashish 2044 
    args.write(self._oprot)
2045 
    self._oprot.writeMessageEnd()
2046 
    self._oprot.trans.flush()
2047 
 
483 rajveer 2048 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2050 
    if mtype == TMessageType.EXCEPTION:
2051 
      x = TApplicationException()
2052 
      x.read(self._iprot)
2053 
      self._iprot.readMessageEnd()
2054 
      raise x
483 rajveer 2055 
    result = getLineItemsForOrder_result()
94 ashish 2056 
    result.read(self._iprot)
2057 
    self._iprot.readMessageEnd()
3431 rajveer 2058 
    if result.success is not None:
94 ashish 2059 
      return result.success
3431 rajveer 2060 
    if result.ex is not None:
94 ashish 2061 
      raise result.ex
483 rajveer 2062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2063 
 
4999 phani.kuma 2064 
  def getOrderList(self, order_ids):
2065 
    """
2066 
    Parameters:
2067 
     - order_ids
2068 
    """
2069 
    self.send_getOrderList(order_ids)
2070 
    return self.recv_getOrderList()
2071 
 
2072 
  def send_getOrderList(self, order_ids):
2073 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2074 
    args = getOrderList_args()
2075 
    args.order_ids = order_ids
2076 
    args.write(self._oprot)
2077 
    self._oprot.writeMessageEnd()
2078 
    self._oprot.trans.flush()
2079 
 
2080 
  def recv_getOrderList(self, ):
2081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2082 
    if mtype == TMessageType.EXCEPTION:
2083 
      x = TApplicationException()
2084 
      x.read(self._iprot)
2085 
      self._iprot.readMessageEnd()
2086 
      raise x
2087 
    result = getOrderList_result()
2088 
    result.read(self._iprot)
2089 
    self._iprot.readMessageEnd()
2090 
    if result.success is not None:
2091 
      return result.success
2092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2093 
 
5386 phani.kuma 2094 
  def getOrderListForVendor(self, order_ids, vendorId):
2095 
    """
2096 
    Parameters:
2097 
     - order_ids
2098 
     - vendorId
2099 
    """
2100 
    self.send_getOrderListForVendor(order_ids, vendorId)
2101 
    return self.recv_getOrderListForVendor()
2102 
 
2103 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2104 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2105 
    args = getOrderListForVendor_args()
2106 
    args.order_ids = order_ids
2107 
    args.vendorId = vendorId
2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
2112 
  def recv_getOrderListForVendor(self, ):
2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
2119 
    result = getOrderListForVendor_result()
2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
2122 
    if result.success is not None:
2123 
      return result.success
2124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2125 
 
1528 ankur.sing 2126 
  def getOrderForCustomer(self, orderId, customerId):
2127 
    """
2128 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2129 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2130 
 
1528 ankur.sing 2131 
    Parameters:
2132 
     - orderId
2133 
     - customerId
2134 
    """
2135 
    self.send_getOrderForCustomer(orderId, customerId)
2136 
    return self.recv_getOrderForCustomer()
2137 
 
2138 
  def send_getOrderForCustomer(self, orderId, customerId):
2139 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2140 
    args = getOrderForCustomer_args()
2141 
    args.orderId = orderId
2142 
    args.customerId = customerId
2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
2147 
  def recv_getOrderForCustomer(self, ):
2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
2154 
    result = getOrderForCustomer_result()
2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
3431 rajveer 2157 
    if result.success is not None:
1528 ankur.sing 2158 
      return result.success
3431 rajveer 2159 
    if result.ex is not None:
1528 ankur.sing 2160 
      raise result.ex
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2162 
 
4444 rajveer 2163 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2164 
    """
2165 
    Parameters:
4394 rajveer 2166 
     - type
4444 rajveer 2167 
     - warehouseId
4394 rajveer 2168 
     - status
2169 
     - timestamp
3064 chandransh 2170 
    """
4444 rajveer 2171 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2172 
    return self.recv_getAlerts()
2173 
 
4444 rajveer 2174 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2175 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2176 
    args = getAlerts_args()
4394 rajveer 2177 
    args.type = type
4444 rajveer 2178 
    args.warehouseId = warehouseId
4394 rajveer 2179 
    args.status = status
2180 
    args.timestamp = timestamp
3064 chandransh 2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_getAlerts(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = getAlerts_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
3431 rajveer 2195 
    if result.success is not None:
3064 chandransh 2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2198 
 
4444 rajveer 2199 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2200 
    """
2201 
    Parameters:
2202 
     - type
4444 rajveer 2203 
     - warehouseId
4394 rajveer 2204 
     - description
3064 chandransh 2205 
    """
4444 rajveer 2206 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2207 
    self.recv_addAlert()
3064 chandransh 2208 
 
4444 rajveer 2209 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2210 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2211 
    args = addAlert_args()
3064 chandransh 2212 
    args.type = type
4444 rajveer 2213 
    args.warehouseId = warehouseId
4394 rajveer 2214 
    args.description = description
3064 chandransh 2215 
    args.write(self._oprot)
2216 
    self._oprot.writeMessageEnd()
2217 
    self._oprot.trans.flush()
2218 
 
4394 rajveer 2219 
  def recv_addAlert(self, ):
3064 chandransh 2220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2221 
    if mtype == TMessageType.EXCEPTION:
2222 
      x = TApplicationException()
2223 
      x.read(self._iprot)
2224 
      self._iprot.readMessageEnd()
2225 
      raise x
4394 rajveer 2226 
    result = addAlert_result()
3064 chandransh 2227 
    result.read(self._iprot)
2228 
    self._iprot.readMessageEnd()
2229 
    return
2230 
 
4444 rajveer 2231 
  def markAlertsAsSeen(self, warehouseId):
2232 
    """
2233 
    Parameters:
2234 
     - warehouseId
2235 
    """
2236 
    self.send_markAlertsAsSeen(warehouseId)
2237 
    self.recv_markAlertsAsSeen()
2238 
 
2239 
  def send_markAlertsAsSeen(self, warehouseId):
2240 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2241 
    args = markAlertsAsSeen_args()
2242 
    args.warehouseId = warehouseId
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
2247 
  def recv_markAlertsAsSeen(self, ):
2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
2254 
    result = markAlertsAsSeen_result()
2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
2257 
    return
2258 
 
3064 chandransh 2259 
  def getValidOrderCount(self, ):
2260 
    """
2261 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2262 
    """
2263 
    self.send_getValidOrderCount()
2264 
    return self.recv_getValidOrderCount()
2265 
 
2266 
  def send_getValidOrderCount(self, ):
2267 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2268 
    args = getValidOrderCount_args()
2269 
    args.write(self._oprot)
2270 
    self._oprot.writeMessageEnd()
2271 
    self._oprot.trans.flush()
2272 
 
2273 
  def recv_getValidOrderCount(self, ):
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
2280 
    result = getValidOrderCount_result()
2281 
    result.read(self._iprot)
2282 
    self._iprot.readMessageEnd()
3431 rajveer 2283 
    if result.success is not None:
3064 chandransh 2284 
      return result.success
2285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2286 
 
2287 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2288 
    """
2289 
    Returns the number of distinct customers who have done successful transactions
2290 
    """
2291 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2292 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2293 
 
2294 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2295 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2296 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_getNoOfCustomersWithSuccessfulTransaction(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 = getNoOfCustomersWithSuccessfulTransaction_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
3431 rajveer 2311 
    if result.success is not None:
3064 chandransh 2312 
      return result.success
2313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2314 
 
2315 
  def getValidOrdersAmountRange(self, ):
2316 
    """
2317 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2318 
    List contains two values, first minimum amount and second maximum amount.
2319 
    """
2320 
    self.send_getValidOrdersAmountRange()
2321 
    return self.recv_getValidOrdersAmountRange()
2322 
 
2323 
  def send_getValidOrdersAmountRange(self, ):
2324 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2325 
    args = getValidOrdersAmountRange_args()
2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_getValidOrdersAmountRange(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = getValidOrdersAmountRange_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
3064 chandransh 2341 
      return result.success
2342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2343 
 
5874 rajveer 2344 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2345 
    """
2346 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2347 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2348 
 
3064 chandransh 2349 
    Parameters:
2350 
     - limit
5874 rajveer 2351 
     - onlyStore
3064 chandransh 2352 
    """
5874 rajveer 2353 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2354 
    return self.recv_getValidOrders()
2355 
 
5874 rajveer 2356 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2357 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2358 
    args = getValidOrders_args()
2359 
    args.limit = limit
5874 rajveer 2360 
    args.onlyStore = onlyStore
3064 chandransh 2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
2365 
  def recv_getValidOrders(self, ):
2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
2372 
    result = getValidOrders_result()
2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
3431 rajveer 2375 
    if result.success is not None:
3064 chandransh 2376 
      return result.success
2377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2378 
 
1220 chandransh 2379 
  def batchOrders(self, warehouseId):
2380 
    """
2381 
    Create a batch of all the pending orders for the given warehouse.
2382 
    The returned list is orderd by created_timestamp.
2383 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2384 
 
1220 chandransh 2385 
    Parameters:
2386 
     - warehouseId
2387 
    """
2388 
    self.send_batchOrders(warehouseId)
2389 
    return self.recv_batchOrders()
2390 
 
2391 
  def send_batchOrders(self, warehouseId):
2392 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2393 
    args = batchOrders_args()
2394 
    args.warehouseId = warehouseId
2395 
    args.write(self._oprot)
2396 
    self._oprot.writeMessageEnd()
2397 
    self._oprot.trans.flush()
2398 
 
2399 
  def recv_batchOrders(self, ):
2400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2401 
    if mtype == TMessageType.EXCEPTION:
2402 
      x = TApplicationException()
2403 
      x.read(self._iprot)
2404 
      self._iprot.readMessageEnd()
2405 
      raise x
2406 
    result = batchOrders_result()
2407 
    result.read(self._iprot)
2408 
    self._iprot.readMessageEnd()
3431 rajveer 2409 
    if result.success is not None:
1220 chandransh 2410 
      return result.success
3431 rajveer 2411 
    if result.ex is not None:
1220 chandransh 2412 
      raise result.ex
2413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2414 
 
1208 chandransh 2415 
  def markOrderAsOutOfStock(self, orderId):
2416 
    """
2417 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2418 
 
1208 chandransh 2419 
    Parameters:
2420 
     - orderId
2421 
    """
2422 
    self.send_markOrderAsOutOfStock(orderId)
2423 
    return self.recv_markOrderAsOutOfStock()
2424 
 
2425 
  def send_markOrderAsOutOfStock(self, orderId):
2426 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2427 
    args = markOrderAsOutOfStock_args()
2428 
    args.orderId = orderId
2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
2433 
  def recv_markOrderAsOutOfStock(self, ):
2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
2440 
    result = markOrderAsOutOfStock_result()
2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
3431 rajveer 2443 
    if result.success is not None:
1208 chandransh 2444 
      return result.success
3431 rajveer 2445 
    if result.ex is not None:
1208 chandransh 2446 
      raise result.ex
2447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2448 
 
3064 chandransh 2449 
  def verifyOrder(self, orderId):
759 chandransh 2450 
    """
3064 chandransh 2451 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2452 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2453 
    used for all other orders as well.
2454 
    Throws an exception if no such order exists.
3431 rajveer 2455 
 
759 chandransh 2456 
    Parameters:
3064 chandransh 2457 
     - orderId
759 chandransh 2458 
    """
3064 chandransh 2459 
    self.send_verifyOrder(orderId)
2460 
    return self.recv_verifyOrder()
759 chandransh 2461 
 
3064 chandransh 2462 
  def send_verifyOrder(self, orderId):
2463 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2464 
    args = verifyOrder_args()
2465 
    args.orderId = orderId
759 chandransh 2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
3064 chandransh 2470 
  def recv_verifyOrder(self, ):
759 chandransh 2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
3064 chandransh 2477 
    result = verifyOrder_result()
759 chandransh 2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
3431 rajveer 2480 
    if result.success is not None:
759 chandransh 2481 
      return result.success
3431 rajveer 2482 
    if result.ex is not None:
759 chandransh 2483 
      raise result.ex
3064 chandransh 2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2485 
 
3064 chandransh 2486 
  def acceptOrder(self, orderId):
1113 chandransh 2487 
    """
3064 chandransh 2488 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2489 
    given order is not a COD order, it also captures the payment if the same has
2490 
    not been captured.
2491 
    Throws an exception if no such order exists.
3431 rajveer 2492 
 
1113 chandransh 2493 
    Parameters:
3064 chandransh 2494 
     - orderId
1113 chandransh 2495 
    """
3064 chandransh 2496 
    self.send_acceptOrder(orderId)
2497 
    return self.recv_acceptOrder()
1113 chandransh 2498 
 
3064 chandransh 2499 
  def send_acceptOrder(self, orderId):
2500 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2501 
    args = acceptOrder_args()
2502 
    args.orderId = orderId
1113 chandransh 2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
3064 chandransh 2507 
  def recv_acceptOrder(self, ):
1113 chandransh 2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
3064 chandransh 2514 
    result = acceptOrder_result()
1113 chandransh 2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
3431 rajveer 2517 
    if result.success is not None:
1113 chandransh 2518 
      return result.success
3431 rajveer 2519 
    if result.ex is not None:
1113 chandransh 2520 
      raise result.ex
3064 chandransh 2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2522 
 
5110 mandeep.dh 2523 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2524 
    """
3064 chandransh 2525 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2526 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2527 
    the IMEI no. if a -1 is supplied.
2528 
    Also, it generates an invoice number for the order, marks the order as
2529 
    BILLED and sets the billing timestamp.
2530 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2531 
 
1135 chandransh 2532 
    Parameters:
3064 chandransh 2533 
     - orderId
2534 
     - invoice_number
4658 mandeep.dh 2535 
     - serialNumber
4283 anupam.sin 2536 
     - itemNumber
3064 chandransh 2537 
     - billed_by
4264 rajveer 2538 
     - jacketNumber
4283 anupam.sin 2539 
     - billingType
5110 mandeep.dh 2540 
     - fulfilmentWarehouseId
4763 rajveer 2541 
     - authorize
1135 chandransh 2542 
    """
5110 mandeep.dh 2543 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2544 
    return self.recv_addBillingDetails()
1135 chandransh 2545 
 
5110 mandeep.dh 2546 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2547 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2548 
    args = addBillingDetails_args()
2549 
    args.orderId = orderId
2550 
    args.invoice_number = invoice_number
4658 mandeep.dh 2551 
    args.serialNumber = serialNumber
4283 anupam.sin 2552 
    args.itemNumber = itemNumber
3064 chandransh 2553 
    args.billed_by = billed_by
4264 rajveer 2554 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2555 
    args.billingType = billingType
5110 mandeep.dh 2556 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2557 
    args.authorize = authorize
1135 chandransh 2558 
    args.write(self._oprot)
2559 
    self._oprot.writeMessageEnd()
2560 
    self._oprot.trans.flush()
2561 
 
3064 chandransh 2562 
  def recv_addBillingDetails(self, ):
1135 chandransh 2563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2564 
    if mtype == TMessageType.EXCEPTION:
2565 
      x = TApplicationException()
2566 
      x.read(self._iprot)
2567 
      self._iprot.readMessageEnd()
2568 
      raise x
3064 chandransh 2569 
    result = addBillingDetails_result()
1135 chandransh 2570 
    result.read(self._iprot)
2571 
    self._iprot.readMessageEnd()
3431 rajveer 2572 
    if result.success is not None:
3064 chandransh 2573 
      return result.success
3431 rajveer 2574 
    if result.ex is not None:
1135 chandransh 2575 
      raise result.ex
3064 chandransh 2576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2577 
 
4763 rajveer 2578 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2579 
    """
2580 
    Add the invoice number to the order.
2581 
 
2582 
    Parameters:
2583 
     - orderId
2584 
     - invoiceNumber
4763 rajveer 2585 
     - color
4579 rajveer 2586 
    """
4763 rajveer 2587 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2588 
    self.recv_addInvoiceNumber()
2589 
 
4763 rajveer 2590 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2591 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2592 
    args = addInvoiceNumber_args()
2593 
    args.orderId = orderId
2594 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2595 
    args.color = color
4579 rajveer 2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_addInvoiceNumber(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = addInvoiceNumber_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
2610 
    if result.ex is not None:
2611 
      raise result.ex
2612 
    return
2613 
 
4910 phani.kuma 2614 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2615 
    """
3064 chandransh 2616 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2617 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2618 
 
1408 ankur.sing 2619 
    Parameters:
3064 chandransh 2620 
     - warehouseId
1408 ankur.sing 2621 
     - providerId
3064 chandransh 2622 
     - cod
4910 phani.kuma 2623 
     - orderIds
1408 ankur.sing 2624 
    """
4910 phani.kuma 2625 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2626 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2627 
 
4910 phani.kuma 2628 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2629 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2630 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2631 
    args.warehouseId = warehouseId
1408 ankur.sing 2632 
    args.providerId = providerId
3064 chandransh 2633 
    args.cod = cod
4910 phani.kuma 2634 
    args.orderIds = orderIds
1408 ankur.sing 2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
4910 phani.kuma 2639 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
4910 phani.kuma 2646 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.success is not None:
1408 ankur.sing 2650 
      return result.success
3431 rajveer 2651 
    if result.ex is not None:
3064 chandransh 2652 
      raise result.ex
4910 phani.kuma 2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2654 
 
5713 rajveer 2655 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2656 
    """
2657 
    Parameters:
2658 
     - providerId
2659 
     - orderIds
5713 rajveer 2660 
     - awbs
5676 rajveer 2661 
    """
5713 rajveer 2662 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2663 
    return self.recv_markOrdersAsReturnedFromStore()
2664 
 
5713 rajveer 2665 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2666 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2667 
    args = markOrdersAsReturnedFromStore_args()
2668 
    args.providerId = providerId
2669 
    args.orderIds = orderIds
5713 rajveer 2670 
    args.awbs = awbs
5676 rajveer 2671 
    args.write(self._oprot)
2672 
    self._oprot.writeMessageEnd()
2673 
    self._oprot.trans.flush()
2674 
 
2675 
  def recv_markOrdersAsReturnedFromStore(self, ):
2676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2677 
    if mtype == TMessageType.EXCEPTION:
2678 
      x = TApplicationException()
2679 
      x.read(self._iprot)
2680 
      self._iprot.readMessageEnd()
2681 
      raise x
2682 
    result = markOrdersAsReturnedFromStore_result()
2683 
    result.read(self._iprot)
2684 
    self._iprot.readMessageEnd()
2685 
    if result.success is not None:
2686 
      return result.success
2687 
    if result.ex is not None:
2688 
      raise result.ex
2689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2690 
 
4910 phani.kuma 2691 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2692 
    """
4910 phani.kuma 2693 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2694 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2695 
 
2696 
    Parameters:
2697 
     - providerId
4910 phani.kuma 2698 
     - pickupDetails
4410 rajveer 2699 
    """
4910 phani.kuma 2700 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2701 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2702 
 
4910 phani.kuma 2703 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2704 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2705 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2706 
    args.providerId = providerId
4910 phani.kuma 2707 
    args.pickupDetails = pickupDetails
4410 rajveer 2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
4910 phani.kuma 2712 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
4910 phani.kuma 2719 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    if result.ex is not None:
2723 
      raise result.ex
4910 phani.kuma 2724 
    return
4410 rajveer 2725 
 
4910 phani.kuma 2726 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2727 
    """
3064 chandransh 2728 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2729 
 
94 ashish 2730 
    Parameters:
3064 chandransh 2731 
     - providerId
304 ashish 2732 
    """
4910 phani.kuma 2733 
    self.send_getOrdersNotPickedUp(providerId)
2734 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2735 
 
4910 phani.kuma 2736 
  def send_getOrdersNotPickedUp(self, providerId):
2737 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2738 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2739 
    args.providerId = providerId
304 ashish 2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
4910 phani.kuma 2744 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
4910 phani.kuma 2751 
    result = getOrdersNotPickedUp_result()
304 ashish 2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
3431 rajveer 2754 
    if result.success is not None:
304 ashish 2755 
      return result.success
4910 phani.kuma 2756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2757 
 
3064 chandransh 2758 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2759 
    """
3064 chandransh 2760 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2761 
    the name of the receiver.
2762 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2763 
 
304 ashish 2764 
    Parameters:
3064 chandransh 2765 
     - providerId
2766 
     - deliveredOrders
304 ashish 2767 
    """
3064 chandransh 2768 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2769 
    self.recv_markOrdersAsDelivered()
304 ashish 2770 
 
3064 chandransh 2771 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2772 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2773 
    args = markOrdersAsDelivered_args()
2774 
    args.providerId = providerId
2775 
    args.deliveredOrders = deliveredOrders
304 ashish 2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
3064 chandransh 2780 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
3064 chandransh 2787 
    result = markOrdersAsDelivered_result()
304 ashish 2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
3431 rajveer 2790 
    if result.ex is not None:
3064 chandransh 2791 
      raise result.ex
304 ashish 2792 
    return
2793 
 
4910 phani.kuma 2794 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2795 
    """
4910 phani.kuma 2796 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2797 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2798 
 
3064 chandransh 2799 
    Parameters:
2800 
     - providerId
2801 
     - returnedOrders
1596 ankur.sing 2802 
    """
4910 phani.kuma 2803 
    self.send_markAsRTOrders(providerId, returnedOrders)
2804 
    self.recv_markAsRTOrders()
304 ashish 2805 
 
4910 phani.kuma 2806 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2807 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2808 
    args = markAsRTOrders_args()
3064 chandransh 2809 
    args.providerId = providerId
2810 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
4910 phani.kuma 2815 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
4910 phani.kuma 2822 
    result = markAsRTOrders_result()
1596 ankur.sing 2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
3431 rajveer 2825 
    if result.ex is not None:
3064 chandransh 2826 
      raise result.ex
2827 
    return
1596 ankur.sing 2828 
 
4910 phani.kuma 2829 
  def getRTOrders(self, providerId):
2830 
    """
2831 
    Returns a list of orders that were returned by courier.
2832 
 
2833 
    Parameters:
2834 
     - providerId
2835 
    """
2836 
    self.send_getRTOrders(providerId)
2837 
    return self.recv_getRTOrders()
2838 
 
2839 
  def send_getRTOrders(self, providerId):
2840 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2841 
    args = getRTOrders_args()
2842 
    args.providerId = providerId
2843 
    args.write(self._oprot)
2844 
    self._oprot.writeMessageEnd()
2845 
    self._oprot.trans.flush()
2846 
 
2847 
  def recv_getRTOrders(self, ):
2848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2849 
    if mtype == TMessageType.EXCEPTION:
2850 
      x = TApplicationException()
2851 
      x.read(self._iprot)
2852 
      self._iprot.readMessageEnd()
2853 
      raise x
2854 
    result = getRTOrders_result()
2855 
    result.read(self._iprot)
2856 
    self._iprot.readMessageEnd()
2857 
    if result.success is not None:
2858 
      return result.success
2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2860 
 
3064 chandransh 2861 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2862 
    """
3064 chandransh 2863 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2864 
 
3064 chandransh 2865 
    Parameters:
2866 
     - providerId
2867 
     - undeliveredOrders
1627 ankur.sing 2868 
    """
3064 chandransh 2869 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2870 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2871 
 
3064 chandransh 2872 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2873 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2874 
    args = updateNonDeliveryReason_args()
2875 
    args.providerId = providerId
2876 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
3064 chandransh 2881 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
3064 chandransh 2888 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
4910 phani.kuma 2891 
    if result.ex is not None:
2892 
      raise result.ex
2893 
    return
2894 
 
2895 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2896 
    """
2897 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2898 
 
2899 
    Parameters:
2900 
     - providerId
2901 
    """
2902 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2903 
    return self.recv_getNonDeliveredOrdersbyCourier()
2904 
 
2905 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2906 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2907 
    args = getNonDeliveredOrdersbyCourier_args()
2908 
    args.providerId = providerId
2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = getNonDeliveredOrdersbyCourier_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
4581 phani.kuma 2923 
    if result.success is not None:
2924 
      return result.success
4910 phani.kuma 2925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2926 
 
2927 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2928 
    """
2929 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2930 
 
2931 
    Parameters:
2932 
     - providerId
2933 
     - local_connected_orders
2934 
    """
2935 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2936 
    self.recv_markOrdersAsLocalConnected()
2937 
 
2938 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2939 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2940 
    args = markOrdersAsLocalConnected_args()
2941 
    args.providerId = providerId
2942 
    args.local_connected_orders = local_connected_orders
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_markOrdersAsLocalConnected(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = markOrdersAsLocalConnected_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
3431 rajveer 2957 
    if result.ex is not None:
3064 chandransh 2958 
      raise result.ex
4910 phani.kuma 2959 
    return
1627 ankur.sing 2960 
 
4910 phani.kuma 2961 
  def getOrdersNotLocalConnected(self, providerId):
2962 
    """
2963 
    Returns a list of orders that were picked up or shipped but pending local connection.
2964 
 
2965 
    Parameters:
2966 
     - providerId
2967 
    """
2968 
    self.send_getOrdersNotLocalConnected(providerId)
2969 
    return self.recv_getOrdersNotLocalConnected()
2970 
 
2971 
  def send_getOrdersNotLocalConnected(self, providerId):
2972 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2973 
    args = getOrdersNotLocalConnected_args()
2974 
    args.providerId = providerId
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_getOrdersNotLocalConnected(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = getOrdersNotLocalConnected_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
2989 
    if result.success is not None:
2990 
      return result.success
2991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2992 
 
2993 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2994 
    """
2995 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2996 
 
2997 
    Parameters:
2998 
     - providerId
2999 
     - destination_city_reached_orders
3000 
    """
3001 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3002 
    self.recv_markOrdersAsDestinationCityReached()
3003 
 
3004 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3005 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3006 
    args = markOrdersAsDestinationCityReached_args()
3007 
    args.providerId = providerId
3008 
    args.destination_city_reached_orders = destination_city_reached_orders
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_markOrdersAsDestinationCityReached(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = markOrdersAsDestinationCityReached_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3023 
    if result.ex is not None:
3024 
      raise result.ex
3025 
    return
3026 
 
3027 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3028 
    """
3029 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3030 
 
3031 
    Parameters:
3032 
     - providerId
3033 
     - first_atdl_orders
3034 
    """
3035 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3036 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3037 
 
3038 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3039 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3040 
    args = markOrdersAsFirstDeliveryAttempted_args()
3041 
    args.providerId = providerId
3042 
    args.first_atdl_orders = first_atdl_orders
3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
3047 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
3054 
    result = markOrdersAsFirstDeliveryAttempted_result()
3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3057 
    if result.ex is not None:
3058 
      raise result.ex
3059 
    return
3060 
 
3064 chandransh 3061 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3062 
    """
3064 chandransh 3063 
    Returns the list of orders whose delivery time has passed but have not been
3064 
    delivered yet for the given provider and warehouse. To get a complete list of
3065 
    undelivered orders, pass them as -1.
3066 
    Returns an empty list if no such orders exist.
3431 rajveer 3067 
 
1886 ankur.sing 3068 
    Parameters:
3064 chandransh 3069 
     - providerId
3070 
     - warehouseId
1886 ankur.sing 3071 
    """
3064 chandransh 3072 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3073 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3074 
 
3064 chandransh 3075 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3076 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3077 
    args = getUndeliveredOrders_args()
3078 
    args.providerId = providerId
3079 
    args.warehouseId = warehouseId
1886 ankur.sing 3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
3064 chandransh 3084 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
3064 chandransh 3091 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3431 rajveer 3094 
    if result.success is not None:
1886 ankur.sing 3095 
      return result.success
3064 chandransh 3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3097 
 
4783 phani.kuma 3098 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3099 
    """
3100 
    Returns the list of orders whose expected delivery date has passed but have not been
3101 
    delivered yet.
3102 
    Returns an empty list if no such orders exist.
3103 
    """
3104 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3105 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3106 
 
3107 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3108 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3109 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3110 
    args.write(self._oprot)
3111 
    self._oprot.writeMessageEnd()
3112 
    self._oprot.trans.flush()
3113 
 
3114 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3116 
    if mtype == TMessageType.EXCEPTION:
3117 
      x = TApplicationException()
3118 
      x.read(self._iprot)
3119 
      self._iprot.readMessageEnd()
3120 
      raise x
3121 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3122 
    result.read(self._iprot)
3123 
    self._iprot.readMessageEnd()
3124 
    if result.success is not None:
3125 
      return result.success
3126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3127 
 
2536 chandransh 3128 
  def toggleDOAFlag(self, orderId):
3129 
    """
3130 
    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.
3131 
    Returns the final flag status.
3132 
    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 3133 
 
2536 chandransh 3134 
    Parameters:
3135 
     - orderId
3136 
    """
3137 
    self.send_toggleDOAFlag(orderId)
3138 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3139 
 
2536 chandransh 3140 
  def send_toggleDOAFlag(self, orderId):
3141 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3142 
    args = toggleDOAFlag_args()
3143 
    args.orderId = orderId
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_toggleDOAFlag(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = toggleDOAFlag_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3431 rajveer 3158 
    if result.success is not None:
2536 chandransh 3159 
      return result.success
3431 rajveer 3160 
    if result.ex is not None:
2536 chandransh 3161 
      raise result.ex
3162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3163 
 
4712 rajveer 3164 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3165 
    """
3166 
    Parameters:
3167 
     - orderId
3168 
     - deliveryTimestamp
3169 
     - receiver
3170 
    """
3171 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3172 
    self.recv_markOrderAsDelivered()
3173 
 
3174 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3175 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3176 
    args = markOrderAsDelivered_args()
3177 
    args.orderId = orderId
3178 
    args.deliveryTimestamp = deliveryTimestamp
3179 
    args.receiver = receiver
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_markOrderAsDelivered(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = markOrderAsDelivered_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.ex is not None:
3195 
      raise result.ex
3196 
    return
3197 
 
5553 rajveer 3198 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3199 
    """
3200 
    Parameters:
3201 
     - orderId
3202 
     - deliveryTimestamp
3203 
    """
3204 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3205 
    self.recv_markOrderAsReceivedAtStore()
3206 
 
3207 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3208 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3209 
    args = markOrderAsReceivedAtStore_args()
3210 
    args.orderId = orderId
3211 
    args.deliveryTimestamp = deliveryTimestamp
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_markOrderAsReceivedAtStore(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = markOrderAsReceivedAtStore_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
3226 
    if result.ex is not None:
3227 
      raise result.ex
3228 
    return
3229 
 
4454 rajveer 3230 
  def markOrderDoaRequestReceived(self, orderId):
3231 
    """
3232 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3233 
 
3234 
    Parameters:
3235 
     - orderId
3236 
    """
3237 
    self.send_markOrderDoaRequestReceived(orderId)
3238 
    return self.recv_markOrderDoaRequestReceived()
3239 
 
3240 
  def send_markOrderDoaRequestReceived(self, orderId):
3241 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3242 
    args = markOrderDoaRequestReceived_args()
3243 
    args.orderId = orderId
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_markOrderDoaRequestReceived(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = markOrderDoaRequestReceived_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
3260 
    if result.ex is not None:
3261 
      raise result.ex
3262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3263 
 
3264 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3265 
    """
3266 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3267 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3268 
 
3269 
    Parameters:
3270 
     - orderId
3271 
     - isAuthorized
3272 
    """
3273 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3274 
    return self.recv_markOrderDoaRequestAuthorized()
3275 
 
3276 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3277 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3278 
    args = markOrderDoaRequestAuthorized_args()
3279 
    args.orderId = orderId
3280 
    args.isAuthorized = isAuthorized
3281 
    args.write(self._oprot)
3282 
    self._oprot.writeMessageEnd()
3283 
    self._oprot.trans.flush()
3284 
 
3285 
  def recv_markOrderDoaRequestAuthorized(self, ):
3286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3287 
    if mtype == TMessageType.EXCEPTION:
3288 
      x = TApplicationException()
3289 
      x.read(self._iprot)
3290 
      self._iprot.readMessageEnd()
3291 
      raise x
3292 
    result = markOrderDoaRequestAuthorized_result()
3293 
    result.read(self._iprot)
3294 
    self._iprot.readMessageEnd()
3295 
    if result.success is not None:
3296 
      return result.success
3297 
    if result.ex is not None:
3298 
      raise result.ex
3299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3300 
 
4488 rajveer 3301 
  def markOrderReturnRequestReceived(self, orderId):
3302 
    """
3303 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3304 
 
3305 
    Parameters:
3306 
     - orderId
3307 
    """
3308 
    self.send_markOrderReturnRequestReceived(orderId)
3309 
    return self.recv_markOrderReturnRequestReceived()
3310 
 
3311 
  def send_markOrderReturnRequestReceived(self, orderId):
3312 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3313 
    args = markOrderReturnRequestReceived_args()
3314 
    args.orderId = orderId
3315 
    args.write(self._oprot)
3316 
    self._oprot.writeMessageEnd()
3317 
    self._oprot.trans.flush()
3318 
 
3319 
  def recv_markOrderReturnRequestReceived(self, ):
3320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3321 
    if mtype == TMessageType.EXCEPTION:
3322 
      x = TApplicationException()
3323 
      x.read(self._iprot)
3324 
      self._iprot.readMessageEnd()
3325 
      raise x
3326 
    result = markOrderReturnRequestReceived_result()
3327 
    result.read(self._iprot)
3328 
    self._iprot.readMessageEnd()
3329 
    if result.success is not None:
3330 
      return result.success
3331 
    if result.ex is not None:
3332 
      raise result.ex
3333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3334 
 
3335 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3336 
    """
3337 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3338 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3339 
 
3340 
    Parameters:
3341 
     - orderId
3342 
     - isAuthorized
3343 
    """
3344 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3345 
    return self.recv_markOrderReturnRequestAuthorized()
3346 
 
3347 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3348 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3349 
    args = markOrderReturnRequestAuthorized_args()
3350 
    args.orderId = orderId
3351 
    args.isAuthorized = isAuthorized
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_markOrderReturnRequestAuthorized(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = markOrderReturnRequestAuthorized_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.success is not None:
3367 
      return result.success
3368 
    if result.ex is not None:
3369 
      raise result.ex
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3371 
 
4579 rajveer 3372 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3373 
    """
3374 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3375 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3376 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3377 
    For any other status, it returns false.
3378 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3379 
 
2536 chandransh 3380 
    Parameters:
3381 
     - orderId
4579 rajveer 3382 
     - providerId
2536 chandransh 3383 
    """
4579 rajveer 3384 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3385 
    return self.recv_requestPickupNumber()
3386 
 
4579 rajveer 3387 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3388 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3389 
    args = requestPickupNumber_args()
3390 
    args.orderId = orderId
4579 rajveer 3391 
    args.providerId = providerId
2536 chandransh 3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_requestPickupNumber(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = requestPickupNumber_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3431 rajveer 3406 
    if result.success is not None:
2536 chandransh 3407 
      return result.success
3431 rajveer 3408 
    if result.ex is not None:
2536 chandransh 3409 
      raise result.ex
3410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3411 
 
4602 rajveer 3412 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3413 
    """
4452 rajveer 3414 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3415 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3416 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3417 
    	3. Returns true
2591 chandransh 3418 
    If the order is in any other status, it returns false.
2536 chandransh 3419 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3420 
 
2536 chandransh 3421 
    Parameters:
3422 
     - orderId
3423 
     - pickupNumber
4602 rajveer 3424 
     - providerId
2536 chandransh 3425 
    """
4602 rajveer 3426 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3427 
    return self.recv_authorizePickup()
3428 
 
4602 rajveer 3429 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3430 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3431 
    args = authorizePickup_args()
3432 
    args.orderId = orderId
3433 
    args.pickupNumber = pickupNumber
4602 rajveer 3434 
    args.providerId = providerId
2536 chandransh 3435 
    args.write(self._oprot)
3436 
    self._oprot.writeMessageEnd()
3437 
    self._oprot.trans.flush()
3438 
 
3439 
  def recv_authorizePickup(self, ):
3440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3441 
    if mtype == TMessageType.EXCEPTION:
3442 
      x = TApplicationException()
3443 
      x.read(self._iprot)
3444 
      self._iprot.readMessageEnd()
3445 
      raise x
3446 
    result = authorizePickup_result()
3447 
    result.read(self._iprot)
3448 
    self._iprot.readMessageEnd()
3431 rajveer 3449 
    if result.success is not None:
2536 chandransh 3450 
      return result.success
3431 rajveer 3451 
    if result.ex is not None:
2536 chandransh 3452 
      raise result.ex
3453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3454 
 
2764 chandransh 3455 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3456 
    """
3457 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3458 
 
2764 chandransh 3459 
    Parameters:
3460 
     - providerId
3461 
     - pickupDetails
3462 
    """
3463 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3464 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3465 
 
3466 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3467 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3468 
    args = markDoasAsPickedUp_args()
3469 
    args.providerId = providerId
3470 
    args.pickupDetails = pickupDetails
3471 
    args.write(self._oprot)
3472 
    self._oprot.writeMessageEnd()
3473 
    self._oprot.trans.flush()
3474 
 
3475 
  def recv_markDoasAsPickedUp(self, ):
3476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3477 
    if mtype == TMessageType.EXCEPTION:
3478 
      x = TApplicationException()
3479 
      x.read(self._iprot)
3480 
      self._iprot.readMessageEnd()
3481 
      raise x
3482 
    result = markDoasAsPickedUp_result()
3483 
    result.read(self._iprot)
3484 
    self._iprot.readMessageEnd()
4910 phani.kuma 3485 
    return
3486 
 
3487 
  def getDoasNotPickedUp(self, providerId):
3488 
    """
3489 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3490 
 
3491 
    Parameters:
3492 
     - providerId
3493 
    """
3494 
    self.send_getDoasNotPickedUp(providerId)
3495 
    return self.recv_getDoasNotPickedUp()
3496 
 
3497 
  def send_getDoasNotPickedUp(self, providerId):
3498 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3499 
    args = getDoasNotPickedUp_args()
3500 
    args.providerId = providerId
3501 
    args.write(self._oprot)
3502 
    self._oprot.writeMessageEnd()
3503 
    self._oprot.trans.flush()
3504 
 
3505 
  def recv_getDoasNotPickedUp(self, ):
3506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3507 
    if mtype == TMessageType.EXCEPTION:
3508 
      x = TApplicationException()
3509 
      x.read(self._iprot)
3510 
      self._iprot.readMessageEnd()
3511 
      raise x
3512 
    result = getDoasNotPickedUp_result()
3513 
    result.read(self._iprot)
3514 
    self._iprot.readMessageEnd()
3431 rajveer 3515 
    if result.success is not None:
2764 chandransh 3516 
      return result.success
4910 phani.kuma 3517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3518 
 
4741 phani.kuma 3519 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3520 
    """
3521 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3522 
 
3523 
    Parameters:
3524 
     - providerId
3525 
     - pickupDetails
3526 
    """
3527 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3528 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3529 
 
3530 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3531 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3532 
    args = markReturnOrdersAsPickedUp_args()
3533 
    args.providerId = providerId
3534 
    args.pickupDetails = pickupDetails
3535 
    args.write(self._oprot)
3536 
    self._oprot.writeMessageEnd()
3537 
    self._oprot.trans.flush()
3538 
 
3539 
  def recv_markReturnOrdersAsPickedUp(self, ):
3540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3541 
    if mtype == TMessageType.EXCEPTION:
3542 
      x = TApplicationException()
3543 
      x.read(self._iprot)
3544 
      self._iprot.readMessageEnd()
3545 
      raise x
3546 
    result = markReturnOrdersAsPickedUp_result()
3547 
    result.read(self._iprot)
3548 
    self._iprot.readMessageEnd()
4910 phani.kuma 3549 
    return
3550 
 
3551 
  def getReturnOrdersNotPickedUp(self, providerId):
3552 
    """
3553 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3554 
 
3555 
    Parameters:
3556 
     - providerId
3557 
    """
3558 
    self.send_getReturnOrdersNotPickedUp(providerId)
3559 
    return self.recv_getReturnOrdersNotPickedUp()
3560 
 
3561 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3562 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3563 
    args = getReturnOrdersNotPickedUp_args()
3564 
    args.providerId = providerId
3565 
    args.write(self._oprot)
3566 
    self._oprot.writeMessageEnd()
3567 
    self._oprot.trans.flush()
3568 
 
3569 
  def recv_getReturnOrdersNotPickedUp(self, ):
3570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3571 
    if mtype == TMessageType.EXCEPTION:
3572 
      x = TApplicationException()
3573 
      x.read(self._iprot)
3574 
      self._iprot.readMessageEnd()
3575 
      raise x
3576 
    result = getReturnOrdersNotPickedUp_result()
3577 
    result.read(self._iprot)
3578 
    self._iprot.readMessageEnd()
4741 phani.kuma 3579 
    if result.success is not None:
3580 
      return result.success
4910 phani.kuma 3581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3582 
 
4479 rajveer 3583 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3584 
    """
4452 rajveer 3585 
    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 3586 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3587 
    If the order is in any other state, it returns false.
3588 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3589 
 
2591 chandransh 3590 
    Parameters:
3591 
     - orderId
4479 rajveer 3592 
     - receiveCondition
2591 chandransh 3593 
    """
4479 rajveer 3594 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3595 
    return self.recv_receiveReturn()
2536 chandransh 3596 
 
4479 rajveer 3597 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3598 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3599 
    args = receiveReturn_args()
2591 chandransh 3600 
    args.orderId = orderId
4479 rajveer 3601 
    args.receiveCondition = receiveCondition
2591 chandransh 3602 
    args.write(self._oprot)
3603 
    self._oprot.writeMessageEnd()
3604 
    self._oprot.trans.flush()
3605 
 
2616 chandransh 3606 
  def recv_receiveReturn(self, ):
2591 chandransh 3607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3608 
    if mtype == TMessageType.EXCEPTION:
3609 
      x = TApplicationException()
3610 
      x.read(self._iprot)
3611 
      self._iprot.readMessageEnd()
3612 
      raise x
2616 chandransh 3613 
    result = receiveReturn_result()
2591 chandransh 3614 
    result.read(self._iprot)
3615 
    self._iprot.readMessageEnd()
3431 rajveer 3616 
    if result.success is not None:
2591 chandransh 3617 
      return result.success
3431 rajveer 3618 
    if result.ex is not None:
2591 chandransh 3619 
      raise result.ex
2616 chandransh 3620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3621 
 
3622 
  def validateDoa(self, orderId, isValid):
3623 
    """
4452 rajveer 3624 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3625 
    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 3626 
    If the order is in any other state, it returns false.
3627 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3628 
 
2591 chandransh 3629 
    Parameters:
3630 
     - orderId
3631 
     - isValid
3632 
    """
3633 
    self.send_validateDoa(orderId, isValid)
3634 
    return self.recv_validateDoa()
3635 
 
3636 
  def send_validateDoa(self, orderId, isValid):
3637 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3638 
    args = validateDoa_args()
3639 
    args.orderId = orderId
3640 
    args.isValid = isValid
3641 
    args.write(self._oprot)
3642 
    self._oprot.writeMessageEnd()
3643 
    self._oprot.trans.flush()
3644 
 
3645 
  def recv_validateDoa(self, ):
3646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3647 
    if mtype == TMessageType.EXCEPTION:
3648 
      x = TApplicationException()
3649 
      x.read(self._iprot)
3650 
      self._iprot.readMessageEnd()
3651 
      raise x
3652 
    result = validateDoa_result()
3653 
    result.read(self._iprot)
3654 
    self._iprot.readMessageEnd()
3431 rajveer 3655 
    if result.success is not None:
2591 chandransh 3656 
      return result.success
3431 rajveer 3657 
    if result.ex is not None:
2591 chandransh 3658 
      raise result.ex
3659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3660 
 
4495 rajveer 3661 
  def validateReturnProduct(self, orderId, isUsable):
3662 
    """
3663 
    Parameters:
3664 
     - orderId
3665 
     - isUsable
3666 
    """
3667 
    self.send_validateReturnProduct(orderId, isUsable)
3668 
    return self.recv_validateReturnProduct()
3669 
 
3670 
  def send_validateReturnProduct(self, orderId, isUsable):
3671 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3672 
    args = validateReturnProduct_args()
3673 
    args.orderId = orderId
3674 
    args.isUsable = isUsable
3675 
    args.write(self._oprot)
3676 
    self._oprot.writeMessageEnd()
3677 
    self._oprot.trans.flush()
3678 
 
3679 
  def recv_validateReturnProduct(self, ):
3680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3681 
    if mtype == TMessageType.EXCEPTION:
3682 
      x = TApplicationException()
3683 
      x.read(self._iprot)
3684 
      self._iprot.readMessageEnd()
3685 
      raise x
3686 
    result = validateReturnProduct_result()
3687 
    result.read(self._iprot)
3688 
    self._iprot.readMessageEnd()
3689 
    if result.success is not None:
3690 
      return result.success
3691 
    if result.ex is not None:
3692 
      raise result.ex
3693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3694 
 
2616 chandransh 3695 
  def reshipOrder(self, orderId):
3696 
    """
4484 rajveer 3697 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3698 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3699 
    	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 3700 
 
3701 
    If the order is in DOA_CERT_VALID state, it does the following:
3702 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3703 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3704 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3705 
 
2616 chandransh 3706 
    Returns the id of the newly created order.
3431 rajveer 3707 
 
2616 chandransh 3708 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3709 
 
2616 chandransh 3710 
    Parameters:
3711 
     - orderId
3712 
    """
3713 
    self.send_reshipOrder(orderId)
3714 
    return self.recv_reshipOrder()
2591 chandransh 3715 
 
2616 chandransh 3716 
  def send_reshipOrder(self, orderId):
3717 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3718 
    args = reshipOrder_args()
3719 
    args.orderId = orderId
3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_reshipOrder(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = reshipOrder_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3431 rajveer 3734 
    if result.success is not None:
2616 chandransh 3735 
      return result.success
3431 rajveer 3736 
    if result.ex is not None:
2616 chandransh 3737 
      raise result.ex
3738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3739 
 
3226 chandransh 3740 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3741 
    """
4484 rajveer 3742 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3743 
    	1. Creates a refund request for batch processing.
3744 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3745 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3746 
 
2616 chandransh 3747 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3748 
    	1. Creates a refund request for batch processing.
3226 chandransh 3749 
    	2. Cancels the reservation of the item in the warehouse.
3750 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3751 
 
3226 chandransh 3752 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3753 
    	1. Cancels the reservation of the item in the warehouse.
3754 
    	2. Marks the current order as CANCELED.
3755 
 
3756 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3757 
 
2616 chandransh 3758 
    Returns True if it is successful, False otherwise.
3431 rajveer 3759 
 
2616 chandransh 3760 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3761 
 
2616 chandransh 3762 
    Parameters:
3763 
     - orderId
3226 chandransh 3764 
     - refundedBy
3765 
     - reason
2616 chandransh 3766 
    """
3226 chandransh 3767 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3768 
    return self.recv_refundOrder()
3769 
 
3226 chandransh 3770 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3771 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3772 
    args = refundOrder_args()
3773 
    args.orderId = orderId
3226 chandransh 3774 
    args.refundedBy = refundedBy
3775 
    args.reason = reason
2616 chandransh 3776 
    args.write(self._oprot)
3777 
    self._oprot.writeMessageEnd()
3778 
    self._oprot.trans.flush()
3779 
 
3780 
  def recv_refundOrder(self, ):
3781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3782 
    if mtype == TMessageType.EXCEPTION:
3783 
      x = TApplicationException()
3784 
      x.read(self._iprot)
3785 
      self._iprot.readMessageEnd()
3786 
      raise x
3787 
    result = refundOrder_result()
3788 
    result.read(self._iprot)
3789 
    self._iprot.readMessageEnd()
3431 rajveer 3790 
    if result.success is not None:
2616 chandransh 3791 
      return result.success
3431 rajveer 3792 
    if result.ex is not None:
2616 chandransh 3793 
      raise result.ex
3794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3795 
 
2690 chandransh 3796 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3797 
    """
3798 
    Get all return orders created between the from and to dates for the given warehouse.
3799 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3800 
 
2690 chandransh 3801 
    Parameters:
3802 
     - warehouseId
3803 
     - fromDate
3804 
     - toDate
3805 
    """
3806 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3807 
    return self.recv_getReturnOrders()
2616 chandransh 3808 
 
2690 chandransh 3809 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3810 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3811 
    args = getReturnOrders_args()
3812 
    args.warehouseId = warehouseId
3813 
    args.fromDate = fromDate
3814 
    args.toDate = toDate
3815 
    args.write(self._oprot)
3816 
    self._oprot.writeMessageEnd()
3817 
    self._oprot.trans.flush()
3818 
 
3819 
  def recv_getReturnOrders(self, ):
3820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3821 
    if mtype == TMessageType.EXCEPTION:
3822 
      x = TApplicationException()
3823 
      x.read(self._iprot)
3824 
      self._iprot.readMessageEnd()
3825 
      raise x
3826 
    result = getReturnOrders_result()
3827 
    result.read(self._iprot)
3828 
    self._iprot.readMessageEnd()
3431 rajveer 3829 
    if result.success is not None:
2690 chandransh 3830 
      return result.success
3831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3832 
 
5481 phani.kuma 3833 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3834 
    """
3835 
    Get all return orders created between the from and to dates.
3836 
 
3837 
    Parameters:
3838 
     - onlyNotProcessed
3839 
     - fromDate
3840 
     - toDate
3841 
    """
3842 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3843 
    return self.recv_getAllReturnOrders()
3844 
 
3845 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3846 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3847 
    args = getAllReturnOrders_args()
3848 
    args.onlyNotProcessed = onlyNotProcessed
3849 
    args.fromDate = fromDate
3850 
    args.toDate = toDate
3851 
    args.write(self._oprot)
3852 
    self._oprot.writeMessageEnd()
3853 
    self._oprot.trans.flush()
3854 
 
3855 
  def recv_getAllReturnOrders(self, ):
3856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3857 
    if mtype == TMessageType.EXCEPTION:
3858 
      x = TApplicationException()
3859 
      x.read(self._iprot)
3860 
      self._iprot.readMessageEnd()
3861 
      raise x
3862 
    result = getAllReturnOrders_result()
3863 
    result.read(self._iprot)
3864 
    self._iprot.readMessageEnd()
3865 
    if result.success is not None:
3866 
      return result.success
3867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3868 
 
2700 chandransh 3869 
  def getReturnOrder(self, id):
3870 
    """
3871 
    Returns the ReturnOrder corresponding to the given id.
3872 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3873 
 
2700 chandransh 3874 
    Parameters:
3875 
     - id
3876 
    """
3877 
    self.send_getReturnOrder(id)
3878 
    return self.recv_getReturnOrder()
3879 
 
3880 
  def send_getReturnOrder(self, id):
3881 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3882 
    args = getReturnOrder_args()
3883 
    args.id = id
3884 
    args.write(self._oprot)
3885 
    self._oprot.writeMessageEnd()
3886 
    self._oprot.trans.flush()
3887 
 
3888 
  def recv_getReturnOrder(self, ):
3889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3890 
    if mtype == TMessageType.EXCEPTION:
3891 
      x = TApplicationException()
3892 
      x.read(self._iprot)
3893 
      self._iprot.readMessageEnd()
3894 
      raise x
3895 
    result = getReturnOrder_result()
3896 
    result.read(self._iprot)
3897 
    self._iprot.readMessageEnd()
3431 rajveer 3898 
    if result.success is not None:
2700 chandransh 3899 
      return result.success
3431 rajveer 3900 
    if result.ex is not None:
2700 chandransh 3901 
      raise result.ex
3902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3903 
 
2690 chandransh 3904 
  def processReturn(self, returnOrderId):
3905 
    """
3906 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3907 
 
2690 chandransh 3908 
    Parameters:
3909 
     - returnOrderId
3910 
    """
3911 
    self.send_processReturn(returnOrderId)
3912 
    self.recv_processReturn()
3913 
 
3914 
  def send_processReturn(self, returnOrderId):
3915 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3916 
    args = processReturn_args()
3917 
    args.returnOrderId = returnOrderId
3918 
    args.write(self._oprot)
3919 
    self._oprot.writeMessageEnd()
3920 
    self._oprot.trans.flush()
3921 
 
3922 
  def recv_processReturn(self, ):
3923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3924 
    if mtype == TMessageType.EXCEPTION:
3925 
      x = TApplicationException()
3926 
      x.read(self._iprot)
3927 
      self._iprot.readMessageEnd()
3928 
      raise x
3929 
    result = processReturn_result()
3930 
    result.read(self._iprot)
3931 
    self._iprot.readMessageEnd()
3431 rajveer 3932 
    if result.ex is not None:
2690 chandransh 3933 
      raise result.ex
3934 
    return
3935 
 
3451 chandransh 3936 
  def updateWeight(self, orderId, weight):
3937 
    """
3938 
    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 3939 
 
3451 chandransh 3940 
    Parameters:
3941 
     - orderId
3942 
     - weight
3943 
    """
3944 
    self.send_updateWeight(orderId, weight)
3945 
    return self.recv_updateWeight()
3946 
 
3947 
  def send_updateWeight(self, orderId, weight):
3948 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3949 
    args = updateWeight_args()
3950 
    args.orderId = orderId
3951 
    args.weight = weight
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_updateWeight(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = updateWeight_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3966 
    if result.success is not None:
3967 
      return result.success
3968 
    if result.ex is not None:
3969 
      raise result.ex
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3971 
 
3469 chandransh 3972 
  def changeItem(self, orderId, itemId):
3973 
    """
3974 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3975 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3976 
 
3469 chandransh 3977 
    Parameters:
3978 
     - orderId
3979 
     - itemId
3980 
    """
3981 
    self.send_changeItem(orderId, itemId)
3982 
    return self.recv_changeItem()
3983 
 
3984 
  def send_changeItem(self, orderId, itemId):
3985 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3986 
    args = changeItem_args()
3987 
    args.orderId = orderId
3988 
    args.itemId = itemId
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_changeItem(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = changeItem_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    if result.success is not None:
4004 
      return result.success
4005 
    if result.ex is not None:
4006 
      raise result.ex
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4008 
 
4009 
  def shiftToWarehouse(self, orderId, warehouseId):
4010 
    """
4011 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4012 
 
4013 
    Parameters:
4014 
     - orderId
4015 
     - warehouseId
4016 
    """
4017 
    self.send_shiftToWarehouse(orderId, warehouseId)
4018 
    return self.recv_shiftToWarehouse()
4019 
 
4020 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4021 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4022 
    args = shiftToWarehouse_args()
4023 
    args.orderId = orderId
4024 
    args.warehouseId = warehouseId
4025 
    args.write(self._oprot)
4026 
    self._oprot.writeMessageEnd()
4027 
    self._oprot.trans.flush()
4028 
 
4029 
  def recv_shiftToWarehouse(self, ):
4030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4031 
    if mtype == TMessageType.EXCEPTION:
4032 
      x = TApplicationException()
4033 
      x.read(self._iprot)
4034 
      self._iprot.readMessageEnd()
4035 
      raise x
4036 
    result = shiftToWarehouse_result()
4037 
    result.read(self._iprot)
4038 
    self._iprot.readMessageEnd()
4039 
    if result.success is not None:
4040 
      return result.success
4041 
    if result.ex is not None:
4042 
      raise result.ex
4043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4044 
 
4647 rajveer 4045 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4046 
    """
4047 
    Adds the given delay reason to the given order.
3986 chandransh 4048 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4049 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4050 
 
3553 chandransh 4051 
    Parameters:
4052 
     - orderId
4053 
     - delayReason
3986 chandransh 4054 
     - furtherDelay
4647 rajveer 4055 
     - delayReasonText
3553 chandransh 4056 
    """
4647 rajveer 4057 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4058 
    return self.recv_addDelayReason()
4059 
 
4647 rajveer 4060 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4061 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4062 
    args = addDelayReason_args()
4063 
    args.orderId = orderId
4064 
    args.delayReason = delayReason
3986 chandransh 4065 
    args.furtherDelay = furtherDelay
4647 rajveer 4066 
    args.delayReasonText = delayReasonText
3553 chandransh 4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_addDelayReason(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = addDelayReason_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
4081 
    if result.success is not None:
4082 
      return result.success
4083 
    if result.ex is not None:
4084 
      raise result.ex
4085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4086 
 
3956 chandransh 4087 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4088 
    """
4089 
    Marks the COD orders with given AWB nos. as having been processed.
4090 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4091 
 
3956 chandransh 4092 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4093 
    1. There is no order corresponding to an AWB number.
4094 
    2. The captured amount for a payment exceeds the total payment.
4095 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4096 
 
4097 
    Parameters:
4098 
     - collectedAmountMap
4099 
     - xferBy
4100 
     - xferTxnId
4101 
     - xferDate
4102 
    """
4103 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4104 
    return self.recv_reconcileCodCollection()
4105 
 
4106 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4107 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4108 
    args = reconcileCodCollection_args()
4109 
    args.collectedAmountMap = collectedAmountMap
4110 
    args.xferBy = xferBy
4111 
    args.xferTxnId = xferTxnId
4112 
    args.xferDate = xferDate
4113 
    args.write(self._oprot)
4114 
    self._oprot.writeMessageEnd()
4115 
    self._oprot.trans.flush()
4116 
 
4117 
  def recv_reconcileCodCollection(self, ):
4118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4119 
    if mtype == TMessageType.EXCEPTION:
4120 
      x = TApplicationException()
4121 
      x.read(self._iprot)
4122 
      self._iprot.readMessageEnd()
4123 
      raise x
4124 
    result = reconcileCodCollection_result()
4125 
    result.read(self._iprot)
4126 
    self._iprot.readMessageEnd()
4127 
    if result.success is not None:
4128 
      return result.success
4129 
    if result.ex is not None:
4130 
      raise result.ex
4131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4132 
 
4008 mandeep.dh 4133 
  def getTransactionsRequiringExtraProcessing(self, category):
4134 
    """
4065 mandeep.dh 4135 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4136 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4137 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4138 
 
4008 mandeep.dh 4139 
    Parameters:
4140 
     - category
4141 
    """
4142 
    self.send_getTransactionsRequiringExtraProcessing(category)
4143 
    return self.recv_getTransactionsRequiringExtraProcessing()
4144 
 
4145 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4146 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4147 
    args = getTransactionsRequiringExtraProcessing_args()
4148 
    args.category = category
4149 
    args.write(self._oprot)
4150 
    self._oprot.writeMessageEnd()
4151 
    self._oprot.trans.flush()
4152 
 
4153 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4155 
    if mtype == TMessageType.EXCEPTION:
4156 
      x = TApplicationException()
4157 
      x.read(self._iprot)
4158 
      self._iprot.readMessageEnd()
4159 
      raise x
4160 
    result = getTransactionsRequiringExtraProcessing_result()
4161 
    result.read(self._iprot)
4162 
    self._iprot.readMessageEnd()
4163 
    if result.success is not None:
4164 
      return result.success
4165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4166 
 
4167 
  def markTransactionAsProcessed(self, transactionId, category):
4168 
    """
4169 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4170 
    It essentially deletes the transaction id record for a particular
4171 
    processing type category (if present) from DB.
4172 
    This is currently used by CRM application.
4008 mandeep.dh 4173 
 
4174 
    Parameters:
4175 
     - transactionId
4176 
     - category
4177 
    """
4178 
    self.send_markTransactionAsProcessed(transactionId, category)
4179 
    self.recv_markTransactionAsProcessed()
4180 
 
4181 
  def send_markTransactionAsProcessed(self, transactionId, category):
4182 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4183 
    args = markTransactionAsProcessed_args()
4184 
    args.transactionId = transactionId
4185 
    args.category = category
4186 
    args.write(self._oprot)
4187 
    self._oprot.writeMessageEnd()
4188 
    self._oprot.trans.flush()
4189 
 
4190 
  def recv_markTransactionAsProcessed(self, ):
4191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4192 
    if mtype == TMessageType.EXCEPTION:
4193 
      x = TApplicationException()
4194 
      x.read(self._iprot)
4195 
      self._iprot.readMessageEnd()
4196 
      raise x
4197 
    result = markTransactionAsProcessed_result()
4198 
    result.read(self._iprot)
4199 
    self._iprot.readMessageEnd()
4200 
    return
4201 
 
4018 chandransh 4202 
  def getItemWiseRiskyOrdersCount(self, ):
4203 
    """
4204 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4205 
    is defined as one whose shipping date is about to expire.
4206 
    """
4207 
    self.send_getItemWiseRiskyOrdersCount()
4208 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4209 
 
4018 chandransh 4210 
  def send_getItemWiseRiskyOrdersCount(self, ):
4211 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4212 
    args = getItemWiseRiskyOrdersCount_args()
4213 
    args.write(self._oprot)
4214 
    self._oprot.writeMessageEnd()
4215 
    self._oprot.trans.flush()
4216 
 
4217 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4219 
    if mtype == TMessageType.EXCEPTION:
4220 
      x = TApplicationException()
4221 
      x.read(self._iprot)
4222 
      self._iprot.readMessageEnd()
4223 
      raise x
4224 
    result = getItemWiseRiskyOrdersCount_result()
4225 
    result.read(self._iprot)
4226 
    self._iprot.readMessageEnd()
4227 
    if result.success is not None:
4228 
      return result.success
4229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4230 
 
4295 varun.gupt 4231 
  def getOrdersForItemIds(self, itemIds):
4232 
    """
4233 
    Returns a list of all orders which have items with given id
4234 
 
4235 
    Parameters:
4236 
     - itemIds
4237 
    """
4238 
    self.send_getOrdersForItemIds(itemIds)
4239 
    return self.recv_getOrdersForItemIds()
4240 
 
4241 
  def send_getOrdersForItemIds(self, itemIds):
4242 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4243 
    args = getOrdersForItemIds_args()
4244 
    args.itemIds = itemIds
4245 
    args.write(self._oprot)
4246 
    self._oprot.writeMessageEnd()
4247 
    self._oprot.trans.flush()
4248 
 
4249 
  def recv_getOrdersForItemIds(self, ):
4250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4251 
    if mtype == TMessageType.EXCEPTION:
4252 
      x = TApplicationException()
4253 
      x.read(self._iprot)
4254 
      self._iprot.readMessageEnd()
4255 
      raise x
4256 
    result = getOrdersForItemIds_result()
4257 
    result.read(self._iprot)
4258 
    self._iprot.readMessageEnd()
4259 
    if result.success is not None:
4260 
      return result.success
4261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4262 
 
4247 rajveer 4263 
  def markOrderCancellationRequestReceived(self, orderId):
4264 
    """
4265 
    Mark order as cancellation request received. If customer sends request of cancellation of
4266 
    a particular order, this method will be called. It will just change status of the order
4267 
    depending on its current status. It also records the previous status, so that we can move
4268 
    back to that status if cancellation request is denied.
4018 chandransh 4269 
 
4247 rajveer 4270 
    Parameters:
4271 
     - orderId
4272 
    """
4273 
    self.send_markOrderCancellationRequestReceived(orderId)
4274 
    self.recv_markOrderCancellationRequestReceived()
4275 
 
4276 
  def send_markOrderCancellationRequestReceived(self, orderId):
4277 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4278 
    args = markOrderCancellationRequestReceived_args()
4279 
    args.orderId = orderId
4280 
    args.write(self._oprot)
4281 
    self._oprot.writeMessageEnd()
4282 
    self._oprot.trans.flush()
4283 
 
4284 
  def recv_markOrderCancellationRequestReceived(self, ):
4285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4286 
    if mtype == TMessageType.EXCEPTION:
4287 
      x = TApplicationException()
4288 
      x.read(self._iprot)
4289 
      self._iprot.readMessageEnd()
4290 
      raise x
4291 
    result = markOrderCancellationRequestReceived_result()
4292 
    result.read(self._iprot)
4293 
    self._iprot.readMessageEnd()
4294 
    if result.ex is not None:
4295 
      raise result.ex
4296 
    return
4297 
 
4298 
  def markOrderCancellationRequestConfirmed(self, orderId):
4299 
    """
4300 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4301 
    cancellation request confirmed. After this OM will be able to cancel the order.
4302 
 
4303 
    Parameters:
4304 
     - orderId
4305 
    """
4306 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4307 
    self.recv_markOrderCancellationRequestConfirmed()
4308 
 
4309 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4310 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4311 
    args = markOrderCancellationRequestConfirmed_args()
4312 
    args.orderId = orderId
4313 
    args.write(self._oprot)
4314 
    self._oprot.writeMessageEnd()
4315 
    self._oprot.trans.flush()
4316 
 
4317 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4319 
    if mtype == TMessageType.EXCEPTION:
4320 
      x = TApplicationException()
4321 
      x.read(self._iprot)
4322 
      self._iprot.readMessageEnd()
4323 
      raise x
4324 
    result = markOrderCancellationRequestConfirmed_result()
4325 
    result.read(self._iprot)
4326 
    self._iprot.readMessageEnd()
4327 
    if result.ex is not None:
4328 
      raise result.ex
4329 
    return
4330 
 
4331 
  def markOrderCancellationRequestDenied(self, orderId):
4332 
    """
4333 
    If we decide to not to cancel order, we will move the order ro previous status.
4334 
 
4335 
    Parameters:
4336 
     - orderId
4337 
    """
4338 
    self.send_markOrderCancellationRequestDenied(orderId)
4339 
    self.recv_markOrderCancellationRequestDenied()
4340 
 
4341 
  def send_markOrderCancellationRequestDenied(self, orderId):
4342 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4343 
    args = markOrderCancellationRequestDenied_args()
4344 
    args.orderId = orderId
4345 
    args.write(self._oprot)
4346 
    self._oprot.writeMessageEnd()
4347 
    self._oprot.trans.flush()
4348 
 
4349 
  def recv_markOrderCancellationRequestDenied(self, ):
4350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4351 
    if mtype == TMessageType.EXCEPTION:
4352 
      x = TApplicationException()
4353 
      x.read(self._iprot)
4354 
      self._iprot.readMessageEnd()
4355 
      raise x
4356 
    result = markOrderCancellationRequestDenied_result()
4357 
    result.read(self._iprot)
4358 
    self._iprot.readMessageEnd()
4359 
    if result.ex is not None:
4360 
      raise result.ex
4361 
    return
4362 
 
4258 rajveer 4363 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4364 
    """
4258 rajveer 4365 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4366 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4367 
 
4368 
    Parameters:
4258 rajveer 4369 
     - transactionId
4247 rajveer 4370 
    """
4258 rajveer 4371 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4372 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4373 
 
4258 rajveer 4374 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4375 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4376 
    args = markTransactionAsPaymentFlagRemoved_args()
4377 
    args.transactionId = transactionId
4247 rajveer 4378 
    args.write(self._oprot)
4379 
    self._oprot.writeMessageEnd()
4380 
    self._oprot.trans.flush()
4381 
 
4258 rajveer 4382 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4384 
    if mtype == TMessageType.EXCEPTION:
4385 
      x = TApplicationException()
4386 
      x.read(self._iprot)
4387 
      self._iprot.readMessageEnd()
4388 
      raise x
4258 rajveer 4389 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4390 
    result.read(self._iprot)
4391 
    self._iprot.readMessageEnd()
4392 
    if result.ex is not None:
4393 
      raise result.ex
4394 
    return
4395 
 
4259 anupam.sin 4396 
  def refundTransaction(self, transactionId, refundedBy, reason):
4397 
    """
4398 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4399 
    need to be cancelled
4247 rajveer 4400 
 
4259 anupam.sin 4401 
    Parameters:
4402 
     - transactionId
4403 
     - refundedBy
4404 
     - reason
4405 
    """
4406 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4407 
    self.recv_refundTransaction()
4408 
 
4409 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4410 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4411 
    args = refundTransaction_args()
4412 
    args.transactionId = transactionId
4413 
    args.refundedBy = refundedBy
4414 
    args.reason = reason
4415 
    args.write(self._oprot)
4416 
    self._oprot.writeMessageEnd()
4417 
    self._oprot.trans.flush()
4418 
 
4419 
  def recv_refundTransaction(self, ):
4420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4421 
    if mtype == TMessageType.EXCEPTION:
4422 
      x = TApplicationException()
4423 
      x.read(self._iprot)
4424 
      self._iprot.readMessageEnd()
4425 
      raise x
4426 
    result = refundTransaction_result()
4427 
    result.read(self._iprot)
4428 
    self._iprot.readMessageEnd()
4429 
    if result.ex is not None:
4430 
      raise result.ex
4431 
    return
4432 
 
4324 mandeep.dh 4433 
  def updateShipmentAddress(self, orderId, addressId):
4434 
    """
4435 
    Updates shipment address of an order. Delivery and shipping date estimates
4436 
    etc. are also updated here.
4437 
 
4438 
    Throws TransactionServiceException in case address change is not
4439 
    possible due to certain reasons such as new pincode in address is
4440 
    not serviceable etc.
4441 
 
4442 
    Parameters:
4443 
     - orderId
4444 
     - addressId
4445 
    """
4446 
    self.send_updateShipmentAddress(orderId, addressId)
4447 
    self.recv_updateShipmentAddress()
4448 
 
4449 
  def send_updateShipmentAddress(self, orderId, addressId):
4450 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4451 
    args = updateShipmentAddress_args()
4452 
    args.orderId = orderId
4453 
    args.addressId = addressId
4454 
    args.write(self._oprot)
4455 
    self._oprot.writeMessageEnd()
4456 
    self._oprot.trans.flush()
4457 
 
4458 
  def recv_updateShipmentAddress(self, ):
4459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4460 
    if mtype == TMessageType.EXCEPTION:
4461 
      x = TApplicationException()
4462 
      x.read(self._iprot)
4463 
      self._iprot.readMessageEnd()
4464 
      raise x
4465 
    result = updateShipmentAddress_result()
4466 
    result.read(self._iprot)
4467 
    self._iprot.readMessageEnd()
4468 
    if result.ex is not None:
4469 
      raise result.ex
4470 
    return
4471 
 
4285 rajveer 4472 
  def acceptOrdersForItemId(self, itemId, inventory):
4473 
    """
4474 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4475 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4476 
 
4285 rajveer 4477 
    Parameters:
4478 
     - itemId
4479 
     - inventory
4480 
    """
4481 
    self.send_acceptOrdersForItemId(itemId, inventory)
4482 
    return self.recv_acceptOrdersForItemId()
4483 
 
4484 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4485 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4486 
    args = acceptOrdersForItemId_args()
4487 
    args.itemId = itemId
4488 
    args.inventory = inventory
4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4493 
  def recv_acceptOrdersForItemId(self, ):
4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4500 
    result = acceptOrdersForItemId_result()
4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    if result.success is not None:
4504 
      return result.success
4505 
    if result.ex is not None:
4506 
      raise result.ex
4507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4508 
 
4369 rajveer 4509 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4510 
    """
4511 
    Parameters:
4512 
     - vendorId
4513 
     - itemId
4514 
     - quantity
4515 
     - estimate
4369 rajveer 4516 
     - isReminder
4303 rajveer 4517 
    """
4369 rajveer 4518 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4519 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4520 
 
4369 rajveer 4521 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4522 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4523 
    args = markOrdersAsPORaised_args()
4524 
    args.vendorId = vendorId
4525 
    args.itemId = itemId
4526 
    args.quantity = quantity
4527 
    args.estimate = estimate
4369 rajveer 4528 
    args.isReminder = isReminder
4303 rajveer 4529 
    args.write(self._oprot)
4530 
    self._oprot.writeMessageEnd()
4531 
    self._oprot.trans.flush()
4532 
 
4533 
  def recv_markOrdersAsPORaised(self, ):
4534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4535 
    if mtype == TMessageType.EXCEPTION:
4536 
      x = TApplicationException()
4537 
      x.read(self._iprot)
4538 
      self._iprot.readMessageEnd()
4539 
      raise x
4540 
    result = markOrdersAsPORaised_result()
4541 
    result.read(self._iprot)
4542 
    self._iprot.readMessageEnd()
4543 
    if result.ex is not None:
4544 
      raise result.ex
4545 
    return
4546 
 
4369 rajveer 4547 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4548 
    """
4549 
    Parameters:
4550 
     - vendorId
4551 
     - itemId
4552 
     - quantity
4553 
     - estimate
4369 rajveer 4554 
     - isReminder
4303 rajveer 4555 
    """
4369 rajveer 4556 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4557 
    self.recv_markOrdersAsReversalInitiated()
4558 
 
4369 rajveer 4559 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4560 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4561 
    args = markOrdersAsReversalInitiated_args()
4562 
    args.vendorId = vendorId
4563 
    args.itemId = itemId
4564 
    args.quantity = quantity
4565 
    args.estimate = estimate
4369 rajveer 4566 
    args.isReminder = isReminder
4303 rajveer 4567 
    args.write(self._oprot)
4568 
    self._oprot.writeMessageEnd()
4569 
    self._oprot.trans.flush()
4570 
 
4571 
  def recv_markOrdersAsReversalInitiated(self, ):
4572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4573 
    if mtype == TMessageType.EXCEPTION:
4574 
      x = TApplicationException()
4575 
      x.read(self._iprot)
4576 
      self._iprot.readMessageEnd()
4577 
      raise x
4578 
    result = markOrdersAsReversalInitiated_result()
4579 
    result.read(self._iprot)
4580 
    self._iprot.readMessageEnd()
4581 
    if result.ex is not None:
4582 
      raise result.ex
4583 
    return
4584 
 
4369 rajveer 4585 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4586 
    """
4587 
    Parameters:
4588 
     - vendorId
4589 
     - itemId
4590 
     - quantity
4591 
     - estimate
4369 rajveer 4592 
     - isReminder
4303 rajveer 4593 
    """
4369 rajveer 4594 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4595 
    self.recv_markOrdersAsNotAvailabke()
4596 
 
4369 rajveer 4597 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4598 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4599 
    args = markOrdersAsNotAvailabke_args()
4600 
    args.vendorId = vendorId
4601 
    args.itemId = itemId
4602 
    args.quantity = quantity
4603 
    args.estimate = estimate
4369 rajveer 4604 
    args.isReminder = isReminder
4303 rajveer 4605 
    args.write(self._oprot)
4606 
    self._oprot.writeMessageEnd()
4607 
    self._oprot.trans.flush()
4608 
 
4609 
  def recv_markOrdersAsNotAvailabke(self, ):
4610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4611 
    if mtype == TMessageType.EXCEPTION:
4612 
      x = TApplicationException()
4613 
      x.read(self._iprot)
4614 
      self._iprot.readMessageEnd()
4615 
      raise x
4616 
    result = markOrdersAsNotAvailabke_result()
4617 
    result.read(self._iprot)
4618 
    self._iprot.readMessageEnd()
4619 
    if result.ex is not None:
4620 
      raise result.ex
4621 
    return
4622 
 
4369 rajveer 4623 
  def markOrdersAsTimeout(self, vendorId):
4624 
    """
4625 
    Parameters:
4626 
     - vendorId
4627 
    """
4628 
    self.send_markOrdersAsTimeout(vendorId)
4629 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4630 
 
4369 rajveer 4631 
  def send_markOrdersAsTimeout(self, vendorId):
4632 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4633 
    args = markOrdersAsTimeout_args()
4634 
    args.vendorId = vendorId
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_markOrdersAsTimeout(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = markOrdersAsTimeout_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    if result.success is not None:
4650 
      return result.success
4651 
    if result.ex is not None:
4652 
      raise result.ex
4653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4654 
 
4662 rajveer 4655 
  def markOrderAsLostInTransit(self, orderId):
4656 
    """
4657 
    Mark order as LOST_IN_TRANSIT
4658 
 
4659 
    Parameters:
4660 
     - orderId
4661 
    """
4662 
    self.send_markOrderAsLostInTransit(orderId)
4663 
    return self.recv_markOrderAsLostInTransit()
4664 
 
4665 
  def send_markOrderAsLostInTransit(self, orderId):
4666 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4667 
    args = markOrderAsLostInTransit_args()
4668 
    args.orderId = orderId
4669 
    args.write(self._oprot)
4670 
    self._oprot.writeMessageEnd()
4671 
    self._oprot.trans.flush()
4672 
 
4673 
  def recv_markOrderAsLostInTransit(self, ):
4674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4675 
    if mtype == TMessageType.EXCEPTION:
4676 
      x = TApplicationException()
4677 
      x.read(self._iprot)
4678 
      self._iprot.readMessageEnd()
4679 
      raise x
4680 
    result = markOrderAsLostInTransit_result()
4681 
    result.read(self._iprot)
4682 
    self._iprot.readMessageEnd()
4683 
    if result.success is not None:
4684 
      return result.success
4685 
    if result.ex is not None:
4686 
      raise result.ex
4687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4688 
 
4386 anupam.sin 4689 
  def getOrderForAwb(self, awb):
4690 
    """
4691 
    Returns the order corresponding to an AWB number
4369 rajveer 4692 
 
4386 anupam.sin 4693 
    Parameters:
4694 
     - awb
4695 
    """
4696 
    self.send_getOrderForAwb(awb)
4697 
    return self.recv_getOrderForAwb()
4698 
 
4699 
  def send_getOrderForAwb(self, awb):
4700 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4701 
    args = getOrderForAwb_args()
4702 
    args.awb = awb
4703 
    args.write(self._oprot)
4704 
    self._oprot.writeMessageEnd()
4705 
    self._oprot.trans.flush()
4706 
 
4707 
  def recv_getOrderForAwb(self, ):
4708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4709 
    if mtype == TMessageType.EXCEPTION:
4710 
      x = TApplicationException()
4711 
      x.read(self._iprot)
4712 
      self._iprot.readMessageEnd()
4713 
      raise x
4714 
    result = getOrderForAwb_result()
4715 
    result.read(self._iprot)
4716 
    self._iprot.readMessageEnd()
4717 
    if result.success is not None:
4718 
      return result.success
4719 
    if result.ex is not None:
4720 
      raise result.ex
4721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4722 
 
4910 phani.kuma 4723 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4724 
    """
4910 phani.kuma 4725 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4726 
 
4506 phani.kuma 4727 
    Parameters:
4728 
     - logistics_provider_id
4910 phani.kuma 4729 
     - order_status_list
4506 phani.kuma 4730 
    """
4910 phani.kuma 4731 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4732 
    return self.recv_getOrdersForProviderForStatus()
4733 
 
4910 phani.kuma 4734 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4735 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4736 
    args = getOrdersForProviderForStatus_args()
4737 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4738 
    args.order_status_list = order_status_list
4506 phani.kuma 4739 
    args.write(self._oprot)
4740 
    self._oprot.writeMessageEnd()
4741 
    self._oprot.trans.flush()
4742 
 
4743 
  def recv_getOrdersForProviderForStatus(self, ):
4744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4745 
    if mtype == TMessageType.EXCEPTION:
4746 
      x = TApplicationException()
4747 
      x.read(self._iprot)
4748 
      self._iprot.readMessageEnd()
4749 
      raise x
4750 
    result = getOrdersForProviderForStatus_result()
4751 
    result.read(self._iprot)
4752 
    self._iprot.readMessageEnd()
4753 
    if result.success is not None:
4754 
      return result.success
4755 
    if result.ex is not None:
4756 
      raise result.ex
4757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4758 
 
4600 varun.gupt 4759 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4760 
    """
4761 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4762 
 
4600 varun.gupt 4763 
    Parameters:
4764 
     - vendorId
4765 
     - billingDateFrom
4766 
     - billingDateTo
4767 
    """
4768 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4769 
    return self.recv_getBilledOrdersForVendor()
4770 
 
4771 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4772 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4773 
    args = getBilledOrdersForVendor_args()
4774 
    args.vendorId = vendorId
4775 
    args.billingDateFrom = billingDateFrom
4776 
    args.billingDateTo = billingDateTo
4777 
    args.write(self._oprot)
4778 
    self._oprot.writeMessageEnd()
4779 
    self._oprot.trans.flush()
4780 
 
4781 
  def recv_getBilledOrdersForVendor(self, ):
4782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4783 
    if mtype == TMessageType.EXCEPTION:
4784 
      x = TApplicationException()
4785 
      x.read(self._iprot)
4786 
      self._iprot.readMessageEnd()
4787 
      raise x
4788 
    result = getBilledOrdersForVendor_result()
4789 
    result.read(self._iprot)
4790 
    self._iprot.readMessageEnd()
4791 
    if result.success is not None:
4792 
      return result.success
4793 
    if result.ex is not None:
4794 
      raise result.ex
4795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4796 
 
4607 rajveer 4797 
  def getSlippedSippingDateOrders(self, ):
4798 
    self.send_getSlippedSippingDateOrders()
4799 
    return self.recv_getSlippedSippingDateOrders()
4800 
 
4801 
  def send_getSlippedSippingDateOrders(self, ):
4802 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4803 
    args = getSlippedSippingDateOrders_args()
4804 
    args.write(self._oprot)
4805 
    self._oprot.writeMessageEnd()
4806 
    self._oprot.trans.flush()
4807 
 
4808 
  def recv_getSlippedSippingDateOrders(self, ):
4809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4810 
    if mtype == TMessageType.EXCEPTION:
4811 
      x = TApplicationException()
4812 
      x.read(self._iprot)
4813 
      self._iprot.readMessageEnd()
4814 
      raise x
4815 
    result = getSlippedSippingDateOrders_result()
4816 
    result.read(self._iprot)
4817 
    self._iprot.readMessageEnd()
4818 
    if result.success is not None:
4819 
      return result.success
4820 
    if result.ex is not None:
4821 
      raise result.ex
4822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4823 
 
4709 rajveer 4824 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4825 
    """
4826 
    Parameters:
4827 
     - cancelDateFrom
4828 
     - cancelDateTo
4829 
    """
4830 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4831 
    return self.recv_getCancelledOrders()
4832 
 
4833 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4834 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4835 
    args = getCancelledOrders_args()
4836 
    args.cancelDateFrom = cancelDateFrom
4837 
    args.cancelDateTo = cancelDateTo
4838 
    args.write(self._oprot)
4839 
    self._oprot.writeMessageEnd()
4840 
    self._oprot.trans.flush()
4841 
 
4842 
  def recv_getCancelledOrders(self, ):
4843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4844 
    if mtype == TMessageType.EXCEPTION:
4845 
      x = TApplicationException()
4846 
      x.read(self._iprot)
4847 
      self._iprot.readMessageEnd()
4848 
      raise x
4849 
    result = getCancelledOrders_result()
4850 
    result.read(self._iprot)
4851 
    self._iprot.readMessageEnd()
4852 
    if result.success is not None:
4853 
      return result.success
4854 
    if result.ex is not None:
4855 
      raise result.ex
4856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4857 
 
4600 varun.gupt 4858 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4859 
    """
4860 
    Parameters:
4861 
     - mapAWBAndAmount
4862 
    """
4863 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4864 
    self.recv_saveBluedartSettlements()
4865 
 
4866 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4867 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4868 
    args = saveBluedartSettlements_args()
4869 
    args.mapAWBAndAmount = mapAWBAndAmount
4870 
    args.write(self._oprot)
4871 
    self._oprot.writeMessageEnd()
4872 
    self._oprot.trans.flush()
4873 
 
4874 
  def recv_saveBluedartSettlements(self, ):
4875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4876 
    if mtype == TMessageType.EXCEPTION:
4877 
      x = TApplicationException()
4878 
      x.read(self._iprot)
4879 
      self._iprot.readMessageEnd()
4880 
      raise x
4881 
    result = saveBluedartSettlements_result()
4882 
    result.read(self._iprot)
4883 
    self._iprot.readMessageEnd()
4884 
    if result.ex is not None:
4885 
      raise result.ex
4886 
    return
4887 
 
4905 varun.gupt 4888 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4889 
    """
4890 
    Parameters:
4891 
     - settlementDate
4892 
     - paymentGatewayId
4905 varun.gupt 4893 
     - referenceId
4600 varun.gupt 4894 
     - serviceTax
4895 
     - otherCharges
4896 
     - netCollection
4897 
    """
4905 varun.gupt 4898 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4899 
    self.recv_savePaymentSettlements()
4900 
 
4905 varun.gupt 4901 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4902 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4903 
    args = savePaymentSettlements_args()
4904 
    args.settlementDate = settlementDate
4905 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4906 
    args.referenceId = referenceId
4600 varun.gupt 4907 
    args.serviceTax = serviceTax
4908 
    args.otherCharges = otherCharges
4909 
    args.netCollection = netCollection
4910 
    args.write(self._oprot)
4911 
    self._oprot.writeMessageEnd()
4912 
    self._oprot.trans.flush()
4913 
 
4914 
  def recv_savePaymentSettlements(self, ):
4915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4916 
    if mtype == TMessageType.EXCEPTION:
4917 
      x = TApplicationException()
4918 
      x.read(self._iprot)
4919 
      self._iprot.readMessageEnd()
4920 
      raise x
4921 
    result = savePaymentSettlements_result()
4922 
    result.read(self._iprot)
4923 
    self._iprot.readMessageEnd()
4924 
    if result.ex is not None:
4925 
      raise result.ex
4926 
    return
4927 
 
4928 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4929 
    """
4930 
    Parameters:
4931 
     - settlementId
4932 
     - settlementDate
4933 
     - transactionDateFrom
4934 
     - transactionDateTo
4935 
     - amount
4936 
    """
4937 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4938 
    self.recv_saveEBSSettlementSummary()
4939 
 
4940 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4941 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4942 
    args = saveEBSSettlementSummary_args()
4943 
    args.settlementId = settlementId
4944 
    args.settlementDate = settlementDate
4945 
    args.transactionDateFrom = transactionDateFrom
4946 
    args.transactionDateTo = transactionDateTo
4947 
    args.amount = amount
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_saveEBSSettlementSummary(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = saveEBSSettlementSummary_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.ex is not None:
4963 
      raise result.ex
4964 
    return
4965 
 
5386 phani.kuma 4966 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4967 
    """
4968 
    Parameters:
5189 varun.gupt 4969 
     - referenceId
4970 
     - isRefund
4600 varun.gupt 4971 
    """
5386 phani.kuma 4972 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4973 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4974 
 
5386 phani.kuma 4975 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4976 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4977 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4978 
    args.referenceId = referenceId
4979 
    args.isRefund = isRefund
4600 varun.gupt 4980 
    args.write(self._oprot)
4981 
    self._oprot.writeMessageEnd()
4982 
    self._oprot.trans.flush()
4983 
 
5386 phani.kuma 4984 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4986 
    if mtype == TMessageType.EXCEPTION:
4987 
      x = TApplicationException()
4988 
      x.read(self._iprot)
4989 
      self._iprot.readMessageEnd()
4990 
      raise x
5386 phani.kuma 4991 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4992 
    result.read(self._iprot)
4993 
    self._iprot.readMessageEnd()
4994 
    if result.success is not None:
4995 
      return result.success
4996 
    if result.ex is not None:
4997 
      raise result.ex
5386 phani.kuma 4998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4999 
 
5386 phani.kuma 5000 
  def getSettlementForCod(self, orderId, isRefund):
5001 
    """
5002 
    Parameters:
5003 
     - orderId
5004 
     - isRefund
5005 
    """
5006 
    self.send_getSettlementForCod(orderId, isRefund)
5007 
    return self.recv_getSettlementForCod()
5008 
 
5009 
  def send_getSettlementForCod(self, orderId, isRefund):
5010 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5011 
    args = getSettlementForCod_args()
5012 
    args.orderId = orderId
5013 
    args.isRefund = isRefund
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_getSettlementForCod(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = getSettlementForCod_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.success is not None:
5029 
      return result.success
5030 
    if result.ex is not None:
5031 
      raise result.ex
5032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5033 
 
4600 varun.gupt 5034 
  def getEBSSettlementSummaries(self, ):
5035 
    self.send_getEBSSettlementSummaries()
5036 
    return self.recv_getEBSSettlementSummaries()
5037 
 
5038 
  def send_getEBSSettlementSummaries(self, ):
5039 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5040 
    args = getEBSSettlementSummaries_args()
5041 
    args.write(self._oprot)
5042 
    self._oprot.writeMessageEnd()
5043 
    self._oprot.trans.flush()
5044 
 
5045 
  def recv_getEBSSettlementSummaries(self, ):
5046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5047 
    if mtype == TMessageType.EXCEPTION:
5048 
      x = TApplicationException()
5049 
      x.read(self._iprot)
5050 
      self._iprot.readMessageEnd()
5051 
      raise x
5052 
    result = getEBSSettlementSummaries_result()
5053 
    result.read(self._iprot)
5054 
    self._iprot.readMessageEnd()
5055 
    if result.success is not None:
5056 
      return result.success
5057 
    if result.ex is not None:
5058 
      raise result.ex
5059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5060 
 
5061 
  def markEBSSettlementUploaded(self, settlementId):
5062 
    """
5063 
    Parameters:
5064 
     - settlementId
5065 
    """
5066 
    self.send_markEBSSettlementUploaded(settlementId)
5067 
    self.recv_markEBSSettlementUploaded()
5068 
 
5069 
  def send_markEBSSettlementUploaded(self, settlementId):
5070 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5071 
    args = markEBSSettlementUploaded_args()
5072 
    args.settlementId = settlementId
5073 
    args.write(self._oprot)
5074 
    self._oprot.writeMessageEnd()
5075 
    self._oprot.trans.flush()
5076 
 
5077 
  def recv_markEBSSettlementUploaded(self, ):
5078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5079 
    if mtype == TMessageType.EXCEPTION:
5080 
      x = TApplicationException()
5081 
      x.read(self._iprot)
5082 
      self._iprot.readMessageEnd()
5083 
      raise x
5084 
    result = markEBSSettlementUploaded_result()
5085 
    result.read(self._iprot)
5086 
    self._iprot.readMessageEnd()
5087 
    if result.ex is not None:
5088 
      raise result.ex
5089 
    return
5090 
 
5091 
  def getEBSSettlementDate(self, settlementId):
5092 
    """
5093 
    Parameters:
5094 
     - settlementId
5095 
    """
5096 
    self.send_getEBSSettlementDate(settlementId)
5097 
    return self.recv_getEBSSettlementDate()
5098 
 
5099 
  def send_getEBSSettlementDate(self, settlementId):
5100 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5101 
    args = getEBSSettlementDate_args()
5102 
    args.settlementId = settlementId
5103 
    args.write(self._oprot)
5104 
    self._oprot.writeMessageEnd()
5105 
    self._oprot.trans.flush()
5106 
 
5107 
  def recv_getEBSSettlementDate(self, ):
5108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5109 
    if mtype == TMessageType.EXCEPTION:
5110 
      x = TApplicationException()
5111 
      x.read(self._iprot)
5112 
      self._iprot.readMessageEnd()
5113 
      raise x
5114 
    result = getEBSSettlementDate_result()
5115 
    result.read(self._iprot)
5116 
    self._iprot.readMessageEnd()
5117 
    if result.success is not None:
5118 
      return result.success
5119 
    if result.ex is not None:
5120 
      raise result.ex
5121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5122 
 
4715 varun.gupt 5123 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5124 
    """
5125 
    Parameters:
5126 
     - settlementDateFrom
5127 
     - settlementDateTo
5128 
     - isRefund
5129 
    """
5130 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5131 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5132 
 
4715 varun.gupt 5133 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5134 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5135 
    args = getSettlementsByDate_args()
5136 
    args.settlementDateFrom = settlementDateFrom
5137 
    args.settlementDateTo = settlementDateTo
5138 
    args.isRefund = isRefund
5139 
    args.write(self._oprot)
5140 
    self._oprot.writeMessageEnd()
5141 
    self._oprot.trans.flush()
5142 
 
5143 
  def recv_getSettlementsByDate(self, ):
5144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5145 
    if mtype == TMessageType.EXCEPTION:
5146 
      x = TApplicationException()
5147 
      x.read(self._iprot)
5148 
      self._iprot.readMessageEnd()
5149 
      raise x
5150 
    result = getSettlementsByDate_result()
5151 
    result.read(self._iprot)
5152 
    self._iprot.readMessageEnd()
5153 
    if result.success is not None:
5154 
      return result.success
5155 
    if result.ex is not None:
5156 
      raise result.ex
5157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5158 
 
5159 
  def getReshippedOrderIds(self, orderIds):
5160 
    """
5161 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5162 
 
5163 
    Parameters:
5164 
     - orderIds
5165 
    """
5166 
    self.send_getReshippedOrderIds(orderIds)
5167 
    return self.recv_getReshippedOrderIds()
5168 
 
5169 
  def send_getReshippedOrderIds(self, orderIds):
5170 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5171 
    args = getReshippedOrderIds_args()
5172 
    args.orderIds = orderIds
5173 
    args.write(self._oprot)
5174 
    self._oprot.writeMessageEnd()
5175 
    self._oprot.trans.flush()
5176 
 
5177 
  def recv_getReshippedOrderIds(self, ):
5178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5179 
    if mtype == TMessageType.EXCEPTION:
5180 
      x = TApplicationException()
5181 
      x.read(self._iprot)
5182 
      self._iprot.readMessageEnd()
5183 
      raise x
5184 
    result = getReshippedOrderIds_result()
5185 
    result.read(self._iprot)
5186 
    self._iprot.readMessageEnd()
5187 
    if result.success is not None:
5188 
      return result.success
5189 
    if result.ex is not None:
5190 
      raise result.ex
5191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5192 
 
5481 phani.kuma 5193 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5194 
    """
5195 
    Parameters:
5196 
     - vendorId
5481 phani.kuma 5197 
     - onlyVendorNotPaid
5198 
     - billingDateFrom
5199 
     - billingDateTo
4875 varun.gupt 5200 
    """
5481 phani.kuma 5201 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5202 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5203 
 
5481 phani.kuma 5204 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5205 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5206 
    args = getBilledOrders_args()
4875 varun.gupt 5207 
    args.vendorId = vendorId
5481 phani.kuma 5208 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5209 
    args.billingDateFrom = billingDateFrom
5210 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5211 
    args.write(self._oprot)
5212 
    self._oprot.writeMessageEnd()
5213 
    self._oprot.trans.flush()
5214 
 
5481 phani.kuma 5215 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5217 
    if mtype == TMessageType.EXCEPTION:
5218 
      x = TApplicationException()
5219 
      x.read(self._iprot)
5220 
      self._iprot.readMessageEnd()
5221 
      raise x
5481 phani.kuma 5222 
    result = getBilledOrders_result()
4875 varun.gupt 5223 
    result.read(self._iprot)
5224 
    self._iprot.readMessageEnd()
5225 
    if result.success is not None:
5226 
      return result.success
5227 
    if result.ex is not None:
5228 
      raise result.ex
5481 phani.kuma 5229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5230 
 
5031 varun.gupt 5231 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5232 
    """
5233 
    Parameters:
5234 
     - startDate
5235 
     - endDate
5236 
    """
5237 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5238 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5239 
 
5031 varun.gupt 5240 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5241 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5242 
    args = getStatusDistributionOfOrders_args()
5243 
    args.startDate = startDate
5244 
    args.endDate = endDate
5245 
    args.write(self._oprot)
5246 
    self._oprot.writeMessageEnd()
5247 
    self._oprot.trans.flush()
5248 
 
5249 
  def recv_getStatusDistributionOfOrders(self, ):
5250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5251 
    if mtype == TMessageType.EXCEPTION:
5252 
      x = TApplicationException()
5253 
      x.read(self._iprot)
5254 
      self._iprot.readMessageEnd()
5255 
      raise x
5256 
    result = getStatusDistributionOfOrders_result()
5257 
    result.read(self._iprot)
5258 
    self._iprot.readMessageEnd()
5259 
    if result.success is not None:
5260 
      return result.success
5261 
    if result.ex is not None:
5262 
      raise result.ex
5263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5264 
 
5067 varun.gupt 5265 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5266 
    """
5267 
    Parameters:
5268 
     - status
5269 
     - startDatetime
5270 
     - endDatetime
5271 
    """
5272 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5273 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5274 
 
5067 varun.gupt 5275 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5276 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5277 
    args = getOrderIdsForStatus_args()
5278 
    args.status = status
5279 
    args.startDatetime = startDatetime
5280 
    args.endDatetime = endDatetime
5281 
    args.write(self._oprot)
5282 
    self._oprot.writeMessageEnd()
5283 
    self._oprot.trans.flush()
5284 
 
5285 
  def recv_getOrderIdsForStatus(self, ):
5286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5287 
    if mtype == TMessageType.EXCEPTION:
5288 
      x = TApplicationException()
5289 
      x.read(self._iprot)
5290 
      self._iprot.readMessageEnd()
5291 
      raise x
5292 
    result = getOrderIdsForStatus_result()
5293 
    result.read(self._iprot)
5294 
    self._iprot.readMessageEnd()
5295 
    if result.success is not None:
5296 
      return result.success
5297 
    if result.ex is not None:
5298 
      raise result.ex
5299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5300 
 
5348 anupam.sin 5301 
  def updateCODAgent(self, agent, orderId):
5302 
    """
5303 
    Updates the agent who handled the COD verification call
5304 
 
5305 
    Parameters:
5306 
     - agent
5307 
     - orderId
5308 
    """
5309 
    self.send_updateCODAgent(agent, orderId)
5310 
    self.recv_updateCODAgent()
5311 
 
5312 
  def send_updateCODAgent(self, agent, orderId):
5313 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5314 
    args = updateCODAgent_args()
5315 
    args.agent = agent
5316 
    args.orderId = orderId
5317 
    args.write(self._oprot)
5318 
    self._oprot.writeMessageEnd()
5319 
    self._oprot.trans.flush()
5320 
 
5321 
  def recv_updateCODAgent(self, ):
5322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5323 
    if mtype == TMessageType.EXCEPTION:
5324 
      x = TApplicationException()
5325 
      x.read(self._iprot)
5326 
      self._iprot.readMessageEnd()
5327 
      raise x
5328 
    result = updateCODAgent_result()
5329 
    result.read(self._iprot)
5330 
    self._iprot.readMessageEnd()
5331 
    if result.ex is not None:
5332 
      raise result.ex
5333 
    return
5334 
 
5099 varun.gupt 5335 
  def updateOrderAsPaidToVendor(self, orderId):
5336 
    """
5337 
    Parameters:
5338 
     - orderId
5339 
    """
5340 
    self.send_updateOrderAsPaidToVendor(orderId)
5341 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5342 
 
5099 varun.gupt 5343 
  def send_updateOrderAsPaidToVendor(self, orderId):
5344 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5345 
    args = updateOrderAsPaidToVendor_args()
5346 
    args.orderId = orderId
5347 
    args.write(self._oprot)
5348 
    self._oprot.writeMessageEnd()
5349 
    self._oprot.trans.flush()
5350 
 
5351 
  def recv_updateOrderAsPaidToVendor(self, ):
5352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5353 
    if mtype == TMessageType.EXCEPTION:
5354 
      x = TApplicationException()
5355 
      x.read(self._iprot)
5356 
      self._iprot.readMessageEnd()
5357 
      raise x
5358 
    result = updateOrderAsPaidToVendor_result()
5359 
    result.read(self._iprot)
5360 
    self._iprot.readMessageEnd()
5361 
    if result.ex is not None:
5362 
      raise result.ex
5363 
    return
5364 
 
5386 phani.kuma 5365 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5366 
    """
5367 
    Parameters:
5368 
     - orderId
5369 
    """
5370 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5371 
    self.recv_updateOrderOnlyAsPaidToVendor()
5372 
 
5373 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5374 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5375 
    args = updateOrderOnlyAsPaidToVendor_args()
5376 
    args.orderId = orderId
5377 
    args.write(self._oprot)
5378 
    self._oprot.writeMessageEnd()
5379 
    self._oprot.trans.flush()
5380 
 
5381 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5383 
    if mtype == TMessageType.EXCEPTION:
5384 
      x = TApplicationException()
5385 
      x.read(self._iprot)
5386 
      self._iprot.readMessageEnd()
5387 
      raise x
5388 
    result = updateOrderOnlyAsPaidToVendor_result()
5389 
    result.read(self._iprot)
5390 
    self._iprot.readMessageEnd()
5391 
    if result.ex is not None:
5392 
      raise result.ex
5393 
    return
5394 
 
5208 varun.gupt 5395 
  def getRefundedOrdersMarkedPaid(self, ):
5396 
    self.send_getRefundedOrdersMarkedPaid()
5397 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5398 
 
5208 varun.gupt 5399 
  def send_getRefundedOrdersMarkedPaid(self, ):
5400 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5401 
    args = getRefundedOrdersMarkedPaid_args()
5402 
    args.write(self._oprot)
5403 
    self._oprot.writeMessageEnd()
5404 
    self._oprot.trans.flush()
5405 
 
5406 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5408 
    if mtype == TMessageType.EXCEPTION:
5409 
      x = TApplicationException()
5410 
      x.read(self._iprot)
5411 
      self._iprot.readMessageEnd()
5412 
      raise x
5413 
    result = getRefundedOrdersMarkedPaid_result()
5414 
    result.read(self._iprot)
5415 
    self._iprot.readMessageEnd()
5416 
    if result.success is not None:
5417 
      return result.success
5418 
    if result.ex is not None:
5419 
      raise result.ex
5420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5421 
 
5447 anupam.sin 5422 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5423 
    """
5424 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5425 
 
5447 anupam.sin 5426 
 
5427 
    Parameters:
5428 
     - minOrderId
5429 
     - maxOrderId
5430 
    """
5431 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5432 
    return self.recv_getAllVerificationAgents()
5433 
 
5434 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5435 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5436 
    args = getAllVerificationAgents_args()
5437 
    args.minOrderId = minOrderId
5438 
    args.maxOrderId = maxOrderId
5439 
    args.write(self._oprot)
5440 
    self._oprot.writeMessageEnd()
5441 
    self._oprot.trans.flush()
5442 
 
5443 
  def recv_getAllVerificationAgents(self, ):
5444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5445 
    if mtype == TMessageType.EXCEPTION:
5446 
      x = TApplicationException()
5447 
      x.read(self._iprot)
5448 
      self._iprot.readMessageEnd()
5449 
      raise x
5450 
    result = getAllVerificationAgents_result()
5451 
    result.read(self._iprot)
5452 
    self._iprot.readMessageEnd()
5453 
    if result.success is not None:
5454 
      return result.success
5455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5456 
 
5527 anupam.sin 5457 
  def getAllAttributesForOrderId(self, orderId):
5458 
    """
5459 
    gets all attributes for a given orderId
5447 anupam.sin 5460 
 
5527 anupam.sin 5461 
    Parameters:
5462 
     - orderId
5463 
    """
5464 
    self.send_getAllAttributesForOrderId(orderId)
5465 
    return self.recv_getAllAttributesForOrderId()
5466 
 
5467 
  def send_getAllAttributesForOrderId(self, orderId):
5468 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5469 
    args = getAllAttributesForOrderId_args()
5470 
    args.orderId = orderId
5471 
    args.write(self._oprot)
5472 
    self._oprot.writeMessageEnd()
5473 
    self._oprot.trans.flush()
5474 
 
5475 
  def recv_getAllAttributesForOrderId(self, ):
5476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5477 
    if mtype == TMessageType.EXCEPTION:
5478 
      x = TApplicationException()
5479 
      x.read(self._iprot)
5480 
      self._iprot.readMessageEnd()
5481 
      raise x
5482 
    result = getAllAttributesForOrderId_result()
5483 
    result.read(self._iprot)
5484 
    self._iprot.readMessageEnd()
5485 
    if result.success is not None:
5486 
      return result.success
5487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5488 
 
5676 rajveer 5489 
  def setOrderAttributes(self, orderId, attributes):
5490 
    """
5491 
    sets attributes for an order
5492 
 
5493 
    Parameters:
5494 
     - orderId
5495 
     - attributes
5496 
    """
5497 
    self.send_setOrderAttributes(orderId, attributes)
5498 
    self.recv_setOrderAttributes()
5499 
 
5500 
  def send_setOrderAttributes(self, orderId, attributes):
5501 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5502 
    args = setOrderAttributes_args()
5503 
    args.orderId = orderId
5504 
    args.attributes = attributes
5505 
    args.write(self._oprot)
5506 
    self._oprot.writeMessageEnd()
5507 
    self._oprot.trans.flush()
5508 
 
5509 
  def recv_setOrderAttributes(self, ):
5510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5511 
    if mtype == TMessageType.EXCEPTION:
5512 
      x = TApplicationException()
5513 
      x.read(self._iprot)
5514 
      self._iprot.readMessageEnd()
5515 
      raise x
5516 
    result = setOrderAttributes_result()
5517 
    result.read(self._iprot)
5518 
    self._iprot.readMessageEnd()
5519 
    return
5520 
 
5527 anupam.sin 5521 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5522 
    """
5523 
    sets attributes for all orders in a transaction
5524 
 
5525 
    Parameters:
5526 
     - transactionId
5527 
     - attribute
5528 
    """
5529 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5530 
    self.recv_setOrderAttributeForTransaction()
5531 
 
5532 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5533 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5534 
    args = setOrderAttributeForTransaction_args()
5535 
    args.transactionId = transactionId
5536 
    args.attribute = attribute
5537 
    args.write(self._oprot)
5538 
    self._oprot.writeMessageEnd()
5539 
    self._oprot.trans.flush()
5540 
 
5541 
  def recv_setOrderAttributeForTransaction(self, ):
5542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5543 
    if mtype == TMessageType.EXCEPTION:
5544 
      x = TApplicationException()
5545 
      x.read(self._iprot)
5546 
      self._iprot.readMessageEnd()
5547 
      raise x
5548 
    result = setOrderAttributeForTransaction_result()
5549 
    result.read(self._iprot)
5550 
    self._iprot.readMessageEnd()
5551 
    return
5552 
 
5553 rajveer 5553 
  def getReceivePendingOrders(self, storeId):
5554 
    """
5555 
    Parameters:
5556 
     - storeId
5557 
    """
5558 
    self.send_getReceivePendingOrders(storeId)
5559 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5560 
 
5553 rajveer 5561 
  def send_getReceivePendingOrders(self, storeId):
5562 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5563 
    args = getReceivePendingOrders_args()
5564 
    args.storeId = storeId
5565 
    args.write(self._oprot)
5566 
    self._oprot.writeMessageEnd()
5567 
    self._oprot.trans.flush()
5568 
 
5569 
  def recv_getReceivePendingOrders(self, ):
5570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5571 
    if mtype == TMessageType.EXCEPTION:
5572 
      x = TApplicationException()
5573 
      x.read(self._iprot)
5574 
      self._iprot.readMessageEnd()
5575 
      raise x
5576 
    result = getReceivePendingOrders_result()
5577 
    result.read(self._iprot)
5578 
    self._iprot.readMessageEnd()
5579 
    if result.success is not None:
5580 
      return result.success
5581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5582 
 
5583 
  def getReceivedAtStoreOrders(self, storeId):
5584 
    """
5585 
    Parameters:
5586 
     - storeId
5587 
    """
5588 
    self.send_getReceivedAtStoreOrders(storeId)
5589 
    return self.recv_getReceivedAtStoreOrders()
5590 
 
5591 
  def send_getReceivedAtStoreOrders(self, storeId):
5592 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5593 
    args = getReceivedAtStoreOrders_args()
5594 
    args.storeId = storeId
5595 
    args.write(self._oprot)
5596 
    self._oprot.writeMessageEnd()
5597 
    self._oprot.trans.flush()
5598 
 
5599 
  def recv_getReceivedAtStoreOrders(self, ):
5600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5601 
    if mtype == TMessageType.EXCEPTION:
5602 
      x = TApplicationException()
5603 
      x.read(self._iprot)
5604 
      self._iprot.readMessageEnd()
5605 
      raise x
5606 
    result = getReceivedAtStoreOrders_result()
5607 
    result.read(self._iprot)
5608 
    self._iprot.readMessageEnd()
5609 
    if result.success is not None:
5610 
      return result.success
5611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5612 
 
5713 rajveer 5613 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5614 
    """
5615 
    Parameters:
5616 
     - storeId
5617 
     - fromDate
5618 
     - toDate
5619 
     - onlyCod
5620 
    """
5621 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5622 
    return self.recv_getOrdersCollectionAtStore()
5623 
 
5624 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5625 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5626 
    args = getOrdersCollectionAtStore_args()
5627 
    args.storeId = storeId
5628 
    args.fromDate = fromDate
5629 
    args.toDate = toDate
5630 
    args.onlyCod = onlyCod
5631 
    args.write(self._oprot)
5632 
    self._oprot.writeMessageEnd()
5633 
    self._oprot.trans.flush()
5634 
 
5635 
  def recv_getOrdersCollectionAtStore(self, ):
5636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5637 
    if mtype == TMessageType.EXCEPTION:
5638 
      x = TApplicationException()
5639 
      x.read(self._iprot)
5640 
      self._iprot.readMessageEnd()
5641 
      raise x
5642 
    result = getOrdersCollectionAtStore_result()
5643 
    result.read(self._iprot)
5644 
    self._iprot.readMessageEnd()
5645 
    if result.success is not None:
5646 
      return result.success
5647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5648 
 
5833 rajveer 5649 
  def getOrderAttributeValue(self, orderId, attributeName):
5650 
    """
5651 
    Parameters:
5652 
     - orderId
5653 
     - attributeName
5654 
    """
5655 
    self.send_getOrderAttributeValue(orderId, attributeName)
5656 
    return self.recv_getOrderAttributeValue()
5657 
 
5658 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5659 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5660 
    args = getOrderAttributeValue_args()
5661 
    args.orderId = orderId
5662 
    args.attributeName = attributeName
5663 
    args.write(self._oprot)
5664 
    self._oprot.writeMessageEnd()
5665 
    self._oprot.trans.flush()
5666 
 
5667 
  def recv_getOrderAttributeValue(self, ):
5668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5669 
    if mtype == TMessageType.EXCEPTION:
5670 
      x = TApplicationException()
5671 
      x.read(self._iprot)
5672 
      self._iprot.readMessageEnd()
5673 
      raise x
5674 
    result = getOrderAttributeValue_result()
5675 
    result.read(self._iprot)
5676 
    self._iprot.readMessageEnd()
5677 
    if result.success is not None:
5678 
      return result.success
5679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5680 
 
6019 rajveer 5681 
  def changeJacketNumber(self, orderId, jacketNumber):
5682 
    """
5683 
    Parameters:
5684 
     - orderId
5685 
     - jacketNumber
5686 
    """
5687 
    self.send_changeJacketNumber(orderId, jacketNumber)
5688 
    return self.recv_changeJacketNumber()
5689 
 
5690 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5691 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5692 
    args = changeJacketNumber_args()
5693 
    args.orderId = orderId
5694 
    args.jacketNumber = jacketNumber
5695 
    args.write(self._oprot)
5696 
    self._oprot.writeMessageEnd()
5697 
    self._oprot.trans.flush()
5698 
 
5699 
  def recv_changeJacketNumber(self, ):
5700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5701 
    if mtype == TMessageType.EXCEPTION:
5702 
      x = TApplicationException()
5703 
      x.read(self._iprot)
5704 
      self._iprot.readMessageEnd()
5705 
      raise x
5706 
    result = changeJacketNumber_result()
5707 
    result.read(self._iprot)
5708 
    self._iprot.readMessageEnd()
5709 
    if result.success is not None:
5710 
      return result.success
5711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5712 
 
5713 
  def markOrderAsRtoInTransit(self, orderId):
5714 
    """
5715 
    Parameters:
5716 
     - orderId
5717 
    """
5718 
    self.send_markOrderAsRtoInTransit(orderId)
5719 
    return self.recv_markOrderAsRtoInTransit()
5720 
 
5721 
  def send_markOrderAsRtoInTransit(self, orderId):
5722 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5723 
    args = markOrderAsRtoInTransit_args()
5724 
    args.orderId = orderId
5725 
    args.write(self._oprot)
5726 
    self._oprot.writeMessageEnd()
5727 
    self._oprot.trans.flush()
5728 
 
5729 
  def recv_markOrderAsRtoInTransit(self, ):
5730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5731 
    if mtype == TMessageType.EXCEPTION:
5732 
      x = TApplicationException()
5733 
      x.read(self._iprot)
5734 
      self._iprot.readMessageEnd()
5735 
      raise x
5736 
    result = markOrderAsRtoInTransit_result()
5737 
    result.read(self._iprot)
5738 
    self._iprot.readMessageEnd()
5739 
    if result.success is not None:
5740 
      return result.success
5741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5742 
 
5593 mandeep.dh 5743 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5744 
    """
5745 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5746 
    invoked while scanning IN of items.
5553 rajveer 5747 
 
5593 mandeep.dh 5748 
    Parameters:
5749 
     - itemId
5750 
     - quantity
5751 
     - fulfilmentWarehouseId
5752 
     - billingWarehouseId
5753 
    """
5754 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5755 
    self.recv_acceptOrderForItem()
5756 
 
5757 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5758 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5759 
    args = acceptOrderForItem_args()
5760 
    args.itemId = itemId
5761 
    args.quantity = quantity
5762 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5763 
    args.billingWarehouseId = billingWarehouseId
5764 
    args.write(self._oprot)
5765 
    self._oprot.writeMessageEnd()
5766 
    self._oprot.trans.flush()
5767 
 
5768 
  def recv_acceptOrderForItem(self, ):
5769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5770 
    if mtype == TMessageType.EXCEPTION:
5771 
      x = TApplicationException()
5772 
      x.read(self._iprot)
5773 
      self._iprot.readMessageEnd()
5774 
      raise x
5775 
    result = acceptOrderForItem_result()
5776 
    result.read(self._iprot)
5777 
    self._iprot.readMessageEnd()
5778 
    return
5779 
 
6000 mandeep.dh 5780 
  def createRechargeOrder(self, rechargeOrder):
5781 
    """
5782 
    Parameters:
5783 
     - rechargeOrder
5784 
    """
5785 
    self.send_createRechargeOrder(rechargeOrder)
5786 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5787 
 
6000 mandeep.dh 5788 
  def send_createRechargeOrder(self, rechargeOrder):
5789 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5790 
    args = createRechargeOrder_args()
5791 
    args.rechargeOrder = rechargeOrder
5792 
    args.write(self._oprot)
5793 
    self._oprot.writeMessageEnd()
5794 
    self._oprot.trans.flush()
5795 
 
5796 
  def recv_createRechargeOrder(self, ):
5797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5798 
    if mtype == TMessageType.EXCEPTION:
5799 
      x = TApplicationException()
5800 
      x.read(self._iprot)
5801 
      self._iprot.readMessageEnd()
5802 
      raise x
5803 
    result = createRechargeOrder_result()
5804 
    result.read(self._iprot)
5805 
    self._iprot.readMessageEnd()
5806 
    if result.success is not None:
5807 
      return result.success
5808 
    if result.ex is not None:
5809 
      raise result.ex
5810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5811 
 
6031 rajveer 5812 
  def getRechargeOrder(self, rechargeRrderId):
5813 
    """
5814 
    Parameters:
5815 
     - rechargeRrderId
5816 
    """
5817 
    self.send_getRechargeOrder(rechargeRrderId)
5818 
    return self.recv_getRechargeOrder()
5819 
 
5820 
  def send_getRechargeOrder(self, rechargeRrderId):
5821 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5822 
    args = getRechargeOrder_args()
5823 
    args.rechargeRrderId = rechargeRrderId
5824 
    args.write(self._oprot)
5825 
    self._oprot.writeMessageEnd()
5826 
    self._oprot.trans.flush()
5827 
 
5828 
  def recv_getRechargeOrder(self, ):
5829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5830 
    if mtype == TMessageType.EXCEPTION:
5831 
      x = TApplicationException()
5832 
      x.read(self._iprot)
5833 
      self._iprot.readMessageEnd()
5834 
      raise x
5835 
    result = getRechargeOrder_result()
5836 
    result.read(self._iprot)
5837 
    self._iprot.readMessageEnd()
5838 
    if result.success is not None:
5839 
      return result.success
5840 
    if result.ex is not None:
5841 
      raise result.ex
5842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5843 
 
5844 
  def getRechargeOrders(self, userId):
5845 
    """
5846 
    Parameters:
5847 
     - userId
5848 
    """
5849 
    self.send_getRechargeOrders(userId)
5850 
    return self.recv_getRechargeOrders()
5851 
 
5852 
  def send_getRechargeOrders(self, userId):
5853 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5854 
    args = getRechargeOrders_args()
5855 
    args.userId = userId
5856 
    args.write(self._oprot)
5857 
    self._oprot.writeMessageEnd()
5858 
    self._oprot.trans.flush()
5859 
 
5860 
  def recv_getRechargeOrders(self, ):
5861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5862 
    if mtype == TMessageType.EXCEPTION:
5863 
      x = TApplicationException()
5864 
      x.read(self._iprot)
5865 
      self._iprot.readMessageEnd()
5866 
      raise x
5867 
    result = getRechargeOrders_result()
5868 
    result.read(self._iprot)
5869 
    self._iprot.readMessageEnd()
5870 
    if result.success is not None:
5871 
      return result.success
5872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5873 
 
6000 mandeep.dh 5874 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5875 
    """
5876 
    Parameters:
5877 
     - rechargeOrderId
5878 
     - rechargeOrderStatus
5879 
    """
5880 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5881 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5882 
 
5883 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5884 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5885 
    args = updateRechargeOrderStatus_args()
5886 
    args.rechargeOrderId = rechargeOrderId
5887 
    args.rechargeOrderStatus = rechargeOrderStatus
5888 
    args.write(self._oprot)
5889 
    self._oprot.writeMessageEnd()
5890 
    self._oprot.trans.flush()
5891 
 
5892 
  def recv_updateRechargeOrderStatus(self, ):
5893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5894 
    if mtype == TMessageType.EXCEPTION:
5895 
      x = TApplicationException()
5896 
      x.read(self._iprot)
5897 
      self._iprot.readMessageEnd()
5898 
      raise x
5899 
    result = updateRechargeOrderStatus_result()
5900 
    result.read(self._iprot)
5901 
    self._iprot.readMessageEnd()
6031 rajveer 5902 
    if result.success is not None:
5903 
      return result.success
6000 mandeep.dh 5904 
    if result.ex is not None:
5905 
      raise result.ex
6031 rajveer 5906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5907 
 
6031 rajveer 5908 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5909 
    """
5910 
    Parameters:
6031 rajveer 5911 
     - rechargeOrderId
6000 mandeep.dh 5912 
    """
6031 rajveer 5913 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5914 
    return self.recv_activateRechargeTxn()
5915 
 
6031 rajveer 5916 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5917 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5918 
    args = activateRechargeTxn_args()
6031 rajveer 5919 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5920 
    args.write(self._oprot)
5921 
    self._oprot.writeMessageEnd()
5922 
    self._oprot.trans.flush()
5923 
 
5924 
  def recv_activateRechargeTxn(self, ):
5925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5926 
    if mtype == TMessageType.EXCEPTION:
5927 
      x = TApplicationException()
5928 
      x.read(self._iprot)
5929 
      self._iprot.readMessageEnd()
5930 
      raise x
5931 
    result = activateRechargeTxn_result()
5932 
    result.read(self._iprot)
5933 
    self._iprot.readMessageEnd()
5934 
    if result.success is not None:
5935 
      return result.success
5936 
    if result.ex is not None:
5937 
      raise result.ex
5938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5939 
 
6031 rajveer 5940 
  def getUserWallet(self, userId):
6000 mandeep.dh 5941 
    """
5942 
    Parameters:
6031 rajveer 5943 
     - userId
6000 mandeep.dh 5944 
    """
6031 rajveer 5945 
    self.send_getUserWallet(userId)
5946 
    return self.recv_getUserWallet()
6000 mandeep.dh 5947 
 
6031 rajveer 5948 
  def send_getUserWallet(self, userId):
5949 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
5950 
    args = getUserWallet_args()
5951 
    args.userId = userId
6000 mandeep.dh 5952 
    args.write(self._oprot)
5953 
    self._oprot.writeMessageEnd()
5954 
    self._oprot.trans.flush()
5955 
 
6031 rajveer 5956 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 5957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5958 
    if mtype == TMessageType.EXCEPTION:
5959 
      x = TApplicationException()
5960 
      x.read(self._iprot)
5961 
      self._iprot.readMessageEnd()
5962 
      raise x
6031 rajveer 5963 
    result = getUserWallet_result()
6000 mandeep.dh 5964 
    result.read(self._iprot)
5965 
    self._iprot.readMessageEnd()
5966 
    if result.success is not None:
5967 
      return result.success
6031 rajveer 5968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 5969 
 
6031 rajveer 5970 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 5971 
    """
5972 
    Parameters:
6031 rajveer 5973 
     - userId
6000 mandeep.dh 5974 
    """
6031 rajveer 5975 
    self.send_getUserWalletHistory(userId)
5976 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 5977 
 
6031 rajveer 5978 
  def send_getUserWalletHistory(self, userId):
5979 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
5980 
    args = getUserWalletHistory_args()
5981 
    args.userId = userId
6000 mandeep.dh 5982 
    args.write(self._oprot)
5983 
    self._oprot.writeMessageEnd()
5984 
    self._oprot.trans.flush()
5985 
 
6031 rajveer 5986 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 5987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5988 
    if mtype == TMessageType.EXCEPTION:
5989 
      x = TApplicationException()
5990 
      x.read(self._iprot)
5991 
      self._iprot.readMessageEnd()
5992 
      raise x
6031 rajveer 5993 
    result = getUserWalletHistory_result()
6000 mandeep.dh 5994 
    result.read(self._iprot)
5995 
    self._iprot.readMessageEnd()
5996 
    if result.success is not None:
5997 
      return result.success
6031 rajveer 5998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 5999 
 
6000 
 
3376 rajveer 6001 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6002 
  def __init__(self, handler):
3376 rajveer 6003 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6004 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6005 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6006 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6007 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6008 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6009 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6010 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6011 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6012 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6013 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6014 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6015 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6016 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6017 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6018 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6019 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6020 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6021 
    self._processMap["createOrder"] = Processor.process_createOrder
6022 
    self._processMap["getOrder"] = Processor.process_getOrder
6023 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6024 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6025 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6026 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6027 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6028 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6029 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6030 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6031 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6032 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6033 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6034 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6035 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6036 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6037 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6038 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6039 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6040 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6041 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6042 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6043 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6044 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6045 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6046 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6047 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6048 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6049 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6050 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6051 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6052 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6053 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6054 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6055 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6056 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6057 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6058 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6059 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6060 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6061 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6062 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6063 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6064 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6065 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6066 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6067 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6068 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6069 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6070 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6071 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6072 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6073 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6074 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6075 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6076 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6077 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6078 
    self._processMap["changeItem"] = Processor.process_changeItem
6079 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6080 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6081 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6082 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6083 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6084 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6085 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6086 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6087 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6088 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6089 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6090 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6091 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6092 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6093 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6094 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6095 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6096 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6097 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6098 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6099 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6100 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6101 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6102 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6103 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6104 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6105 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6106 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6107 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6108 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6109 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6110 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6111 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6112 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6113 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6114 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6115 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6116 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6117 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6118 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6119 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6120 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6121 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6122 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6123 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6124 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6125 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6126 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6127 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6128 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6129 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6130 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6131 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6132 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6133 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6134 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6135 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6136 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6137 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
94 ashish 6138 
 
6139 
  def process(self, iprot, oprot):
6140 
    (name, type, seqid) = iprot.readMessageBegin()
6141 
    if name not in self._processMap:
6142 
      iprot.skip(TType.STRUCT)
6143 
      iprot.readMessageEnd()
6144 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6145 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6146 
      x.write(oprot)
6147 
      oprot.writeMessageEnd()
6148 
      oprot.trans.flush()
6149 
      return
6150 
    else:
6151 
      self._processMap[name](self, seqid, iprot, oprot)
6152 
    return True
6153 
 
6154 
  def process_createTransaction(self, seqid, iprot, oprot):
6155 
    args = createTransaction_args()
6156 
    args.read(iprot)
6157 
    iprot.readMessageEnd()
6158 
    result = createTransaction_result()
6159 
    try:
132 ashish 6160 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6161 
    except TransactionServiceException, ex:
6162 
      result.ex = ex
6163 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6164 
    result.write(oprot)
6165 
    oprot.writeMessageEnd()
6166 
    oprot.trans.flush()
6167 
 
6168 
  def process_getTransaction(self, seqid, iprot, oprot):
6169 
    args = getTransaction_args()
6170 
    args.read(iprot)
6171 
    iprot.readMessageEnd()
6172 
    result = getTransaction_result()
6173 
    try:
6174 
      result.success = self._handler.getTransaction(args.id)
6175 
    except TransactionServiceException, ex:
6176 
      result.ex = ex
6177 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6178 
    result.write(oprot)
6179 
    oprot.writeMessageEnd()
6180 
    oprot.trans.flush()
6181 
 
6182 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6183 
    args = getTransactionsForCustomer_args()
6184 
    args.read(iprot)
6185 
    iprot.readMessageEnd()
6186 
    result = getTransactionsForCustomer_result()
6187 
    try:
6188 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6189 
    except TransactionServiceException, ex:
6190 
      result.ex = ex
6191 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6192 
    result.write(oprot)
6193 
    oprot.writeMessageEnd()
6194 
    oprot.trans.flush()
6195 
 
132 ashish 6196 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6197 
    args = getTransactionsForShoppingCartId_args()
6198 
    args.read(iprot)
6199 
    iprot.readMessageEnd()
6200 
    result = getTransactionsForShoppingCartId_result()
6201 
    try:
6202 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6203 
    except TransactionServiceException, ex:
6204 
      result.ex = ex
6205 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6206 
    result.write(oprot)
6207 
    oprot.writeMessageEnd()
6208 
    oprot.trans.flush()
6209 
 
94 ashish 6210 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6211 
    args = getTransactionStatus_args()
6212 
    args.read(iprot)
6213 
    iprot.readMessageEnd()
6214 
    result = getTransactionStatus_result()
6215 
    try:
6216 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6217 
    except TransactionServiceException, ex:
6218 
      result.ex = ex
6219 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6220 
    result.write(oprot)
6221 
    oprot.writeMessageEnd()
6222 
    oprot.trans.flush()
6223 
 
6224 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6225 
    args = changeTransactionStatus_args()
6226 
    args.read(iprot)
6227 
    iprot.readMessageEnd()
6228 
    result = changeTransactionStatus_result()
6229 
    try:
5527 anupam.sin 6230 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6231 
    except TransactionServiceException, ex:
6232 
      result.ex = ex
6233 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6234 
    result.write(oprot)
6235 
    oprot.writeMessageEnd()
6236 
    oprot.trans.flush()
6237 
 
1398 varun.gupt 6238 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6239 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6240 
    args.read(iprot)
6241 
    iprot.readMessageEnd()
1398 varun.gupt 6242 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6243 
    try:
1398 varun.gupt 6244 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6245 
    except TransactionServiceException, ex:
6246 
      result.ex = ex
1398 varun.gupt 6247 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6248 
    result.write(oprot)
6249 
    oprot.writeMessageEnd()
6250 
    oprot.trans.flush()
6251 
 
483 rajveer 6252 
  def process_getAllOrders(self, seqid, iprot, oprot):
6253 
    args = getAllOrders_args()
94 ashish 6254 
    args.read(iprot)
6255 
    iprot.readMessageEnd()
483 rajveer 6256 
    result = getAllOrders_result()
94 ashish 6257 
    try:
4801 anupam.sin 6258 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6259 
    except TransactionServiceException, ex:
6260 
      result.ex = ex
483 rajveer 6261 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6262 
    result.write(oprot)
6263 
    oprot.writeMessageEnd()
6264 
    oprot.trans.flush()
6265 
 
4133 chandransh 6266 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6267 
    args = getOrdersInBatch_args()
6268 
    args.read(iprot)
6269 
    iprot.readMessageEnd()
6270 
    result = getOrdersInBatch_result()
6271 
    try:
6272 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6273 
    except TransactionServiceException, ex:
6274 
      result.ex = ex
6275 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6276 
    result.write(oprot)
6277 
    oprot.writeMessageEnd()
6278 
    oprot.trans.flush()
6279 
 
6280 
  def process_getOrderCount(self, seqid, iprot, oprot):
6281 
    args = getOrderCount_args()
6282 
    args.read(iprot)
6283 
    iprot.readMessageEnd()
6284 
    result = getOrderCount_result()
6285 
    try:
6286 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6287 
    except TransactionServiceException, ex:
6288 
      result.ex = ex
6289 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6290 
    result.write(oprot)
6291 
    oprot.writeMessageEnd()
6292 
    oprot.trans.flush()
6293 
 
999 varun.gupt 6294 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6295 
    args = getOrdersByBillingDate_args()
6296 
    args.read(iprot)
6297 
    iprot.readMessageEnd()
6298 
    result = getOrdersByBillingDate_result()
6299 
    try:
6300 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6301 
    except TransactionServiceException, ex:
6302 
      result.ex = ex
6303 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6304 
    result.write(oprot)
6305 
    oprot.writeMessageEnd()
6306 
    oprot.trans.flush()
6307 
 
3427 chandransh 6308 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6309 
    args = getOrdersByShippingDate_args()
6310 
    args.read(iprot)
6311 
    iprot.readMessageEnd()
6312 
    result = getOrdersByShippingDate_result()
6313 
    try:
3451 chandransh 6314 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6315 
    except TransactionServiceException, ex:
6316 
      result.ex = ex
6317 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6318 
    result.write(oprot)
6319 
    oprot.writeMessageEnd()
6320 
    oprot.trans.flush()
6321 
 
1382 varun.gupt 6322 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6323 
    args = getReturnableOrdersForCustomer_args()
6324 
    args.read(iprot)
6325 
    iprot.readMessageEnd()
6326 
    result = getReturnableOrdersForCustomer_result()
6327 
    try:
6328 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6329 
    except TransactionServiceException, ex:
6330 
      result.ex = ex
6331 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6332 
    result.write(oprot)
6333 
    oprot.writeMessageEnd()
6334 
    oprot.trans.flush()
6335 
 
6336 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6337 
    args = getCancellableOrdersForCustomer_args()
6338 
    args.read(iprot)
6339 
    iprot.readMessageEnd()
6340 
    result = getCancellableOrdersForCustomer_result()
6341 
    try:
6342 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6343 
    except TransactionServiceException, ex:
6344 
      result.ex = ex
6345 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6346 
    result.write(oprot)
6347 
    oprot.writeMessageEnd()
6348 
    oprot.trans.flush()
6349 
 
483 rajveer 6350 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6351 
    args = changeOrderStatus_args()
94 ashish 6352 
    args.read(iprot)
6353 
    iprot.readMessageEnd()
483 rajveer 6354 
    result = changeOrderStatus_result()
94 ashish 6355 
    try:
483 rajveer 6356 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6357 
    except TransactionServiceException, ex:
6358 
      result.ex = ex
483 rajveer 6359 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6360 
    result.write(oprot)
6361 
    oprot.writeMessageEnd()
6362 
    oprot.trans.flush()
6363 
 
483 rajveer 6364 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6365 
    args = getOrdersForTransaction_args()
94 ashish 6366 
    args.read(iprot)
6367 
    iprot.readMessageEnd()
483 rajveer 6368 
    result = getOrdersForTransaction_result()
94 ashish 6369 
    try:
1528 ankur.sing 6370 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6371 
    except TransactionServiceException, ex:
6372 
      result.ex = ex
483 rajveer 6373 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6374 
    result.write(oprot)
6375 
    oprot.writeMessageEnd()
6376 
    oprot.trans.flush()
6377 
 
483 rajveer 6378 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6379 
    args = getOrdersForCustomer_args()
94 ashish 6380 
    args.read(iprot)
6381 
    iprot.readMessageEnd()
483 rajveer 6382 
    result = getOrdersForCustomer_result()
94 ashish 6383 
    try:
3014 chandransh 6384 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6385 
    except TransactionServiceException, ex:
6386 
      result.ex = ex
483 rajveer 6387 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
6391 
 
483 rajveer 6392 
  def process_createOrder(self, seqid, iprot, oprot):
6393 
    args = createOrder_args()
94 ashish 6394 
    args.read(iprot)
6395 
    iprot.readMessageEnd()
483 rajveer 6396 
    result = createOrder_result()
94 ashish 6397 
    try:
483 rajveer 6398 
      result.success = self._handler.createOrder(args.order)
94 ashish 6399 
    except TransactionServiceException, ex:
6400 
      result.ex = ex
483 rajveer 6401 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6402 
    result.write(oprot)
6403 
    oprot.writeMessageEnd()
6404 
    oprot.trans.flush()
6405 
 
483 rajveer 6406 
  def process_getOrder(self, seqid, iprot, oprot):
6407 
    args = getOrder_args()
94 ashish 6408 
    args.read(iprot)
6409 
    iprot.readMessageEnd()
483 rajveer 6410 
    result = getOrder_result()
94 ashish 6411 
    try:
483 rajveer 6412 
      result.success = self._handler.getOrder(args.id)
94 ashish 6413 
    except TransactionServiceException, ex:
6414 
      result.ex = ex
483 rajveer 6415 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6416 
    result.write(oprot)
6417 
    oprot.writeMessageEnd()
6418 
    oprot.trans.flush()
6419 
 
483 rajveer 6420 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6421 
    args = getLineItemsForOrder_args()
94 ashish 6422 
    args.read(iprot)
6423 
    iprot.readMessageEnd()
483 rajveer 6424 
    result = getLineItemsForOrder_result()
94 ashish 6425 
    try:
483 rajveer 6426 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6427 
    except TransactionServiceException, ex:
6428 
      result.ex = ex
483 rajveer 6429 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6430 
    result.write(oprot)
6431 
    oprot.writeMessageEnd()
6432 
    oprot.trans.flush()
6433 
 
4999 phani.kuma 6434 
  def process_getOrderList(self, seqid, iprot, oprot):
6435 
    args = getOrderList_args()
6436 
    args.read(iprot)
6437 
    iprot.readMessageEnd()
6438 
    result = getOrderList_result()
6439 
    result.success = self._handler.getOrderList(args.order_ids)
6440 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6441 
    result.write(oprot)
6442 
    oprot.writeMessageEnd()
6443 
    oprot.trans.flush()
6444 
 
5386 phani.kuma 6445 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6446 
    args = getOrderListForVendor_args()
6447 
    args.read(iprot)
6448 
    iprot.readMessageEnd()
6449 
    result = getOrderListForVendor_result()
6450 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6451 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6452 
    result.write(oprot)
6453 
    oprot.writeMessageEnd()
6454 
    oprot.trans.flush()
6455 
 
1528 ankur.sing 6456 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6457 
    args = getOrderForCustomer_args()
6458 
    args.read(iprot)
6459 
    iprot.readMessageEnd()
6460 
    result = getOrderForCustomer_result()
6461 
    try:
6462 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6463 
    except TransactionServiceException, ex:
6464 
      result.ex = ex
6465 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6466 
    result.write(oprot)
6467 
    oprot.writeMessageEnd()
6468 
    oprot.trans.flush()
6469 
 
3064 chandransh 6470 
  def process_getAlerts(self, seqid, iprot, oprot):
6471 
    args = getAlerts_args()
6472 
    args.read(iprot)
6473 
    iprot.readMessageEnd()
6474 
    result = getAlerts_result()
4444 rajveer 6475 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6476 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
6480 
 
4394 rajveer 6481 
  def process_addAlert(self, seqid, iprot, oprot):
6482 
    args = addAlert_args()
3064 chandransh 6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
4394 rajveer 6485 
    result = addAlert_result()
4444 rajveer 6486 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6487 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6488 
    result.write(oprot)
6489 
    oprot.writeMessageEnd()
6490 
    oprot.trans.flush()
6491 
 
4444 rajveer 6492 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6493 
    args = markAlertsAsSeen_args()
6494 
    args.read(iprot)
6495 
    iprot.readMessageEnd()
6496 
    result = markAlertsAsSeen_result()
6497 
    self._handler.markAlertsAsSeen(args.warehouseId)
6498 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6499 
    result.write(oprot)
6500 
    oprot.writeMessageEnd()
6501 
    oprot.trans.flush()
6502 
 
3064 chandransh 6503 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6504 
    args = getValidOrderCount_args()
6505 
    args.read(iprot)
6506 
    iprot.readMessageEnd()
6507 
    result = getValidOrderCount_result()
6508 
    result.success = self._handler.getValidOrderCount()
6509 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6510 
    result.write(oprot)
6511 
    oprot.writeMessageEnd()
6512 
    oprot.trans.flush()
6513 
 
6514 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6515 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6516 
    args.read(iprot)
6517 
    iprot.readMessageEnd()
6518 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6519 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6520 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6521 
    result.write(oprot)
6522 
    oprot.writeMessageEnd()
6523 
    oprot.trans.flush()
6524 
 
6525 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6526 
    args = getValidOrdersAmountRange_args()
6527 
    args.read(iprot)
6528 
    iprot.readMessageEnd()
6529 
    result = getValidOrdersAmountRange_result()
6530 
    result.success = self._handler.getValidOrdersAmountRange()
6531 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6532 
    result.write(oprot)
6533 
    oprot.writeMessageEnd()
6534 
    oprot.trans.flush()
6535 
 
6536 
  def process_getValidOrders(self, seqid, iprot, oprot):
6537 
    args = getValidOrders_args()
6538 
    args.read(iprot)
6539 
    iprot.readMessageEnd()
6540 
    result = getValidOrders_result()
5874 rajveer 6541 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6542 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6543 
    result.write(oprot)
6544 
    oprot.writeMessageEnd()
6545 
    oprot.trans.flush()
6546 
 
1220 chandransh 6547 
  def process_batchOrders(self, seqid, iprot, oprot):
6548 
    args = batchOrders_args()
6549 
    args.read(iprot)
6550 
    iprot.readMessageEnd()
6551 
    result = batchOrders_result()
6552 
    try:
6553 
      result.success = self._handler.batchOrders(args.warehouseId)
6554 
    except TransactionServiceException, ex:
6555 
      result.ex = ex
6556 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6557 
    result.write(oprot)
6558 
    oprot.writeMessageEnd()
6559 
    oprot.trans.flush()
6560 
 
1208 chandransh 6561 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6562 
    args = markOrderAsOutOfStock_args()
6563 
    args.read(iprot)
6564 
    iprot.readMessageEnd()
6565 
    result = markOrderAsOutOfStock_result()
6566 
    try:
6567 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6568 
    except TransactionServiceException, ex:
6569 
      result.ex = ex
6570 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6571 
    result.write(oprot)
6572 
    oprot.writeMessageEnd()
6573 
    oprot.trans.flush()
6574 
 
3064 chandransh 6575 
  def process_verifyOrder(self, seqid, iprot, oprot):
6576 
    args = verifyOrder_args()
759 chandransh 6577 
    args.read(iprot)
6578 
    iprot.readMessageEnd()
3064 chandransh 6579 
    result = verifyOrder_result()
759 chandransh 6580 
    try:
3064 chandransh 6581 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6582 
    except TransactionServiceException, ex:
6583 
      result.ex = ex
3064 chandransh 6584 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6585 
    result.write(oprot)
6586 
    oprot.writeMessageEnd()
6587 
    oprot.trans.flush()
6588 
 
3064 chandransh 6589 
  def process_acceptOrder(self, seqid, iprot, oprot):
6590 
    args = acceptOrder_args()
1113 chandransh 6591 
    args.read(iprot)
6592 
    iprot.readMessageEnd()
3064 chandransh 6593 
    result = acceptOrder_result()
1113 chandransh 6594 
    try:
3064 chandransh 6595 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6596 
    except TransactionServiceException, ex:
6597 
      result.ex = ex
3064 chandransh 6598 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6599 
    result.write(oprot)
6600 
    oprot.writeMessageEnd()
6601 
    oprot.trans.flush()
6602 
 
3064 chandransh 6603 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6604 
    args = addBillingDetails_args()
1135 chandransh 6605 
    args.read(iprot)
6606 
    iprot.readMessageEnd()
3064 chandransh 6607 
    result = addBillingDetails_result()
1135 chandransh 6608 
    try:
5110 mandeep.dh 6609 
      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 6610 
    except TransactionServiceException, ex:
6611 
      result.ex = ex
3064 chandransh 6612 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6613 
    result.write(oprot)
6614 
    oprot.writeMessageEnd()
6615 
    oprot.trans.flush()
6616 
 
4579 rajveer 6617 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6618 
    args = addInvoiceNumber_args()
6619 
    args.read(iprot)
6620 
    iprot.readMessageEnd()
6621 
    result = addInvoiceNumber_result()
6622 
    try:
4763 rajveer 6623 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6624 
    except TransactionServiceException, ex:
6625 
      result.ex = ex
6626 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
4410 rajveer 6631 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6632 
    args = markOrdersAsShippedFromWarehouse_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = markOrdersAsShippedFromWarehouse_result()
6636 
    try:
4789 rajveer 6637 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6638 
    except TransactionServiceException, ex:
6639 
      result.ex = ex
6640 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
5676 rajveer 6645 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6646 
    args = markOrdersAsReturnedFromStore_args()
6647 
    args.read(iprot)
6648 
    iprot.readMessageEnd()
6649 
    result = markOrdersAsReturnedFromStore_result()
6650 
    try:
5713 rajveer 6651 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6652 
    except TransactionServiceException, ex:
6653 
      result.ex = ex
6654 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6655 
    result.write(oprot)
6656 
    oprot.writeMessageEnd()
6657 
    oprot.trans.flush()
6658 
 
3064 chandransh 6659 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6660 
    args = markOrdersAsPickedUp_args()
304 ashish 6661 
    args.read(iprot)
6662 
    iprot.readMessageEnd()
3064 chandransh 6663 
    result = markOrdersAsPickedUp_result()
6664 
    try:
4910 phani.kuma 6665 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6666 
    except TransactionServiceException, ex:
6667 
      result.ex = ex
6668 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
94 ashish 6672 
 
4910 phani.kuma 6673 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6674 
    args = getOrdersNotPickedUp_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = getOrdersNotPickedUp_result()
6678 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6679 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6680 
    result.write(oprot)
6681 
    oprot.writeMessageEnd()
6682 
    oprot.trans.flush()
6683 
 
3064 chandransh 6684 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6685 
    args = markOrdersAsDelivered_args()
304 ashish 6686 
    args.read(iprot)
6687 
    iprot.readMessageEnd()
3064 chandransh 6688 
    result = markOrdersAsDelivered_result()
6689 
    try:
6690 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6691 
    except TransactionServiceException, ex:
6692 
      result.ex = ex
6693 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6694 
    result.write(oprot)
6695 
    oprot.writeMessageEnd()
6696 
    oprot.trans.flush()
6697 
 
4910 phani.kuma 6698 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6699 
    args = markAsRTOrders_args()
1596 ankur.sing 6700 
    args.read(iprot)
6701 
    iprot.readMessageEnd()
4910 phani.kuma 6702 
    result = markAsRTOrders_result()
3064 chandransh 6703 
    try:
4910 phani.kuma 6704 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6705 
    except TransactionServiceException, ex:
6706 
      result.ex = ex
4910 phani.kuma 6707 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6708 
    result.write(oprot)
6709 
    oprot.writeMessageEnd()
6710 
    oprot.trans.flush()
304 ashish 6711 
 
4910 phani.kuma 6712 
  def process_getRTOrders(self, seqid, iprot, oprot):
6713 
    args = getRTOrders_args()
6714 
    args.read(iprot)
6715 
    iprot.readMessageEnd()
6716 
    result = getRTOrders_result()
6717 
    result.success = self._handler.getRTOrders(args.providerId)
6718 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6719 
    result.write(oprot)
6720 
    oprot.writeMessageEnd()
6721 
    oprot.trans.flush()
6722 
 
3064 chandransh 6723 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6724 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6725 
    args.read(iprot)
6726 
    iprot.readMessageEnd()
3064 chandransh 6727 
    result = updateNonDeliveryReason_result()
6728 
    try:
4910 phani.kuma 6729 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6730 
    except TransactionServiceException, ex:
6731 
      result.ex = ex
6732 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6733 
    result.write(oprot)
6734 
    oprot.writeMessageEnd()
6735 
    oprot.trans.flush()
1596 ankur.sing 6736 
 
4910 phani.kuma 6737 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6738 
    args = getNonDeliveredOrdersbyCourier_args()
6739 
    args.read(iprot)
6740 
    iprot.readMessageEnd()
6741 
    result = getNonDeliveredOrdersbyCourier_result()
6742 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6743 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6744 
    result.write(oprot)
6745 
    oprot.writeMessageEnd()
6746 
    oprot.trans.flush()
6747 
 
6748 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6749 
    args = markOrdersAsLocalConnected_args()
6750 
    args.read(iprot)
6751 
    iprot.readMessageEnd()
6752 
    result = markOrdersAsLocalConnected_result()
6753 
    try:
6754 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6755 
    except TransactionServiceException, ex:
6756 
      result.ex = ex
6757 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6758 
    result.write(oprot)
6759 
    oprot.writeMessageEnd()
6760 
    oprot.trans.flush()
6761 
 
6762 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6763 
    args = getOrdersNotLocalConnected_args()
6764 
    args.read(iprot)
6765 
    iprot.readMessageEnd()
6766 
    result = getOrdersNotLocalConnected_result()
6767 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6768 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6769 
    result.write(oprot)
6770 
    oprot.writeMessageEnd()
6771 
    oprot.trans.flush()
6772 
 
6773 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6774 
    args = markOrdersAsDestinationCityReached_args()
6775 
    args.read(iprot)
6776 
    iprot.readMessageEnd()
6777 
    result = markOrdersAsDestinationCityReached_result()
6778 
    try:
6779 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6780 
    except TransactionServiceException, ex:
6781 
      result.ex = ex
6782 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6783 
    result.write(oprot)
6784 
    oprot.writeMessageEnd()
6785 
    oprot.trans.flush()
6786 
 
6787 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6788 
    args = markOrdersAsFirstDeliveryAttempted_args()
6789 
    args.read(iprot)
6790 
    iprot.readMessageEnd()
6791 
    result = markOrdersAsFirstDeliveryAttempted_result()
6792 
    try:
6793 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6794 
    except TransactionServiceException, ex:
6795 
      result.ex = ex
6796 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6797 
    result.write(oprot)
6798 
    oprot.writeMessageEnd()
6799 
    oprot.trans.flush()
6800 
 
3064 chandransh 6801 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6802 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6803 
    args.read(iprot)
6804 
    iprot.readMessageEnd()
3064 chandransh 6805 
    result = getUndeliveredOrders_result()
6806 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6807 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6808 
    result.write(oprot)
6809 
    oprot.writeMessageEnd()
6810 
    oprot.trans.flush()
6811 
 
4783 phani.kuma 6812 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6813 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6814 
    args.read(iprot)
6815 
    iprot.readMessageEnd()
6816 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6817 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6818 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6819 
    result.write(oprot)
6820 
    oprot.writeMessageEnd()
6821 
    oprot.trans.flush()
6822 
 
2536 chandransh 6823 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6824 
    args = toggleDOAFlag_args()
6825 
    args.read(iprot)
6826 
    iprot.readMessageEnd()
6827 
    result = toggleDOAFlag_result()
6828 
    try:
6829 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6830 
    except TransactionServiceException, ex:
6831 
      result.ex = ex
6832 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6833 
    result.write(oprot)
6834 
    oprot.writeMessageEnd()
6835 
    oprot.trans.flush()
1886 ankur.sing 6836 
 
4712 rajveer 6837 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6838 
    args = markOrderAsDelivered_args()
6839 
    args.read(iprot)
6840 
    iprot.readMessageEnd()
6841 
    result = markOrderAsDelivered_result()
6842 
    try:
6843 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6844 
    except TransactionServiceException, ex:
6845 
      result.ex = ex
6846 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6847 
    result.write(oprot)
6848 
    oprot.writeMessageEnd()
6849 
    oprot.trans.flush()
6850 
 
5553 rajveer 6851 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6852 
    args = markOrderAsReceivedAtStore_args()
6853 
    args.read(iprot)
6854 
    iprot.readMessageEnd()
6855 
    result = markOrderAsReceivedAtStore_result()
6856 
    try:
6857 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6858 
    except TransactionServiceException, ex:
6859 
      result.ex = ex
6860 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6861 
    result.write(oprot)
6862 
    oprot.writeMessageEnd()
6863 
    oprot.trans.flush()
6864 
 
4454 rajveer 6865 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6866 
    args = markOrderDoaRequestReceived_args()
6867 
    args.read(iprot)
6868 
    iprot.readMessageEnd()
6869 
    result = markOrderDoaRequestReceived_result()
6870 
    try:
6871 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6872 
    except TransactionServiceException, ex:
6873 
      result.ex = ex
6874 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6875 
    result.write(oprot)
6876 
    oprot.writeMessageEnd()
6877 
    oprot.trans.flush()
6878 
 
6879 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6880 
    args = markOrderDoaRequestAuthorized_args()
6881 
    args.read(iprot)
6882 
    iprot.readMessageEnd()
6883 
    result = markOrderDoaRequestAuthorized_result()
6884 
    try:
6885 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6886 
    except TransactionServiceException, ex:
6887 
      result.ex = ex
6888 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6889 
    result.write(oprot)
6890 
    oprot.writeMessageEnd()
6891 
    oprot.trans.flush()
6892 
 
4488 rajveer 6893 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6894 
    args = markOrderReturnRequestReceived_args()
6895 
    args.read(iprot)
6896 
    iprot.readMessageEnd()
6897 
    result = markOrderReturnRequestReceived_result()
6898 
    try:
6899 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6900 
    except TransactionServiceException, ex:
6901 
      result.ex = ex
6902 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6903 
    result.write(oprot)
6904 
    oprot.writeMessageEnd()
6905 
    oprot.trans.flush()
6906 
 
6907 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6908 
    args = markOrderReturnRequestAuthorized_args()
6909 
    args.read(iprot)
6910 
    iprot.readMessageEnd()
6911 
    result = markOrderReturnRequestAuthorized_result()
6912 
    try:
6913 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6914 
    except TransactionServiceException, ex:
6915 
      result.ex = ex
6916 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6917 
    result.write(oprot)
6918 
    oprot.writeMessageEnd()
6919 
    oprot.trans.flush()
6920 
 
2536 chandransh 6921 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6922 
    args = requestPickupNumber_args()
6923 
    args.read(iprot)
6924 
    iprot.readMessageEnd()
6925 
    result = requestPickupNumber_result()
6926 
    try:
4579 rajveer 6927 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6928 
    except TransactionServiceException, ex:
6929 
      result.ex = ex
6930 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6931 
    result.write(oprot)
6932 
    oprot.writeMessageEnd()
6933 
    oprot.trans.flush()
6934 
 
6935 
  def process_authorizePickup(self, seqid, iprot, oprot):
6936 
    args = authorizePickup_args()
6937 
    args.read(iprot)
6938 
    iprot.readMessageEnd()
6939 
    result = authorizePickup_result()
6940 
    try:
4602 rajveer 6941 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6942 
    except TransactionServiceException, ex:
6943 
      result.ex = ex
6944 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6945 
    result.write(oprot)
6946 
    oprot.writeMessageEnd()
6947 
    oprot.trans.flush()
6948 
 
2764 chandransh 6949 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6950 
    args = markDoasAsPickedUp_args()
6951 
    args.read(iprot)
6952 
    iprot.readMessageEnd()
6953 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6954 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6955 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6956 
    result.write(oprot)
6957 
    oprot.writeMessageEnd()
6958 
    oprot.trans.flush()
6959 
 
4910 phani.kuma 6960 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6961 
    args = getDoasNotPickedUp_args()
6962 
    args.read(iprot)
6963 
    iprot.readMessageEnd()
6964 
    result = getDoasNotPickedUp_result()
6965 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6966 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6967 
    result.write(oprot)
6968 
    oprot.writeMessageEnd()
6969 
    oprot.trans.flush()
6970 
 
4741 phani.kuma 6971 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6972 
    args = markReturnOrdersAsPickedUp_args()
6973 
    args.read(iprot)
6974 
    iprot.readMessageEnd()
6975 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6976 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6977 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6978 
    result.write(oprot)
6979 
    oprot.writeMessageEnd()
6980 
    oprot.trans.flush()
6981 
 
4910 phani.kuma 6982 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6983 
    args = getReturnOrdersNotPickedUp_args()
6984 
    args.read(iprot)
6985 
    iprot.readMessageEnd()
6986 
    result = getReturnOrdersNotPickedUp_result()
6987 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6988 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6989 
    result.write(oprot)
6990 
    oprot.writeMessageEnd()
6991 
    oprot.trans.flush()
6992 
 
2616 chandransh 6993 
  def process_receiveReturn(self, seqid, iprot, oprot):
6994 
    args = receiveReturn_args()
2591 chandransh 6995 
    args.read(iprot)
6996 
    iprot.readMessageEnd()
2616 chandransh 6997 
    result = receiveReturn_result()
2591 chandransh 6998 
    try:
4479 rajveer 6999 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7000 
    except TransactionServiceException, ex:
7001 
      result.ex = ex
2616 chandransh 7002 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7003 
    result.write(oprot)
7004 
    oprot.writeMessageEnd()
7005 
    oprot.trans.flush()
2536 chandransh 7006 
 
2591 chandransh 7007 
  def process_validateDoa(self, seqid, iprot, oprot):
7008 
    args = validateDoa_args()
7009 
    args.read(iprot)
7010 
    iprot.readMessageEnd()
7011 
    result = validateDoa_result()
7012 
    try:
7013 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7014 
    except TransactionServiceException, ex:
7015 
      result.ex = ex
7016 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7017 
    result.write(oprot)
7018 
    oprot.writeMessageEnd()
7019 
    oprot.trans.flush()
7020 
 
4495 rajveer 7021 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7022 
    args = validateReturnProduct_args()
7023 
    args.read(iprot)
7024 
    iprot.readMessageEnd()
7025 
    result = validateReturnProduct_result()
7026 
    try:
7027 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7028 
    except TransactionServiceException, ex:
7029 
      result.ex = ex
7030 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7031 
    result.write(oprot)
7032 
    oprot.writeMessageEnd()
7033 
    oprot.trans.flush()
7034 
 
2616 chandransh 7035 
  def process_reshipOrder(self, seqid, iprot, oprot):
7036 
    args = reshipOrder_args()
7037 
    args.read(iprot)
7038 
    iprot.readMessageEnd()
7039 
    result = reshipOrder_result()
7040 
    try:
7041 
      result.success = self._handler.reshipOrder(args.orderId)
7042 
    except TransactionServiceException, ex:
7043 
      result.ex = ex
7044 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7045 
    result.write(oprot)
7046 
    oprot.writeMessageEnd()
7047 
    oprot.trans.flush()
2591 chandransh 7048 
 
2616 chandransh 7049 
  def process_refundOrder(self, seqid, iprot, oprot):
7050 
    args = refundOrder_args()
7051 
    args.read(iprot)
7052 
    iprot.readMessageEnd()
7053 
    result = refundOrder_result()
7054 
    try:
3226 chandransh 7055 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7056 
    except TransactionServiceException, ex:
7057 
      result.ex = ex
7058 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7059 
    result.write(oprot)
7060 
    oprot.writeMessageEnd()
7061 
    oprot.trans.flush()
7062 
 
2690 chandransh 7063 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7064 
    args = getReturnOrders_args()
7065 
    args.read(iprot)
7066 
    iprot.readMessageEnd()
7067 
    result = getReturnOrders_result()
7068 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7069 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7070 
    result.write(oprot)
7071 
    oprot.writeMessageEnd()
7072 
    oprot.trans.flush()
2616 chandransh 7073 
 
5481 phani.kuma 7074 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7075 
    args = getAllReturnOrders_args()
7076 
    args.read(iprot)
7077 
    iprot.readMessageEnd()
7078 
    result = getAllReturnOrders_result()
7079 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7080 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7081 
    result.write(oprot)
7082 
    oprot.writeMessageEnd()
7083 
    oprot.trans.flush()
7084 
 
2700 chandransh 7085 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7086 
    args = getReturnOrder_args()
7087 
    args.read(iprot)
7088 
    iprot.readMessageEnd()
7089 
    result = getReturnOrder_result()
7090 
    try:
7091 
      result.success = self._handler.getReturnOrder(args.id)
7092 
    except TransactionServiceException, ex:
7093 
      result.ex = ex
7094 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7095 
    result.write(oprot)
7096 
    oprot.writeMessageEnd()
7097 
    oprot.trans.flush()
7098 
 
2690 chandransh 7099 
  def process_processReturn(self, seqid, iprot, oprot):
7100 
    args = processReturn_args()
7101 
    args.read(iprot)
7102 
    iprot.readMessageEnd()
7103 
    result = processReturn_result()
7104 
    try:
7105 
      self._handler.processReturn(args.returnOrderId)
7106 
    except TransactionServiceException, ex:
7107 
      result.ex = ex
7108 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7109 
    result.write(oprot)
7110 
    oprot.writeMessageEnd()
7111 
    oprot.trans.flush()
7112 
 
3451 chandransh 7113 
  def process_updateWeight(self, seqid, iprot, oprot):
7114 
    args = updateWeight_args()
7115 
    args.read(iprot)
7116 
    iprot.readMessageEnd()
7117 
    result = updateWeight_result()
7118 
    try:
7119 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7120 
    except TransactionServiceException, ex:
7121 
      result.ex = ex
7122 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7123 
    result.write(oprot)
7124 
    oprot.writeMessageEnd()
7125 
    oprot.trans.flush()
2819 chandransh 7126 
 
3469 chandransh 7127 
  def process_changeItem(self, seqid, iprot, oprot):
7128 
    args = changeItem_args()
7129 
    args.read(iprot)
7130 
    iprot.readMessageEnd()
7131 
    result = changeItem_result()
7132 
    try:
7133 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7134 
    except TransactionServiceException, ex:
7135 
      result.ex = ex
7136 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7137 
    result.write(oprot)
7138 
    oprot.writeMessageEnd()
7139 
    oprot.trans.flush()
3451 chandransh 7140 
 
3469 chandransh 7141 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7142 
    args = shiftToWarehouse_args()
7143 
    args.read(iprot)
7144 
    iprot.readMessageEnd()
7145 
    result = shiftToWarehouse_result()
7146 
    try:
7147 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7148 
    except TransactionServiceException, ex:
7149 
      result.ex = ex
7150 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7151 
    result.write(oprot)
7152 
    oprot.writeMessageEnd()
7153 
    oprot.trans.flush()
7154 
 
3553 chandransh 7155 
  def process_addDelayReason(self, seqid, iprot, oprot):
7156 
    args = addDelayReason_args()
7157 
    args.read(iprot)
7158 
    iprot.readMessageEnd()
7159 
    result = addDelayReason_result()
7160 
    try:
4647 rajveer 7161 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7162 
    except TransactionServiceException, ex:
7163 
      result.ex = ex
7164 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7165 
    result.write(oprot)
7166 
    oprot.writeMessageEnd()
7167 
    oprot.trans.flush()
3469 chandransh 7168 
 
3956 chandransh 7169 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7170 
    args = reconcileCodCollection_args()
7171 
    args.read(iprot)
7172 
    iprot.readMessageEnd()
7173 
    result = reconcileCodCollection_result()
7174 
    try:
7175 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7176 
    except TransactionServiceException, ex:
7177 
      result.ex = ex
7178 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7179 
    result.write(oprot)
7180 
    oprot.writeMessageEnd()
7181 
    oprot.trans.flush()
3553 chandransh 7182 
 
4008 mandeep.dh 7183 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7184 
    args = getTransactionsRequiringExtraProcessing_args()
7185 
    args.read(iprot)
7186 
    iprot.readMessageEnd()
7187 
    result = getTransactionsRequiringExtraProcessing_result()
7188 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7189 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7190 
    result.write(oprot)
7191 
    oprot.writeMessageEnd()
7192 
    oprot.trans.flush()
3956 chandransh 7193 
 
4008 mandeep.dh 7194 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7195 
    args = markTransactionAsProcessed_args()
7196 
    args.read(iprot)
7197 
    iprot.readMessageEnd()
7198 
    result = markTransactionAsProcessed_result()
7199 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7200 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7201 
    result.write(oprot)
7202 
    oprot.writeMessageEnd()
7203 
    oprot.trans.flush()
7204 
 
4018 chandransh 7205 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7206 
    args = getItemWiseRiskyOrdersCount_args()
7207 
    args.read(iprot)
7208 
    iprot.readMessageEnd()
7209 
    result = getItemWiseRiskyOrdersCount_result()
7210 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7211 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7212 
    result.write(oprot)
7213 
    oprot.writeMessageEnd()
7214 
    oprot.trans.flush()
4008 mandeep.dh 7215 
 
4295 varun.gupt 7216 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7217 
    args = getOrdersForItemIds_args()
7218 
    args.read(iprot)
7219 
    iprot.readMessageEnd()
7220 
    result = getOrdersForItemIds_result()
7221 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7222 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7223 
    result.write(oprot)
7224 
    oprot.writeMessageEnd()
7225 
    oprot.trans.flush()
7226 
 
4247 rajveer 7227 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7228 
    args = markOrderCancellationRequestReceived_args()
7229 
    args.read(iprot)
7230 
    iprot.readMessageEnd()
7231 
    result = markOrderCancellationRequestReceived_result()
7232 
    try:
7233 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7234 
    except TransactionServiceException, ex:
7235 
      result.ex = ex
7236 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7237 
    result.write(oprot)
7238 
    oprot.writeMessageEnd()
7239 
    oprot.trans.flush()
4018 chandransh 7240 
 
4247 rajveer 7241 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7242 
    args = markOrderCancellationRequestConfirmed_args()
7243 
    args.read(iprot)
7244 
    iprot.readMessageEnd()
7245 
    result = markOrderCancellationRequestConfirmed_result()
7246 
    try:
7247 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7248 
    except TransactionServiceException, ex:
7249 
      result.ex = ex
7250 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7251 
    result.write(oprot)
7252 
    oprot.writeMessageEnd()
7253 
    oprot.trans.flush()
7254 
 
7255 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7256 
    args = markOrderCancellationRequestDenied_args()
7257 
    args.read(iprot)
7258 
    iprot.readMessageEnd()
7259 
    result = markOrderCancellationRequestDenied_result()
7260 
    try:
7261 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7262 
    except TransactionServiceException, ex:
7263 
      result.ex = ex
7264 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7265 
    result.write(oprot)
7266 
    oprot.writeMessageEnd()
7267 
    oprot.trans.flush()
7268 
 
4258 rajveer 7269 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7270 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7271 
    args.read(iprot)
7272 
    iprot.readMessageEnd()
4258 rajveer 7273 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7274 
    try:
4258 rajveer 7275 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7276 
    except TransactionServiceException, ex:
7277 
      result.ex = ex
4258 rajveer 7278 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7279 
    result.write(oprot)
7280 
    oprot.writeMessageEnd()
7281 
    oprot.trans.flush()
7282 
 
4259 anupam.sin 7283 
  def process_refundTransaction(self, seqid, iprot, oprot):
7284 
    args = refundTransaction_args()
7285 
    args.read(iprot)
7286 
    iprot.readMessageEnd()
7287 
    result = refundTransaction_result()
7288 
    try:
7289 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7290 
    except TransactionServiceException, ex:
7291 
      result.ex = ex
7292 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7293 
    result.write(oprot)
7294 
    oprot.writeMessageEnd()
7295 
    oprot.trans.flush()
4247 rajveer 7296 
 
4324 mandeep.dh 7297 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7298 
    args = updateShipmentAddress_args()
7299 
    args.read(iprot)
7300 
    iprot.readMessageEnd()
7301 
    result = updateShipmentAddress_result()
7302 
    try:
7303 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7304 
    except TransactionServiceException, ex:
7305 
      result.ex = ex
7306 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7307 
    result.write(oprot)
7308 
    oprot.writeMessageEnd()
7309 
    oprot.trans.flush()
7310 
 
4285 rajveer 7311 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7312 
    args = acceptOrdersForItemId_args()
7313 
    args.read(iprot)
7314 
    iprot.readMessageEnd()
7315 
    result = acceptOrdersForItemId_result()
7316 
    try:
7317 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7318 
    except TransactionServiceException, ex:
7319 
      result.ex = ex
7320 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7321 
    result.write(oprot)
7322 
    oprot.writeMessageEnd()
7323 
    oprot.trans.flush()
4259 anupam.sin 7324 
 
4303 rajveer 7325 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7326 
    args = markOrdersAsPORaised_args()
7327 
    args.read(iprot)
7328 
    iprot.readMessageEnd()
7329 
    result = markOrdersAsPORaised_result()
7330 
    try:
4369 rajveer 7331 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7332 
    except TransactionServiceException, ex:
7333 
      result.ex = ex
7334 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7335 
    result.write(oprot)
7336 
    oprot.writeMessageEnd()
7337 
    oprot.trans.flush()
4285 rajveer 7338 
 
4303 rajveer 7339 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7340 
    args = markOrdersAsReversalInitiated_args()
7341 
    args.read(iprot)
7342 
    iprot.readMessageEnd()
7343 
    result = markOrdersAsReversalInitiated_result()
7344 
    try:
4369 rajveer 7345 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7346 
    except TransactionServiceException, ex:
7347 
      result.ex = ex
7348 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7349 
    result.write(oprot)
7350 
    oprot.writeMessageEnd()
7351 
    oprot.trans.flush()
7352 
 
7353 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7354 
    args = markOrdersAsNotAvailabke_args()
7355 
    args.read(iprot)
7356 
    iprot.readMessageEnd()
7357 
    result = markOrdersAsNotAvailabke_result()
7358 
    try:
4369 rajveer 7359 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7360 
    except TransactionServiceException, ex:
7361 
      result.ex = ex
7362 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7363 
    result.write(oprot)
7364 
    oprot.writeMessageEnd()
7365 
    oprot.trans.flush()
7366 
 
4369 rajveer 7367 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7368 
    args = markOrdersAsTimeout_args()
7369 
    args.read(iprot)
7370 
    iprot.readMessageEnd()
7371 
    result = markOrdersAsTimeout_result()
7372 
    try:
7373 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7374 
    except TransactionServiceException, ex:
7375 
      result.ex = ex
7376 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7377 
    result.write(oprot)
7378 
    oprot.writeMessageEnd()
7379 
    oprot.trans.flush()
4303 rajveer 7380 
 
4662 rajveer 7381 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7382 
    args = markOrderAsLostInTransit_args()
7383 
    args.read(iprot)
7384 
    iprot.readMessageEnd()
7385 
    result = markOrderAsLostInTransit_result()
7386 
    try:
7387 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7388 
    except TransactionServiceException, ex:
7389 
      result.ex = ex
7390 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7391 
    result.write(oprot)
7392 
    oprot.writeMessageEnd()
7393 
    oprot.trans.flush()
7394 
 
4386 anupam.sin 7395 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7396 
    args = getOrderForAwb_args()
7397 
    args.read(iprot)
7398 
    iprot.readMessageEnd()
7399 
    result = getOrderForAwb_result()
7400 
    try:
7401 
      result.success = self._handler.getOrderForAwb(args.awb)
7402 
    except TransactionServiceException, ex:
7403 
      result.ex = ex
7404 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7405 
    result.write(oprot)
7406 
    oprot.writeMessageEnd()
7407 
    oprot.trans.flush()
4369 rajveer 7408 
 
4506 phani.kuma 7409 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7410 
    args = getOrdersForProviderForStatus_args()
7411 
    args.read(iprot)
7412 
    iprot.readMessageEnd()
7413 
    result = getOrdersForProviderForStatus_result()
7414 
    try:
4910 phani.kuma 7415 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7416 
    except TransactionServiceException, ex:
7417 
      result.ex = ex
7418 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7419 
    result.write(oprot)
7420 
    oprot.writeMessageEnd()
7421 
    oprot.trans.flush()
4386 anupam.sin 7422 
 
4600 varun.gupt 7423 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7424 
    args = getBilledOrdersForVendor_args()
7425 
    args.read(iprot)
7426 
    iprot.readMessageEnd()
7427 
    result = getBilledOrdersForVendor_result()
7428 
    try:
7429 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7430 
    except TransactionServiceException, ex:
7431 
      result.ex = ex
7432 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7433 
    result.write(oprot)
7434 
    oprot.writeMessageEnd()
7435 
    oprot.trans.flush()
4506 phani.kuma 7436 
 
4607 rajveer 7437 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7438 
    args = getSlippedSippingDateOrders_args()
7439 
    args.read(iprot)
7440 
    iprot.readMessageEnd()
7441 
    result = getSlippedSippingDateOrders_result()
7442 
    try:
7443 
      result.success = self._handler.getSlippedSippingDateOrders()
7444 
    except TransactionServiceException, ex:
7445 
      result.ex = ex
7446 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7447 
    result.write(oprot)
7448 
    oprot.writeMessageEnd()
7449 
    oprot.trans.flush()
7450 
 
4709 rajveer 7451 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7452 
    args = getCancelledOrders_args()
7453 
    args.read(iprot)
7454 
    iprot.readMessageEnd()
7455 
    result = getCancelledOrders_result()
7456 
    try:
7457 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7458 
    except TransactionServiceException, ex:
7459 
      result.ex = ex
7460 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7461 
    result.write(oprot)
7462 
    oprot.writeMessageEnd()
7463 
    oprot.trans.flush()
7464 
 
4600 varun.gupt 7465 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7466 
    args = saveBluedartSettlements_args()
7467 
    args.read(iprot)
7468 
    iprot.readMessageEnd()
7469 
    result = saveBluedartSettlements_result()
7470 
    try:
7471 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7472 
    except TransactionServiceException, ex:
7473 
      result.ex = ex
7474 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7475 
    result.write(oprot)
7476 
    oprot.writeMessageEnd()
7477 
    oprot.trans.flush()
7478 
 
7479 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7480 
    args = savePaymentSettlements_args()
7481 
    args.read(iprot)
7482 
    iprot.readMessageEnd()
7483 
    result = savePaymentSettlements_result()
7484 
    try:
4905 varun.gupt 7485 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7486 
    except TransactionServiceException, ex:
7487 
      result.ex = ex
7488 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7489 
    result.write(oprot)
7490 
    oprot.writeMessageEnd()
7491 
    oprot.trans.flush()
7492 
 
7493 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7494 
    args = saveEBSSettlementSummary_args()
7495 
    args.read(iprot)
7496 
    iprot.readMessageEnd()
7497 
    result = saveEBSSettlementSummary_result()
7498 
    try:
7499 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7500 
    except TransactionServiceException, ex:
7501 
      result.ex = ex
7502 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7506 
 
5386 phani.kuma 7507 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7508 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
5386 phani.kuma 7511 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7512 
    try:
5386 phani.kuma 7513 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7514 
    except TransactionServiceException, ex:
7515 
      result.ex = ex
5386 phani.kuma 7516 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
7520 
 
5386 phani.kuma 7521 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7522 
    args = getSettlementForCod_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = getSettlementForCod_result()
7526 
    try:
7527 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
7530 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
4600 varun.gupt 7535 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7536 
    args = getEBSSettlementSummaries_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = getEBSSettlementSummaries_result()
7540 
    try:
7541 
      result.success = self._handler.getEBSSettlementSummaries()
7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
7548 
 
7549 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7550 
    args = markEBSSettlementUploaded_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = markEBSSettlementUploaded_result()
7554 
    try:
7555 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
7563 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7564 
    args = getEBSSettlementDate_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = getEBSSettlementDate_result()
7568 
    try:
7569 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
4715 varun.gupt 7577 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7578 
    args = getSettlementsByDate_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = getSettlementsByDate_result()
7582 
    try:
7583 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7584 
    except TransactionServiceException, ex:
7585 
      result.ex = ex
7586 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
4600 varun.gupt 7590 
 
4715 varun.gupt 7591 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7592 
    args = getReshippedOrderIds_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = getReshippedOrderIds_result()
7596 
    try:
7597 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7598 
    except TransactionServiceException, ex:
7599 
      result.ex = ex
7600 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7601 
    result.write(oprot)
7602 
    oprot.writeMessageEnd()
7603 
    oprot.trans.flush()
7604 
 
5481 phani.kuma 7605 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7606 
    args = getBilledOrders_args()
4875 varun.gupt 7607 
    args.read(iprot)
7608 
    iprot.readMessageEnd()
5481 phani.kuma 7609 
    result = getBilledOrders_result()
4875 varun.gupt 7610 
    try:
5481 phani.kuma 7611 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7612 
    except TransactionServiceException, ex:
7613 
      result.ex = ex
5481 phani.kuma 7614 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7615 
    result.write(oprot)
7616 
    oprot.writeMessageEnd()
7617 
    oprot.trans.flush()
4757 mandeep.dh 7618 
 
5031 varun.gupt 7619 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7620 
    args = getStatusDistributionOfOrders_args()
7621 
    args.read(iprot)
7622 
    iprot.readMessageEnd()
7623 
    result = getStatusDistributionOfOrders_result()
7624 
    try:
7625 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7626 
    except TransactionServiceException, ex:
7627 
      result.ex = ex
7628 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7629 
    result.write(oprot)
7630 
    oprot.writeMessageEnd()
7631 
    oprot.trans.flush()
4875 varun.gupt 7632 
 
5067 varun.gupt 7633 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7634 
    args = getOrderIdsForStatus_args()
7635 
    args.read(iprot)
7636 
    iprot.readMessageEnd()
7637 
    result = getOrderIdsForStatus_result()
7638 
    try:
7639 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7640 
    except TransactionServiceException, ex:
7641 
      result.ex = ex
7642 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7643 
    result.write(oprot)
7644 
    oprot.writeMessageEnd()
7645 
    oprot.trans.flush()
5031 varun.gupt 7646 
 
5348 anupam.sin 7647 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7648 
    args = updateCODAgent_args()
7649 
    args.read(iprot)
7650 
    iprot.readMessageEnd()
7651 
    result = updateCODAgent_result()
7652 
    try:
7653 
      self._handler.updateCODAgent(args.agent, args.orderId)
7654 
    except TransactionServiceException, ex:
7655 
      result.ex = ex
7656 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7657 
    result.write(oprot)
7658 
    oprot.writeMessageEnd()
7659 
    oprot.trans.flush()
7660 
 
5099 varun.gupt 7661 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7662 
    args = updateOrderAsPaidToVendor_args()
7663 
    args.read(iprot)
7664 
    iprot.readMessageEnd()
7665 
    result = updateOrderAsPaidToVendor_result()
7666 
    try:
7667 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7668 
    except TransactionServiceException, ex:
7669 
      result.ex = ex
7670 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7671 
    result.write(oprot)
7672 
    oprot.writeMessageEnd()
7673 
    oprot.trans.flush()
5067 varun.gupt 7674 
 
5386 phani.kuma 7675 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7676 
    args = updateOrderOnlyAsPaidToVendor_args()
7677 
    args.read(iprot)
7678 
    iprot.readMessageEnd()
7679 
    result = updateOrderOnlyAsPaidToVendor_result()
7680 
    try:
7681 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7682 
    except TransactionServiceException, ex:
7683 
      result.ex = ex
7684 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7685 
    result.write(oprot)
7686 
    oprot.writeMessageEnd()
7687 
    oprot.trans.flush()
7688 
 
5208 varun.gupt 7689 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7690 
    args = getRefundedOrdersMarkedPaid_args()
7691 
    args.read(iprot)
7692 
    iprot.readMessageEnd()
7693 
    result = getRefundedOrdersMarkedPaid_result()
7694 
    try:
7695 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7696 
    except TransactionServiceException, ex:
7697 
      result.ex = ex
7698 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7699 
    result.write(oprot)
7700 
    oprot.writeMessageEnd()
7701 
    oprot.trans.flush()
5099 varun.gupt 7702 
 
5447 anupam.sin 7703 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7704 
    args = getAllVerificationAgents_args()
7705 
    args.read(iprot)
7706 
    iprot.readMessageEnd()
7707 
    result = getAllVerificationAgents_result()
7708 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7709 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7710 
    result.write(oprot)
7711 
    oprot.writeMessageEnd()
7712 
    oprot.trans.flush()
5208 varun.gupt 7713 
 
5527 anupam.sin 7714 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7715 
    args = getAllAttributesForOrderId_args()
7716 
    args.read(iprot)
7717 
    iprot.readMessageEnd()
7718 
    result = getAllAttributesForOrderId_result()
7719 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7720 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7721 
    result.write(oprot)
7722 
    oprot.writeMessageEnd()
7723 
    oprot.trans.flush()
5447 anupam.sin 7724 
 
5676 rajveer 7725 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7726 
    args = setOrderAttributes_args()
7727 
    args.read(iprot)
7728 
    iprot.readMessageEnd()
7729 
    result = setOrderAttributes_result()
7730 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7731 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7732 
    result.write(oprot)
7733 
    oprot.writeMessageEnd()
7734 
    oprot.trans.flush()
7735 
 
5527 anupam.sin 7736 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7737 
    args = setOrderAttributeForTransaction_args()
7738 
    args.read(iprot)
7739 
    iprot.readMessageEnd()
7740 
    result = setOrderAttributeForTransaction_result()
7741 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7742 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
7746 
 
5553 rajveer 7747 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7748 
    args = getReceivePendingOrders_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = getReceivePendingOrders_result()
7752 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7753 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
5527 anupam.sin 7757 
 
5553 rajveer 7758 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7759 
    args = getReceivedAtStoreOrders_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = getReceivedAtStoreOrders_result()
7763 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7764 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7765 
    result.write(oprot)
7766 
    oprot.writeMessageEnd()
7767 
    oprot.trans.flush()
7768 
 
5713 rajveer 7769 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7770 
    args = getOrdersCollectionAtStore_args()
7771 
    args.read(iprot)
7772 
    iprot.readMessageEnd()
7773 
    result = getOrdersCollectionAtStore_result()
7774 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7775 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7776 
    result.write(oprot)
7777 
    oprot.writeMessageEnd()
7778 
    oprot.trans.flush()
7779 
 
5833 rajveer 7780 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7781 
    args = getOrderAttributeValue_args()
7782 
    args.read(iprot)
7783 
    iprot.readMessageEnd()
7784 
    result = getOrderAttributeValue_result()
7785 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7786 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7787 
    result.write(oprot)
7788 
    oprot.writeMessageEnd()
7789 
    oprot.trans.flush()
7790 
 
6019 rajveer 7791 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
7792 
    args = changeJacketNumber_args()
7793 
    args.read(iprot)
7794 
    iprot.readMessageEnd()
7795 
    result = changeJacketNumber_result()
7796 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
7797 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
7798 
    result.write(oprot)
7799 
    oprot.writeMessageEnd()
7800 
    oprot.trans.flush()
7801 
 
7802 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
7803 
    args = markOrderAsRtoInTransit_args()
7804 
    args.read(iprot)
7805 
    iprot.readMessageEnd()
7806 
    result = markOrderAsRtoInTransit_result()
7807 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
7808 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
7809 
    result.write(oprot)
7810 
    oprot.writeMessageEnd()
7811 
    oprot.trans.flush()
7812 
 
5593 mandeep.dh 7813 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7814 
    args = acceptOrderForItem_args()
7815 
    args.read(iprot)
7816 
    iprot.readMessageEnd()
7817 
    result = acceptOrderForItem_result()
7818 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7819 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7820 
    result.write(oprot)
7821 
    oprot.writeMessageEnd()
7822 
    oprot.trans.flush()
5553 rajveer 7823 
 
6000 mandeep.dh 7824 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
7825 
    args = createRechargeOrder_args()
7826 
    args.read(iprot)
7827 
    iprot.readMessageEnd()
7828 
    result = createRechargeOrder_result()
7829 
    try:
7830 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
7831 
    except TransactionServiceException, ex:
7832 
      result.ex = ex
7833 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
7834 
    result.write(oprot)
7835 
    oprot.writeMessageEnd()
7836 
    oprot.trans.flush()
5593 mandeep.dh 7837 
 
6031 rajveer 7838 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
7839 
    args = getRechargeOrder_args()
7840 
    args.read(iprot)
7841 
    iprot.readMessageEnd()
7842 
    result = getRechargeOrder_result()
7843 
    try:
7844 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
7845 
    except TransactionServiceException, ex:
7846 
      result.ex = ex
7847 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
7848 
    result.write(oprot)
7849 
    oprot.writeMessageEnd()
7850 
    oprot.trans.flush()
7851 
 
7852 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
7853 
    args = getRechargeOrders_args()
7854 
    args.read(iprot)
7855 
    iprot.readMessageEnd()
7856 
    result = getRechargeOrders_result()
7857 
    result.success = self._handler.getRechargeOrders(args.userId)
7858 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
7859 
    result.write(oprot)
7860 
    oprot.writeMessageEnd()
7861 
    oprot.trans.flush()
7862 
 
6000 mandeep.dh 7863 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
7864 
    args = updateRechargeOrderStatus_args()
7865 
    args.read(iprot)
7866 
    iprot.readMessageEnd()
7867 
    result = updateRechargeOrderStatus_result()
7868 
    try:
6031 rajveer 7869 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 7870 
    except TransactionServiceException, ex:
7871 
      result.ex = ex
7872 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
7873 
    result.write(oprot)
7874 
    oprot.writeMessageEnd()
7875 
    oprot.trans.flush()
7876 
 
7877 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
7878 
    args = activateRechargeTxn_args()
7879 
    args.read(iprot)
7880 
    iprot.readMessageEnd()
7881 
    result = activateRechargeTxn_result()
7882 
    try:
6031 rajveer 7883 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 7884 
    except TransactionServiceException, ex:
7885 
      result.ex = ex
7886 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
7887 
    result.write(oprot)
7888 
    oprot.writeMessageEnd()
7889 
    oprot.trans.flush()
7890 
 
6031 rajveer 7891 
  def process_getUserWallet(self, seqid, iprot, oprot):
7892 
    args = getUserWallet_args()
6000 mandeep.dh 7893 
    args.read(iprot)
7894 
    iprot.readMessageEnd()
6031 rajveer 7895 
    result = getUserWallet_result()
7896 
    result.success = self._handler.getUserWallet(args.userId)
7897 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 7898 
    result.write(oprot)
7899 
    oprot.writeMessageEnd()
7900 
    oprot.trans.flush()
7901 
 
6031 rajveer 7902 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
7903 
    args = getUserWalletHistory_args()
6000 mandeep.dh 7904 
    args.read(iprot)
7905 
    iprot.readMessageEnd()
6031 rajveer 7906 
    result = getUserWalletHistory_result()
7907 
    result.success = self._handler.getUserWalletHistory(args.userId)
7908 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 7909 
    result.write(oprot)
7910 
    oprot.writeMessageEnd()
7911 
    oprot.trans.flush()
7912 
 
7913 
 
94 ashish 7914 
# HELPER FUNCTIONS AND STRUCTURES
7915 
 
7916 
class createTransaction_args:
7917 
  """
7918 
  Attributes:
7919 
   - transaction
7920 
  """
7921 
 
7922 
  thrift_spec = (
7923 
    None, # 0
7924 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7925 
  )
7926 
 
7927 
  def __init__(self, transaction=None,):
7928 
    self.transaction = transaction
7929 
 
7930 
  def read(self, iprot):
7931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7933 
      return
7934 
    iprot.readStructBegin()
7935 
    while True:
7936 
      (fname, ftype, fid) = iprot.readFieldBegin()
7937 
      if ftype == TType.STOP:
7938 
        break
7939 
      if fid == 1:
7940 
        if ftype == TType.STRUCT:
7941 
          self.transaction = Transaction()
7942 
          self.transaction.read(iprot)
7943 
        else:
7944 
          iprot.skip(ftype)
7945 
      else:
7946 
        iprot.skip(ftype)
7947 
      iprot.readFieldEnd()
7948 
    iprot.readStructEnd()
7949 
 
7950 
  def write(self, oprot):
7951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7953 
      return
7954 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7955 
    if self.transaction is not None:
94 ashish 7956 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7957 
      self.transaction.write(oprot)
7958 
      oprot.writeFieldEnd()
7959 
    oprot.writeFieldStop()
7960 
    oprot.writeStructEnd()
7961 
 
3431 rajveer 7962 
  def validate(self):
7963 
    return
7964 
 
7965 
 
94 ashish 7966 
  def __repr__(self):
7967 
    L = ['%s=%r' % (key, value)
7968 
      for key, value in self.__dict__.iteritems()]
7969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7970 
 
7971 
  def __eq__(self, other):
7972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7973 
 
7974 
  def __ne__(self, other):
7975 
    return not (self == other)
7976 
 
7977 
class createTransaction_result:
7978 
  """
7979 
  Attributes:
132 ashish 7980 
   - success
94 ashish 7981 
   - ex
7982 
  """
7983 
 
7984 
  thrift_spec = (
132 ashish 7985 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7987 
  )
7988 
 
132 ashish 7989 
  def __init__(self, success=None, ex=None,):
7990 
    self.success = success
94 ashish 7991 
    self.ex = ex
7992 
 
7993 
  def read(self, iprot):
7994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7996 
      return
7997 
    iprot.readStructBegin()
7998 
    while True:
7999 
      (fname, ftype, fid) = iprot.readFieldBegin()
8000 
      if ftype == TType.STOP:
8001 
        break
132 ashish 8002 
      if fid == 0:
8003 
        if ftype == TType.I64:
8004 
          self.success = iprot.readI64();
8005 
        else:
8006 
          iprot.skip(ftype)
8007 
      elif fid == 1:
94 ashish 8008 
        if ftype == TType.STRUCT:
8009 
          self.ex = TransactionServiceException()
8010 
          self.ex.read(iprot)
8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8023 
    if self.success is not None:
132 ashish 8024 
      oprot.writeFieldBegin('success', TType.I64, 0)
8025 
      oprot.writeI64(self.success)
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ex is not None:
94 ashish 8028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8029 
      self.ex.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
94 ashish 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
8049 
class getTransaction_args:
8050 
  """
8051 
  Attributes:
8052 
   - id
8053 
  """
8054 
 
8055 
  thrift_spec = (
8056 
    None, # 0
8057 
    (1, TType.I64, 'id', None, None, ), # 1
8058 
  )
8059 
 
8060 
  def __init__(self, id=None,):
8061 
    self.id = id
8062 
 
8063 
  def read(self, iprot):
8064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8066 
      return
8067 
    iprot.readStructBegin()
8068 
    while True:
8069 
      (fname, ftype, fid) = iprot.readFieldBegin()
8070 
      if ftype == TType.STOP:
8071 
        break
8072 
      if fid == 1:
8073 
        if ftype == TType.I64:
8074 
          self.id = iprot.readI64();
8075 
        else:
8076 
          iprot.skip(ftype)
8077 
      else:
8078 
        iprot.skip(ftype)
8079 
      iprot.readFieldEnd()
8080 
    iprot.readStructEnd()
8081 
 
8082 
  def write(self, oprot):
8083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8085 
      return
8086 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8087 
    if self.id is not None:
94 ashish 8088 
      oprot.writeFieldBegin('id', TType.I64, 1)
8089 
      oprot.writeI64(self.id)
8090 
      oprot.writeFieldEnd()
8091 
    oprot.writeFieldStop()
8092 
    oprot.writeStructEnd()
8093 
 
3431 rajveer 8094 
  def validate(self):
8095 
    return
8096 
 
8097 
 
94 ashish 8098 
  def __repr__(self):
8099 
    L = ['%s=%r' % (key, value)
8100 
      for key, value in self.__dict__.iteritems()]
8101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8102 
 
8103 
  def __eq__(self, other):
8104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8105 
 
8106 
  def __ne__(self, other):
8107 
    return not (self == other)
8108 
 
8109 
class getTransaction_result:
8110 
  """
8111 
  Attributes:
8112 
   - success
8113 
   - ex
8114 
  """
8115 
 
8116 
  thrift_spec = (
8117 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8119 
  )
8120 
 
8121 
  def __init__(self, success=None, ex=None,):
8122 
    self.success = success
8123 
    self.ex = ex
8124 
 
8125 
  def read(self, iprot):
8126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8128 
      return
8129 
    iprot.readStructBegin()
8130 
    while True:
8131 
      (fname, ftype, fid) = iprot.readFieldBegin()
8132 
      if ftype == TType.STOP:
8133 
        break
8134 
      if fid == 0:
8135 
        if ftype == TType.STRUCT:
8136 
          self.success = Transaction()
8137 
          self.success.read(iprot)
8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      elif fid == 1:
8141 
        if ftype == TType.STRUCT:
8142 
          self.ex = TransactionServiceException()
8143 
          self.ex.read(iprot)
8144 
        else:
8145 
          iprot.skip(ftype)
8146 
      else:
8147 
        iprot.skip(ftype)
8148 
      iprot.readFieldEnd()
8149 
    iprot.readStructEnd()
8150 
 
8151 
  def write(self, oprot):
8152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8154 
      return
8155 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8156 
    if self.success is not None:
94 ashish 8157 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8158 
      self.success.write(oprot)
8159 
      oprot.writeFieldEnd()
3431 rajveer 8160 
    if self.ex is not None:
94 ashish 8161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8162 
      self.ex.write(oprot)
8163 
      oprot.writeFieldEnd()
8164 
    oprot.writeFieldStop()
8165 
    oprot.writeStructEnd()
8166 
 
3431 rajveer 8167 
  def validate(self):
8168 
    return
8169 
 
8170 
 
94 ashish 8171 
  def __repr__(self):
8172 
    L = ['%s=%r' % (key, value)
8173 
      for key, value in self.__dict__.iteritems()]
8174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8175 
 
8176 
  def __eq__(self, other):
8177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8178 
 
8179 
  def __ne__(self, other):
8180 
    return not (self == other)
8181 
 
8182 
class getTransactionsForCustomer_args:
8183 
  """
8184 
  Attributes:
8185 
   - customerId
8186 
   - from_date
8187 
   - to_date
8188 
   - status
8189 
  """
8190 
 
8191 
  thrift_spec = (
8192 
    None, # 0
8193 
    (1, TType.I64, 'customerId', None, None, ), # 1
8194 
    (2, TType.I64, 'from_date', None, None, ), # 2
8195 
    (3, TType.I64, 'to_date', None, None, ), # 3
8196 
    (4, TType.I32, 'status', None, None, ), # 4
8197 
  )
8198 
 
8199 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8200 
    self.customerId = customerId
8201 
    self.from_date = from_date
8202 
    self.to_date = to_date
8203 
    self.status = status
8204 
 
8205 
  def read(self, iprot):
8206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8208 
      return
8209 
    iprot.readStructBegin()
8210 
    while True:
8211 
      (fname, ftype, fid) = iprot.readFieldBegin()
8212 
      if ftype == TType.STOP:
8213 
        break
8214 
      if fid == 1:
8215 
        if ftype == TType.I64:
8216 
          self.customerId = iprot.readI64();
8217 
        else:
8218 
          iprot.skip(ftype)
8219 
      elif fid == 2:
8220 
        if ftype == TType.I64:
8221 
          self.from_date = iprot.readI64();
8222 
        else:
8223 
          iprot.skip(ftype)
8224 
      elif fid == 3:
8225 
        if ftype == TType.I64:
8226 
          self.to_date = iprot.readI64();
8227 
        else:
8228 
          iprot.skip(ftype)
8229 
      elif fid == 4:
8230 
        if ftype == TType.I32:
8231 
          self.status = iprot.readI32();
8232 
        else:
8233 
          iprot.skip(ftype)
8234 
      else:
8235 
        iprot.skip(ftype)
8236 
      iprot.readFieldEnd()
8237 
    iprot.readStructEnd()
8238 
 
8239 
  def write(self, oprot):
8240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8242 
      return
8243 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8244 
    if self.customerId is not None:
94 ashish 8245 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8246 
      oprot.writeI64(self.customerId)
8247 
      oprot.writeFieldEnd()
3431 rajveer 8248 
    if self.from_date is not None:
94 ashish 8249 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8250 
      oprot.writeI64(self.from_date)
8251 
      oprot.writeFieldEnd()
3431 rajveer 8252 
    if self.to_date is not None:
94 ashish 8253 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8254 
      oprot.writeI64(self.to_date)
8255 
      oprot.writeFieldEnd()
3431 rajveer 8256 
    if self.status is not None:
94 ashish 8257 
      oprot.writeFieldBegin('status', TType.I32, 4)
8258 
      oprot.writeI32(self.status)
8259 
      oprot.writeFieldEnd()
8260 
    oprot.writeFieldStop()
8261 
    oprot.writeStructEnd()
8262 
 
3431 rajveer 8263 
  def validate(self):
8264 
    return
8265 
 
8266 
 
94 ashish 8267 
  def __repr__(self):
8268 
    L = ['%s=%r' % (key, value)
8269 
      for key, value in self.__dict__.iteritems()]
8270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8271 
 
8272 
  def __eq__(self, other):
8273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8274 
 
8275 
  def __ne__(self, other):
8276 
    return not (self == other)
8277 
 
8278 
class getTransactionsForCustomer_result:
8279 
  """
8280 
  Attributes:
8281 
   - success
8282 
   - ex
8283 
  """
8284 
 
8285 
  thrift_spec = (
8286 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8288 
  )
8289 
 
8290 
  def __init__(self, success=None, ex=None,):
8291 
    self.success = success
8292 
    self.ex = ex
8293 
 
8294 
  def read(self, iprot):
8295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8297 
      return
8298 
    iprot.readStructBegin()
8299 
    while True:
8300 
      (fname, ftype, fid) = iprot.readFieldBegin()
8301 
      if ftype == TType.STOP:
8302 
        break
8303 
      if fid == 0:
8304 
        if ftype == TType.LIST:
8305 
          self.success = []
6031 rajveer 8306 
          (_etype66, _size63) = iprot.readListBegin()
8307 
          for _i67 in xrange(_size63):
8308 
            _elem68 = Transaction()
8309 
            _elem68.read(iprot)
8310 
            self.success.append(_elem68)
94 ashish 8311 
          iprot.readListEnd()
8312 
        else:
8313 
          iprot.skip(ftype)
8314 
      elif fid == 1:
8315 
        if ftype == TType.STRUCT:
8316 
          self.ex = TransactionServiceException()
8317 
          self.ex.read(iprot)
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
8329 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8330 
    if self.success is not None:
94 ashish 8331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8333 
      for iter69 in self.success:
8334 
        iter69.write(oprot)
94 ashish 8335 
      oprot.writeListEnd()
8336 
      oprot.writeFieldEnd()
3431 rajveer 8337 
    if self.ex is not None:
94 ashish 8338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8339 
      self.ex.write(oprot)
8340 
      oprot.writeFieldEnd()
8341 
    oprot.writeFieldStop()
8342 
    oprot.writeStructEnd()
8343 
 
3431 rajveer 8344 
  def validate(self):
8345 
    return
8346 
 
8347 
 
94 ashish 8348 
  def __repr__(self):
8349 
    L = ['%s=%r' % (key, value)
8350 
      for key, value in self.__dict__.iteritems()]
8351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8352 
 
8353 
  def __eq__(self, other):
8354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8355 
 
8356 
  def __ne__(self, other):
8357 
    return not (self == other)
8358 
 
132 ashish 8359 
class getTransactionsForShoppingCartId_args:
8360 
  """
8361 
  Attributes:
8362 
   - shoppingCartId
8363 
  """
8364 
 
8365 
  thrift_spec = (
8366 
    None, # 0
8367 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8368 
  )
8369 
 
8370 
  def __init__(self, shoppingCartId=None,):
8371 
    self.shoppingCartId = shoppingCartId
8372 
 
8373 
  def read(self, iprot):
8374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8376 
      return
8377 
    iprot.readStructBegin()
8378 
    while True:
8379 
      (fname, ftype, fid) = iprot.readFieldBegin()
8380 
      if ftype == TType.STOP:
8381 
        break
8382 
      if fid == 1:
8383 
        if ftype == TType.I64:
8384 
          self.shoppingCartId = iprot.readI64();
8385 
        else:
8386 
          iprot.skip(ftype)
8387 
      else:
8388 
        iprot.skip(ftype)
8389 
      iprot.readFieldEnd()
8390 
    iprot.readStructEnd()
8391 
 
8392 
  def write(self, oprot):
8393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8395 
      return
8396 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8397 
    if self.shoppingCartId is not None:
132 ashish 8398 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8399 
      oprot.writeI64(self.shoppingCartId)
8400 
      oprot.writeFieldEnd()
8401 
    oprot.writeFieldStop()
8402 
    oprot.writeStructEnd()
8403 
 
3431 rajveer 8404 
  def validate(self):
8405 
    return
8406 
 
8407 
 
132 ashish 8408 
  def __repr__(self):
8409 
    L = ['%s=%r' % (key, value)
8410 
      for key, value in self.__dict__.iteritems()]
8411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8412 
 
8413 
  def __eq__(self, other):
8414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8415 
 
8416 
  def __ne__(self, other):
8417 
    return not (self == other)
8418 
 
8419 
class getTransactionsForShoppingCartId_result:
8420 
  """
8421 
  Attributes:
8422 
   - success
8423 
   - ex
8424 
  """
8425 
 
8426 
  thrift_spec = (
8427 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8429 
  )
8430 
 
8431 
  def __init__(self, success=None, ex=None,):
8432 
    self.success = success
8433 
    self.ex = ex
8434 
 
8435 
  def read(self, iprot):
8436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8438 
      return
8439 
    iprot.readStructBegin()
8440 
    while True:
8441 
      (fname, ftype, fid) = iprot.readFieldBegin()
8442 
      if ftype == TType.STOP:
8443 
        break
8444 
      if fid == 0:
8445 
        if ftype == TType.LIST:
8446 
          self.success = []
6031 rajveer 8447 
          (_etype73, _size70) = iprot.readListBegin()
8448 
          for _i74 in xrange(_size70):
8449 
            _elem75 = Transaction()
8450 
            _elem75.read(iprot)
8451 
            self.success.append(_elem75)
132 ashish 8452 
          iprot.readListEnd()
8453 
        else:
8454 
          iprot.skip(ftype)
8455 
      elif fid == 1:
8456 
        if ftype == TType.STRUCT:
8457 
          self.ex = TransactionServiceException()
8458 
          self.ex.read(iprot)
8459 
        else:
8460 
          iprot.skip(ftype)
8461 
      else:
8462 
        iprot.skip(ftype)
8463 
      iprot.readFieldEnd()
8464 
    iprot.readStructEnd()
8465 
 
8466 
  def write(self, oprot):
8467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8469 
      return
8470 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8471 
    if self.success is not None:
132 ashish 8472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8474 
      for iter76 in self.success:
8475 
        iter76.write(oprot)
132 ashish 8476 
      oprot.writeListEnd()
8477 
      oprot.writeFieldEnd()
3431 rajveer 8478 
    if self.ex is not None:
132 ashish 8479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8480 
      self.ex.write(oprot)
8481 
      oprot.writeFieldEnd()
8482 
    oprot.writeFieldStop()
8483 
    oprot.writeStructEnd()
8484 
 
3431 rajveer 8485 
  def validate(self):
8486 
    return
8487 
 
8488 
 
132 ashish 8489 
  def __repr__(self):
8490 
    L = ['%s=%r' % (key, value)
8491 
      for key, value in self.__dict__.iteritems()]
8492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8493 
 
8494 
  def __eq__(self, other):
8495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8496 
 
8497 
  def __ne__(self, other):
8498 
    return not (self == other)
8499 
 
94 ashish 8500 
class getTransactionStatus_args:
8501 
  """
8502 
  Attributes:
8503 
   - transactionId
8504 
  """
8505 
 
8506 
  thrift_spec = (
8507 
    None, # 0
8508 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8509 
  )
8510 
 
8511 
  def __init__(self, transactionId=None,):
8512 
    self.transactionId = transactionId
8513 
 
8514 
  def read(self, iprot):
8515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8517 
      return
8518 
    iprot.readStructBegin()
8519 
    while True:
8520 
      (fname, ftype, fid) = iprot.readFieldBegin()
8521 
      if ftype == TType.STOP:
8522 
        break
8523 
      if fid == 1:
8524 
        if ftype == TType.I64:
8525 
          self.transactionId = iprot.readI64();
8526 
        else:
8527 
          iprot.skip(ftype)
8528 
      else:
8529 
        iprot.skip(ftype)
8530 
      iprot.readFieldEnd()
8531 
    iprot.readStructEnd()
8532 
 
8533 
  def write(self, oprot):
8534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8536 
      return
8537 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8538 
    if self.transactionId is not None:
94 ashish 8539 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8540 
      oprot.writeI64(self.transactionId)
8541 
      oprot.writeFieldEnd()
8542 
    oprot.writeFieldStop()
8543 
    oprot.writeStructEnd()
8544 
 
3431 rajveer 8545 
  def validate(self):
8546 
    return
8547 
 
8548 
 
94 ashish 8549 
  def __repr__(self):
8550 
    L = ['%s=%r' % (key, value)
8551 
      for key, value in self.__dict__.iteritems()]
8552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8553 
 
8554 
  def __eq__(self, other):
8555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8556 
 
8557 
  def __ne__(self, other):
8558 
    return not (self == other)
8559 
 
8560 
class getTransactionStatus_result:
8561 
  """
8562 
  Attributes:
8563 
   - success
8564 
   - ex
8565 
  """
8566 
 
8567 
  thrift_spec = (
8568 
    (0, TType.I32, 'success', None, None, ), # 0
8569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8570 
  )
8571 
 
8572 
  def __init__(self, success=None, ex=None,):
8573 
    self.success = success
8574 
    self.ex = ex
8575 
 
8576 
  def read(self, iprot):
8577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8579 
      return
8580 
    iprot.readStructBegin()
8581 
    while True:
8582 
      (fname, ftype, fid) = iprot.readFieldBegin()
8583 
      if ftype == TType.STOP:
8584 
        break
8585 
      if fid == 0:
8586 
        if ftype == TType.I32:
8587 
          self.success = iprot.readI32();
8588 
        else:
8589 
          iprot.skip(ftype)
8590 
      elif fid == 1:
8591 
        if ftype == TType.STRUCT:
8592 
          self.ex = TransactionServiceException()
8593 
          self.ex.read(iprot)
8594 
        else:
8595 
          iprot.skip(ftype)
8596 
      else:
8597 
        iprot.skip(ftype)
8598 
      iprot.readFieldEnd()
8599 
    iprot.readStructEnd()
8600 
 
8601 
  def write(self, oprot):
8602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8604 
      return
8605 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8606 
    if self.success is not None:
94 ashish 8607 
      oprot.writeFieldBegin('success', TType.I32, 0)
8608 
      oprot.writeI32(self.success)
8609 
      oprot.writeFieldEnd()
3431 rajveer 8610 
    if self.ex is not None:
94 ashish 8611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8612 
      self.ex.write(oprot)
8613 
      oprot.writeFieldEnd()
8614 
    oprot.writeFieldStop()
8615 
    oprot.writeStructEnd()
8616 
 
3431 rajveer 8617 
  def validate(self):
8618 
    return
8619 
 
8620 
 
94 ashish 8621 
  def __repr__(self):
8622 
    L = ['%s=%r' % (key, value)
8623 
      for key, value in self.__dict__.iteritems()]
8624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8625 
 
8626 
  def __eq__(self, other):
8627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8628 
 
8629 
  def __ne__(self, other):
8630 
    return not (self == other)
8631 
 
8632 
class changeTransactionStatus_args:
8633 
  """
8634 
  Attributes:
8635 
   - transactionId
8636 
   - status
8637 
   - description
5527 anupam.sin 8638 
   - pickUp
8639 
   - orderType
94 ashish 8640 
  """
8641 
 
8642 
  thrift_spec = (
8643 
    None, # 0
8644 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8645 
    (2, TType.I32, 'status', None, None, ), # 2
8646 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8647 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8648 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8649 
  )
8650 
 
5527 anupam.sin 8651 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8652 
    self.transactionId = transactionId
8653 
    self.status = status
8654 
    self.description = description
5527 anupam.sin 8655 
    self.pickUp = pickUp
8656 
    self.orderType = orderType
94 ashish 8657 
 
8658 
  def read(self, iprot):
8659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8661 
      return
8662 
    iprot.readStructBegin()
8663 
    while True:
8664 
      (fname, ftype, fid) = iprot.readFieldBegin()
8665 
      if ftype == TType.STOP:
8666 
        break
8667 
      if fid == 1:
8668 
        if ftype == TType.I64:
8669 
          self.transactionId = iprot.readI64();
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      elif fid == 2:
8673 
        if ftype == TType.I32:
8674 
          self.status = iprot.readI32();
8675 
        else:
8676 
          iprot.skip(ftype)
8677 
      elif fid == 3:
8678 
        if ftype == TType.STRING:
8679 
          self.description = iprot.readString();
8680 
        else:
8681 
          iprot.skip(ftype)
5387 rajveer 8682 
      elif fid == 4:
5527 anupam.sin 8683 
        if ftype == TType.I64:
8684 
          self.pickUp = iprot.readI64();
5387 rajveer 8685 
        else:
8686 
          iprot.skip(ftype)
5527 anupam.sin 8687 
      elif fid == 5:
8688 
        if ftype == TType.I32:
8689 
          self.orderType = iprot.readI32();
8690 
        else:
8691 
          iprot.skip(ftype)
94 ashish 8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
8701 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8702 
    if self.transactionId is not None:
94 ashish 8703 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8704 
      oprot.writeI64(self.transactionId)
8705 
      oprot.writeFieldEnd()
3431 rajveer 8706 
    if self.status is not None:
94 ashish 8707 
      oprot.writeFieldBegin('status', TType.I32, 2)
8708 
      oprot.writeI32(self.status)
8709 
      oprot.writeFieldEnd()
3431 rajveer 8710 
    if self.description is not None:
94 ashish 8711 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8712 
      oprot.writeString(self.description)
8713 
      oprot.writeFieldEnd()
5527 anupam.sin 8714 
    if self.pickUp is not None:
8715 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8716 
      oprot.writeI64(self.pickUp)
5387 rajveer 8717 
      oprot.writeFieldEnd()
5527 anupam.sin 8718 
    if self.orderType is not None:
8719 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8720 
      oprot.writeI32(self.orderType)
8721 
      oprot.writeFieldEnd()
94 ashish 8722 
    oprot.writeFieldStop()
8723 
    oprot.writeStructEnd()
8724 
 
3431 rajveer 8725 
  def validate(self):
8726 
    return
8727 
 
8728 
 
94 ashish 8729 
  def __repr__(self):
8730 
    L = ['%s=%r' % (key, value)
8731 
      for key, value in self.__dict__.iteritems()]
8732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8733 
 
8734 
  def __eq__(self, other):
8735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8736 
 
8737 
  def __ne__(self, other):
8738 
    return not (self == other)
8739 
 
8740 
class changeTransactionStatus_result:
8741 
  """
8742 
  Attributes:
8743 
   - success
8744 
   - ex
8745 
  """
8746 
 
8747 
  thrift_spec = (
8748 
    (0, TType.BOOL, 'success', None, None, ), # 0
8749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8750 
  )
8751 
 
8752 
  def __init__(self, success=None, ex=None,):
8753 
    self.success = success
8754 
    self.ex = ex
8755 
 
8756 
  def read(self, iprot):
8757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8759 
      return
8760 
    iprot.readStructBegin()
8761 
    while True:
8762 
      (fname, ftype, fid) = iprot.readFieldBegin()
8763 
      if ftype == TType.STOP:
8764 
        break
8765 
      if fid == 0:
8766 
        if ftype == TType.BOOL:
8767 
          self.success = iprot.readBool();
8768 
        else:
8769 
          iprot.skip(ftype)
8770 
      elif fid == 1:
8771 
        if ftype == TType.STRUCT:
8772 
          self.ex = TransactionServiceException()
8773 
          self.ex.read(iprot)
8774 
        else:
8775 
          iprot.skip(ftype)
8776 
      else:
8777 
        iprot.skip(ftype)
8778 
      iprot.readFieldEnd()
8779 
    iprot.readStructEnd()
8780 
 
8781 
  def write(self, oprot):
8782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8784 
      return
8785 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8786 
    if self.success is not None:
94 ashish 8787 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8788 
      oprot.writeBool(self.success)
8789 
      oprot.writeFieldEnd()
3431 rajveer 8790 
    if self.ex is not None:
94 ashish 8791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8792 
      self.ex.write(oprot)
8793 
      oprot.writeFieldEnd()
8794 
    oprot.writeFieldStop()
8795 
    oprot.writeStructEnd()
8796 
 
3431 rajveer 8797 
  def validate(self):
8798 
    return
8799 
 
8800 
 
94 ashish 8801 
  def __repr__(self):
8802 
    L = ['%s=%r' % (key, value)
8803 
      for key, value in self.__dict__.iteritems()]
8804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8805 
 
8806 
  def __eq__(self, other):
8807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8808 
 
8809 
  def __ne__(self, other):
8810 
    return not (self == other)
8811 
 
1398 varun.gupt 8812 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8813 
  """
8814 
  Attributes:
8815 
   - transactionId
8816 
  """
8817 
 
8818 
  thrift_spec = (
8819 
    None, # 0
8820 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8821 
  )
8822 
 
8823 
  def __init__(self, transactionId=None,):
8824 
    self.transactionId = transactionId
8825 
 
8826 
  def read(self, iprot):
8827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8829 
      return
8830 
    iprot.readStructBegin()
8831 
    while True:
8832 
      (fname, ftype, fid) = iprot.readFieldBegin()
8833 
      if ftype == TType.STOP:
8834 
        break
8835 
      if fid == 1:
8836 
        if ftype == TType.I64:
8837 
          self.transactionId = iprot.readI64();
8838 
        else:
8839 
          iprot.skip(ftype)
8840 
      else:
8841 
        iprot.skip(ftype)
8842 
      iprot.readFieldEnd()
8843 
    iprot.readStructEnd()
8844 
 
8845 
  def write(self, oprot):
8846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8848 
      return
1398 varun.gupt 8849 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8850 
    if self.transactionId is not None:
1382 varun.gupt 8851 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8852 
      oprot.writeI64(self.transactionId)
8853 
      oprot.writeFieldEnd()
8854 
    oprot.writeFieldStop()
8855 
    oprot.writeStructEnd()
8856 
 
3431 rajveer 8857 
  def validate(self):
8858 
    return
8859 
 
8860 
 
1382 varun.gupt 8861 
  def __repr__(self):
8862 
    L = ['%s=%r' % (key, value)
8863 
      for key, value in self.__dict__.iteritems()]
8864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8865 
 
8866 
  def __eq__(self, other):
8867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8868 
 
8869 
  def __ne__(self, other):
8870 
    return not (self == other)
8871 
 
1398 varun.gupt 8872 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8873 
  """
8874 
  Attributes:
8875 
   - success
8876 
   - ex
8877 
  """
8878 
 
8879 
  thrift_spec = (
8880 
    (0, TType.BOOL, 'success', None, None, ), # 0
8881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8882 
  )
8883 
 
8884 
  def __init__(self, success=None, ex=None,):
8885 
    self.success = success
8886 
    self.ex = ex
8887 
 
8888 
  def read(self, iprot):
8889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8891 
      return
8892 
    iprot.readStructBegin()
8893 
    while True:
8894 
      (fname, ftype, fid) = iprot.readFieldBegin()
8895 
      if ftype == TType.STOP:
8896 
        break
8897 
      if fid == 0:
8898 
        if ftype == TType.BOOL:
8899 
          self.success = iprot.readBool();
8900 
        else:
8901 
          iprot.skip(ftype)
8902 
      elif fid == 1:
8903 
        if ftype == TType.STRUCT:
8904 
          self.ex = TransactionServiceException()
8905 
          self.ex.read(iprot)
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
1398 varun.gupt 8917 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8918 
    if self.success is not None:
1382 varun.gupt 8919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8920 
      oprot.writeBool(self.success)
8921 
      oprot.writeFieldEnd()
3431 rajveer 8922 
    if self.ex is not None:
1382 varun.gupt 8923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8924 
      self.ex.write(oprot)
8925 
      oprot.writeFieldEnd()
8926 
    oprot.writeFieldStop()
8927 
    oprot.writeStructEnd()
8928 
 
3431 rajveer 8929 
  def validate(self):
8930 
    return
8931 
 
8932 
 
1382 varun.gupt 8933 
  def __repr__(self):
8934 
    L = ['%s=%r' % (key, value)
8935 
      for key, value in self.__dict__.iteritems()]
8936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8937 
 
8938 
  def __eq__(self, other):
8939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8940 
 
8941 
  def __ne__(self, other):
8942 
    return not (self == other)
8943 
 
483 rajveer 8944 
class getAllOrders_args:
94 ashish 8945 
  """
8946 
  Attributes:
4801 anupam.sin 8947 
   - statuses
483 rajveer 8948 
   - from_date
8949 
   - to_date
8950 
   - warehouse_id
94 ashish 8951 
  """
8952 
 
8953 
  thrift_spec = (
8954 
    None, # 0
4801 anupam.sin 8955 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8956 
    (2, TType.I64, 'from_date', None, None, ), # 2
8957 
    (3, TType.I64, 'to_date', None, None, ), # 3
8958 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8959 
  )
8960 
 
4801 anupam.sin 8961 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8962 
    self.statuses = statuses
483 rajveer 8963 
    self.from_date = from_date
8964 
    self.to_date = to_date
8965 
    self.warehouse_id = warehouse_id
94 ashish 8966 
 
8967 
  def read(self, iprot):
8968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8970 
      return
8971 
    iprot.readStructBegin()
8972 
    while True:
8973 
      (fname, ftype, fid) = iprot.readFieldBegin()
8974 
      if ftype == TType.STOP:
8975 
        break
8976 
      if fid == 1:
4801 anupam.sin 8977 
        if ftype == TType.LIST:
8978 
          self.statuses = []
6031 rajveer 8979 
          (_etype80, _size77) = iprot.readListBegin()
8980 
          for _i81 in xrange(_size77):
8981 
            _elem82 = iprot.readI32();
8982 
            self.statuses.append(_elem82)
4801 anupam.sin 8983 
          iprot.readListEnd()
94 ashish 8984 
        else:
8985 
          iprot.skip(ftype)
483 rajveer 8986 
      elif fid == 2:
8987 
        if ftype == TType.I64:
8988 
          self.from_date = iprot.readI64();
94 ashish 8989 
        else:
8990 
          iprot.skip(ftype)
483 rajveer 8991 
      elif fid == 3:
8992 
        if ftype == TType.I64:
8993 
          self.to_date = iprot.readI64();
94 ashish 8994 
        else:
8995 
          iprot.skip(ftype)
483 rajveer 8996 
      elif fid == 4:
94 ashish 8997 
        if ftype == TType.I64:
483 rajveer 8998 
          self.warehouse_id = iprot.readI64();
94 ashish 8999 
        else:
9000 
          iprot.skip(ftype)
9001 
      else:
9002 
        iprot.skip(ftype)
9003 
      iprot.readFieldEnd()
9004 
    iprot.readStructEnd()
9005 
 
9006 
  def write(self, oprot):
9007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9009 
      return
483 rajveer 9010 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9011 
    if self.statuses is not None:
9012 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9013 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9014 
      for iter83 in self.statuses:
9015 
        oprot.writeI32(iter83)
4801 anupam.sin 9016 
      oprot.writeListEnd()
94 ashish 9017 
      oprot.writeFieldEnd()
3431 rajveer 9018 
    if self.from_date is not None:
483 rajveer 9019 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9020 
      oprot.writeI64(self.from_date)
94 ashish 9021 
      oprot.writeFieldEnd()
3431 rajveer 9022 
    if self.to_date is not None:
483 rajveer 9023 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9024 
      oprot.writeI64(self.to_date)
94 ashish 9025 
      oprot.writeFieldEnd()
3431 rajveer 9026 
    if self.warehouse_id is not None:
483 rajveer 9027 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9028 
      oprot.writeI64(self.warehouse_id)
94 ashish 9029 
      oprot.writeFieldEnd()
9030 
    oprot.writeFieldStop()
9031 
    oprot.writeStructEnd()
9032 
 
3431 rajveer 9033 
  def validate(self):
9034 
    return
9035 
 
9036 
 
94 ashish 9037 
  def __repr__(self):
9038 
    L = ['%s=%r' % (key, value)
9039 
      for key, value in self.__dict__.iteritems()]
9040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9041 
 
9042 
  def __eq__(self, other):
9043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9044 
 
9045 
  def __ne__(self, other):
9046 
    return not (self == other)
9047 
 
483 rajveer 9048 
class getAllOrders_result:
94 ashish 9049 
  """
9050 
  Attributes:
9051 
   - success
9052 
   - ex
9053 
  """
9054 
 
9055 
  thrift_spec = (
483 rajveer 9056 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9058 
  )
9059 
 
9060 
  def __init__(self, success=None, ex=None,):
9061 
    self.success = success
9062 
    self.ex = ex
9063 
 
9064 
  def read(self, iprot):
9065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9067 
      return
9068 
    iprot.readStructBegin()
9069 
    while True:
9070 
      (fname, ftype, fid) = iprot.readFieldBegin()
9071 
      if ftype == TType.STOP:
9072 
        break
9073 
      if fid == 0:
483 rajveer 9074 
        if ftype == TType.LIST:
9075 
          self.success = []
6031 rajveer 9076 
          (_etype87, _size84) = iprot.readListBegin()
9077 
          for _i88 in xrange(_size84):
9078 
            _elem89 = Order()
9079 
            _elem89.read(iprot)
9080 
            self.success.append(_elem89)
483 rajveer 9081 
          iprot.readListEnd()
94 ashish 9082 
        else:
9083 
          iprot.skip(ftype)
9084 
      elif fid == 1:
9085 
        if ftype == TType.STRUCT:
9086 
          self.ex = TransactionServiceException()
9087 
          self.ex.read(iprot)
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
483 rajveer 9099 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9100 
    if self.success is not None:
483 rajveer 9101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9102 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9103 
      for iter90 in self.success:
9104 
        iter90.write(oprot)
483 rajveer 9105 
      oprot.writeListEnd()
94 ashish 9106 
      oprot.writeFieldEnd()
3431 rajveer 9107 
    if self.ex is not None:
94 ashish 9108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9109 
      self.ex.write(oprot)
9110 
      oprot.writeFieldEnd()
9111 
    oprot.writeFieldStop()
9112 
    oprot.writeStructEnd()
9113 
 
3431 rajveer 9114 
  def validate(self):
9115 
    return
9116 
 
9117 
 
94 ashish 9118 
  def __repr__(self):
9119 
    L = ['%s=%r' % (key, value)
9120 
      for key, value in self.__dict__.iteritems()]
9121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9122 
 
9123 
  def __eq__(self, other):
9124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9125 
 
9126 
  def __ne__(self, other):
9127 
    return not (self == other)
9128 
 
4133 chandransh 9129 
class getOrdersInBatch_args:
9130 
  """
9131 
  Attributes:
9132 
   - statuses
9133 
   - offset
9134 
   - limit
9135 
   - warehouse_id
9136 
  """
9137 
 
9138 
  thrift_spec = (
9139 
    None, # 0
9140 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9141 
    (2, TType.I64, 'offset', None, None, ), # 2
9142 
    (3, TType.I64, 'limit', None, None, ), # 3
9143 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9144 
  )
9145 
 
9146 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9147 
    self.statuses = statuses
9148 
    self.offset = offset
9149 
    self.limit = limit
9150 
    self.warehouse_id = warehouse_id
9151 
 
9152 
  def read(self, iprot):
9153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9155 
      return
9156 
    iprot.readStructBegin()
9157 
    while True:
9158 
      (fname, ftype, fid) = iprot.readFieldBegin()
9159 
      if ftype == TType.STOP:
9160 
        break
9161 
      if fid == 1:
9162 
        if ftype == TType.LIST:
9163 
          self.statuses = []
6031 rajveer 9164 
          (_etype94, _size91) = iprot.readListBegin()
9165 
          for _i95 in xrange(_size91):
9166 
            _elem96 = iprot.readI32();
9167 
            self.statuses.append(_elem96)
4133 chandransh 9168 
          iprot.readListEnd()
9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      elif fid == 2:
9172 
        if ftype == TType.I64:
9173 
          self.offset = iprot.readI64();
9174 
        else:
9175 
          iprot.skip(ftype)
9176 
      elif fid == 3:
9177 
        if ftype == TType.I64:
9178 
          self.limit = iprot.readI64();
9179 
        else:
9180 
          iprot.skip(ftype)
9181 
      elif fid == 4:
9182 
        if ftype == TType.I64:
9183 
          self.warehouse_id = iprot.readI64();
9184 
        else:
9185 
          iprot.skip(ftype)
9186 
      else:
9187 
        iprot.skip(ftype)
9188 
      iprot.readFieldEnd()
9189 
    iprot.readStructEnd()
9190 
 
9191 
  def write(self, oprot):
9192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9194 
      return
9195 
    oprot.writeStructBegin('getOrdersInBatch_args')
9196 
    if self.statuses is not None:
9197 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9198 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9199 
      for iter97 in self.statuses:
9200 
        oprot.writeI32(iter97)
4133 chandransh 9201 
      oprot.writeListEnd()
9202 
      oprot.writeFieldEnd()
9203 
    if self.offset is not None:
9204 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9205 
      oprot.writeI64(self.offset)
9206 
      oprot.writeFieldEnd()
9207 
    if self.limit is not None:
9208 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9209 
      oprot.writeI64(self.limit)
9210 
      oprot.writeFieldEnd()
9211 
    if self.warehouse_id is not None:
9212 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9213 
      oprot.writeI64(self.warehouse_id)
9214 
      oprot.writeFieldEnd()
9215 
    oprot.writeFieldStop()
9216 
    oprot.writeStructEnd()
9217 
 
9218 
  def validate(self):
9219 
    return
9220 
 
9221 
 
9222 
  def __repr__(self):
9223 
    L = ['%s=%r' % (key, value)
9224 
      for key, value in self.__dict__.iteritems()]
9225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9226 
 
9227 
  def __eq__(self, other):
9228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9229 
 
9230 
  def __ne__(self, other):
9231 
    return not (self == other)
9232 
 
9233 
class getOrdersInBatch_result:
9234 
  """
9235 
  Attributes:
9236 
   - success
9237 
   - ex
9238 
  """
9239 
 
9240 
  thrift_spec = (
9241 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9242 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9243 
  )
9244 
 
9245 
  def __init__(self, success=None, ex=None,):
9246 
    self.success = success
9247 
    self.ex = ex
9248 
 
9249 
  def read(self, iprot):
9250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9252 
      return
9253 
    iprot.readStructBegin()
9254 
    while True:
9255 
      (fname, ftype, fid) = iprot.readFieldBegin()
9256 
      if ftype == TType.STOP:
9257 
        break
9258 
      if fid == 0:
9259 
        if ftype == TType.LIST:
9260 
          self.success = []
6031 rajveer 9261 
          (_etype101, _size98) = iprot.readListBegin()
9262 
          for _i102 in xrange(_size98):
9263 
            _elem103 = Order()
9264 
            _elem103.read(iprot)
9265 
            self.success.append(_elem103)
4133 chandransh 9266 
          iprot.readListEnd()
9267 
        else:
9268 
          iprot.skip(ftype)
9269 
      elif fid == 1:
9270 
        if ftype == TType.STRUCT:
9271 
          self.ex = TransactionServiceException()
9272 
          self.ex.read(iprot)
9273 
        else:
9274 
          iprot.skip(ftype)
9275 
      else:
9276 
        iprot.skip(ftype)
9277 
      iprot.readFieldEnd()
9278 
    iprot.readStructEnd()
9279 
 
9280 
  def write(self, oprot):
9281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9283 
      return
9284 
    oprot.writeStructBegin('getOrdersInBatch_result')
9285 
    if self.success is not None:
9286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9288 
      for iter104 in self.success:
9289 
        iter104.write(oprot)
4133 chandransh 9290 
      oprot.writeListEnd()
9291 
      oprot.writeFieldEnd()
9292 
    if self.ex is not None:
9293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9294 
      self.ex.write(oprot)
9295 
      oprot.writeFieldEnd()
9296 
    oprot.writeFieldStop()
9297 
    oprot.writeStructEnd()
9298 
 
9299 
  def validate(self):
9300 
    return
9301 
 
9302 
 
9303 
  def __repr__(self):
9304 
    L = ['%s=%r' % (key, value)
9305 
      for key, value in self.__dict__.iteritems()]
9306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9307 
 
9308 
  def __eq__(self, other):
9309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9310 
 
9311 
  def __ne__(self, other):
9312 
    return not (self == other)
9313 
 
9314 
class getOrderCount_args:
9315 
  """
9316 
  Attributes:
9317 
   - statuses
9318 
   - warehouseId
9319 
  """
9320 
 
9321 
  thrift_spec = (
9322 
    None, # 0
9323 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9324 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9325 
  )
9326 
 
9327 
  def __init__(self, statuses=None, warehouseId=None,):
9328 
    self.statuses = statuses
9329 
    self.warehouseId = warehouseId
9330 
 
9331 
  def read(self, iprot):
9332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9334 
      return
9335 
    iprot.readStructBegin()
9336 
    while True:
9337 
      (fname, ftype, fid) = iprot.readFieldBegin()
9338 
      if ftype == TType.STOP:
9339 
        break
9340 
      if fid == 1:
9341 
        if ftype == TType.LIST:
9342 
          self.statuses = []
6031 rajveer 9343 
          (_etype108, _size105) = iprot.readListBegin()
9344 
          for _i109 in xrange(_size105):
9345 
            _elem110 = iprot.readI32();
9346 
            self.statuses.append(_elem110)
4133 chandransh 9347 
          iprot.readListEnd()
9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      elif fid == 2:
9351 
        if ftype == TType.I64:
9352 
          self.warehouseId = iprot.readI64();
9353 
        else:
9354 
          iprot.skip(ftype)
9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('getOrderCount_args')
9365 
    if self.statuses is not None:
9366 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9367 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9368 
      for iter111 in self.statuses:
9369 
        oprot.writeI32(iter111)
4133 chandransh 9370 
      oprot.writeListEnd()
9371 
      oprot.writeFieldEnd()
9372 
    if self.warehouseId is not None:
9373 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9374 
      oprot.writeI64(self.warehouseId)
9375 
      oprot.writeFieldEnd()
9376 
    oprot.writeFieldStop()
9377 
    oprot.writeStructEnd()
9378 
 
9379 
  def validate(self):
9380 
    return
9381 
 
9382 
 
9383 
  def __repr__(self):
9384 
    L = ['%s=%r' % (key, value)
9385 
      for key, value in self.__dict__.iteritems()]
9386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9387 
 
9388 
  def __eq__(self, other):
9389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9390 
 
9391 
  def __ne__(self, other):
9392 
    return not (self == other)
9393 
 
9394 
class getOrderCount_result:
9395 
  """
9396 
  Attributes:
9397 
   - success
9398 
   - ex
9399 
  """
9400 
 
9401 
  thrift_spec = (
9402 
    (0, TType.I32, 'success', None, None, ), # 0
9403 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9404 
  )
9405 
 
9406 
  def __init__(self, success=None, ex=None,):
9407 
    self.success = success
9408 
    self.ex = ex
9409 
 
9410 
  def read(self, iprot):
9411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9413 
      return
9414 
    iprot.readStructBegin()
9415 
    while True:
9416 
      (fname, ftype, fid) = iprot.readFieldBegin()
9417 
      if ftype == TType.STOP:
9418 
        break
9419 
      if fid == 0:
9420 
        if ftype == TType.I32:
9421 
          self.success = iprot.readI32();
9422 
        else:
9423 
          iprot.skip(ftype)
9424 
      elif fid == 1:
9425 
        if ftype == TType.STRUCT:
9426 
          self.ex = TransactionServiceException()
9427 
          self.ex.read(iprot)
9428 
        else:
9429 
          iprot.skip(ftype)
9430 
      else:
9431 
        iprot.skip(ftype)
9432 
      iprot.readFieldEnd()
9433 
    iprot.readStructEnd()
9434 
 
9435 
  def write(self, oprot):
9436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9438 
      return
9439 
    oprot.writeStructBegin('getOrderCount_result')
9440 
    if self.success is not None:
9441 
      oprot.writeFieldBegin('success', TType.I32, 0)
9442 
      oprot.writeI32(self.success)
9443 
      oprot.writeFieldEnd()
9444 
    if self.ex is not None:
9445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9446 
      self.ex.write(oprot)
9447 
      oprot.writeFieldEnd()
9448 
    oprot.writeFieldStop()
9449 
    oprot.writeStructEnd()
9450 
 
9451 
  def validate(self):
9452 
    return
9453 
 
9454 
 
9455 
  def __repr__(self):
9456 
    L = ['%s=%r' % (key, value)
9457 
      for key, value in self.__dict__.iteritems()]
9458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9459 
 
9460 
  def __eq__(self, other):
9461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9462 
 
9463 
  def __ne__(self, other):
9464 
    return not (self == other)
9465 
 
999 varun.gupt 9466 
class getOrdersByBillingDate_args:
9467 
  """
9468 
  Attributes:
9469 
   - status
9470 
   - start_billing_date
9471 
   - end_billing_date
9472 
   - warehouse_id
9473 
  """
9474 
 
9475 
  thrift_spec = (
9476 
    None, # 0
9477 
    (1, TType.I32, 'status', None, None, ), # 1
9478 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9479 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9480 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9481 
  )
9482 
 
9483 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9484 
    self.status = status
9485 
    self.start_billing_date = start_billing_date
9486 
    self.end_billing_date = end_billing_date
9487 
    self.warehouse_id = warehouse_id
9488 
 
9489 
  def read(self, iprot):
9490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9492 
      return
9493 
    iprot.readStructBegin()
9494 
    while True:
9495 
      (fname, ftype, fid) = iprot.readFieldBegin()
9496 
      if ftype == TType.STOP:
9497 
        break
9498 
      if fid == 1:
9499 
        if ftype == TType.I32:
9500 
          self.status = iprot.readI32();
9501 
        else:
9502 
          iprot.skip(ftype)
9503 
      elif fid == 2:
9504 
        if ftype == TType.I64:
9505 
          self.start_billing_date = iprot.readI64();
9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 3:
9509 
        if ftype == TType.I64:
9510 
          self.end_billing_date = iprot.readI64();
9511 
        else:
9512 
          iprot.skip(ftype)
9513 
      elif fid == 4:
9514 
        if ftype == TType.I64:
9515 
          self.warehouse_id = iprot.readI64();
9516 
        else:
9517 
          iprot.skip(ftype)
9518 
      else:
9519 
        iprot.skip(ftype)
9520 
      iprot.readFieldEnd()
9521 
    iprot.readStructEnd()
9522 
 
9523 
  def write(self, oprot):
9524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9526 
      return
9527 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9528 
    if self.status is not None:
999 varun.gupt 9529 
      oprot.writeFieldBegin('status', TType.I32, 1)
9530 
      oprot.writeI32(self.status)
9531 
      oprot.writeFieldEnd()
3431 rajveer 9532 
    if self.start_billing_date is not None:
999 varun.gupt 9533 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9534 
      oprot.writeI64(self.start_billing_date)
9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.end_billing_date is not None:
999 varun.gupt 9537 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9538 
      oprot.writeI64(self.end_billing_date)
9539 
      oprot.writeFieldEnd()
3431 rajveer 9540 
    if self.warehouse_id is not None:
999 varun.gupt 9541 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9542 
      oprot.writeI64(self.warehouse_id)
9543 
      oprot.writeFieldEnd()
9544 
    oprot.writeFieldStop()
9545 
    oprot.writeStructEnd()
9546 
 
3431 rajveer 9547 
  def validate(self):
9548 
    return
9549 
 
9550 
 
999 varun.gupt 9551 
  def __repr__(self):
9552 
    L = ['%s=%r' % (key, value)
9553 
      for key, value in self.__dict__.iteritems()]
9554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9555 
 
9556 
  def __eq__(self, other):
9557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9558 
 
9559 
  def __ne__(self, other):
9560 
    return not (self == other)
9561 
 
9562 
class getOrdersByBillingDate_result:
9563 
  """
9564 
  Attributes:
9565 
   - success
9566 
   - ex
9567 
  """
9568 
 
9569 
  thrift_spec = (
9570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9572 
  )
9573 
 
9574 
  def __init__(self, success=None, ex=None,):
9575 
    self.success = success
9576 
    self.ex = ex
9577 
 
9578 
  def read(self, iprot):
9579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9581 
      return
9582 
    iprot.readStructBegin()
9583 
    while True:
9584 
      (fname, ftype, fid) = iprot.readFieldBegin()
9585 
      if ftype == TType.STOP:
9586 
        break
9587 
      if fid == 0:
9588 
        if ftype == TType.LIST:
9589 
          self.success = []
6031 rajveer 9590 
          (_etype115, _size112) = iprot.readListBegin()
9591 
          for _i116 in xrange(_size112):
9592 
            _elem117 = Order()
9593 
            _elem117.read(iprot)
9594 
            self.success.append(_elem117)
999 varun.gupt 9595 
          iprot.readListEnd()
9596 
        else:
9597 
          iprot.skip(ftype)
9598 
      elif fid == 1:
9599 
        if ftype == TType.STRUCT:
9600 
          self.ex = TransactionServiceException()
9601 
          self.ex.read(iprot)
9602 
        else:
9603 
          iprot.skip(ftype)
9604 
      else:
9605 
        iprot.skip(ftype)
9606 
      iprot.readFieldEnd()
9607 
    iprot.readStructEnd()
9608 
 
9609 
  def write(self, oprot):
9610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9612 
      return
9613 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9614 
    if self.success is not None:
999 varun.gupt 9615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9617 
      for iter118 in self.success:
9618 
        iter118.write(oprot)
999 varun.gupt 9619 
      oprot.writeListEnd()
9620 
      oprot.writeFieldEnd()
3431 rajveer 9621 
    if self.ex is not None:
999 varun.gupt 9622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9623 
      self.ex.write(oprot)
9624 
      oprot.writeFieldEnd()
9625 
    oprot.writeFieldStop()
9626 
    oprot.writeStructEnd()
9627 
 
3431 rajveer 9628 
  def validate(self):
9629 
    return
9630 
 
9631 
 
999 varun.gupt 9632 
  def __repr__(self):
9633 
    L = ['%s=%r' % (key, value)
9634 
      for key, value in self.__dict__.iteritems()]
9635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9636 
 
9637 
  def __eq__(self, other):
9638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9639 
 
9640 
  def __ne__(self, other):
9641 
    return not (self == other)
9642 
 
3427 chandransh 9643 
class getOrdersByShippingDate_args:
9644 
  """
9645 
  Attributes:
9646 
   - fromShippingDate
9647 
   - toShippingDate
9648 
   - providerId
9649 
   - warehouseId
3451 chandransh 9650 
   - cod
3427 chandransh 9651 
  """
9652 
 
9653 
  thrift_spec = (
9654 
    None, # 0
9655 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9656 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9657 
    (3, TType.I64, 'providerId', None, None, ), # 3
9658 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9659 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9660 
  )
9661 
 
3451 chandransh 9662 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9663 
    self.fromShippingDate = fromShippingDate
9664 
    self.toShippingDate = toShippingDate
9665 
    self.providerId = providerId
9666 
    self.warehouseId = warehouseId
3451 chandransh 9667 
    self.cod = cod
3427 chandransh 9668 
 
9669 
  def read(self, iprot):
9670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9672 
      return
9673 
    iprot.readStructBegin()
9674 
    while True:
9675 
      (fname, ftype, fid) = iprot.readFieldBegin()
9676 
      if ftype == TType.STOP:
9677 
        break
9678 
      if fid == 1:
9679 
        if ftype == TType.I64:
9680 
          self.fromShippingDate = iprot.readI64();
9681 
        else:
9682 
          iprot.skip(ftype)
9683 
      elif fid == 2:
9684 
        if ftype == TType.I64:
9685 
          self.toShippingDate = iprot.readI64();
9686 
        else:
9687 
          iprot.skip(ftype)
9688 
      elif fid == 3:
9689 
        if ftype == TType.I64:
9690 
          self.providerId = iprot.readI64();
9691 
        else:
9692 
          iprot.skip(ftype)
9693 
      elif fid == 4:
9694 
        if ftype == TType.I64:
9695 
          self.warehouseId = iprot.readI64();
9696 
        else:
9697 
          iprot.skip(ftype)
3451 chandransh 9698 
      elif fid == 5:
9699 
        if ftype == TType.BOOL:
9700 
          self.cod = iprot.readBool();
9701 
        else:
9702 
          iprot.skip(ftype)
3427 chandransh 9703 
      else:
9704 
        iprot.skip(ftype)
9705 
      iprot.readFieldEnd()
9706 
    iprot.readStructEnd()
9707 
 
9708 
  def write(self, oprot):
9709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9711 
      return
9712 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9713 
    if self.fromShippingDate is not None:
3427 chandransh 9714 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9715 
      oprot.writeI64(self.fromShippingDate)
9716 
      oprot.writeFieldEnd()
3431 rajveer 9717 
    if self.toShippingDate is not None:
3427 chandransh 9718 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9719 
      oprot.writeI64(self.toShippingDate)
9720 
      oprot.writeFieldEnd()
3431 rajveer 9721 
    if self.providerId is not None:
3427 chandransh 9722 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9723 
      oprot.writeI64(self.providerId)
9724 
      oprot.writeFieldEnd()
3431 rajveer 9725 
    if self.warehouseId is not None:
3427 chandransh 9726 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9727 
      oprot.writeI64(self.warehouseId)
9728 
      oprot.writeFieldEnd()
3451 chandransh 9729 
    if self.cod is not None:
9730 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9731 
      oprot.writeBool(self.cod)
9732 
      oprot.writeFieldEnd()
3427 chandransh 9733 
    oprot.writeFieldStop()
9734 
    oprot.writeStructEnd()
9735 
 
3431 rajveer 9736 
  def validate(self):
9737 
    return
9738 
 
9739 
 
3427 chandransh 9740 
  def __repr__(self):
9741 
    L = ['%s=%r' % (key, value)
9742 
      for key, value in self.__dict__.iteritems()]
9743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9744 
 
9745 
  def __eq__(self, other):
9746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9747 
 
9748 
  def __ne__(self, other):
9749 
    return not (self == other)
9750 
 
9751 
class getOrdersByShippingDate_result:
9752 
  """
9753 
  Attributes:
9754 
   - success
9755 
   - ex
9756 
  """
9757 
 
9758 
  thrift_spec = (
9759 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9761 
  )
9762 
 
9763 
  def __init__(self, success=None, ex=None,):
9764 
    self.success = success
9765 
    self.ex = ex
9766 
 
9767 
  def read(self, iprot):
9768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9770 
      return
9771 
    iprot.readStructBegin()
9772 
    while True:
9773 
      (fname, ftype, fid) = iprot.readFieldBegin()
9774 
      if ftype == TType.STOP:
9775 
        break
9776 
      if fid == 0:
9777 
        if ftype == TType.LIST:
9778 
          self.success = []
6031 rajveer 9779 
          (_etype122, _size119) = iprot.readListBegin()
9780 
          for _i123 in xrange(_size119):
9781 
            _elem124 = Order()
9782 
            _elem124.read(iprot)
9783 
            self.success.append(_elem124)
3427 chandransh 9784 
          iprot.readListEnd()
9785 
        else:
9786 
          iprot.skip(ftype)
9787 
      elif fid == 1:
9788 
        if ftype == TType.STRUCT:
9789 
          self.ex = TransactionServiceException()
9790 
          self.ex.read(iprot)
9791 
        else:
9792 
          iprot.skip(ftype)
9793 
      else:
9794 
        iprot.skip(ftype)
9795 
      iprot.readFieldEnd()
9796 
    iprot.readStructEnd()
9797 
 
9798 
  def write(self, oprot):
9799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9801 
      return
9802 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9803 
    if self.success is not None:
3427 chandransh 9804 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9805 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9806 
      for iter125 in self.success:
9807 
        iter125.write(oprot)
3427 chandransh 9808 
      oprot.writeListEnd()
9809 
      oprot.writeFieldEnd()
3431 rajveer 9810 
    if self.ex is not None:
3427 chandransh 9811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9812 
      self.ex.write(oprot)
9813 
      oprot.writeFieldEnd()
9814 
    oprot.writeFieldStop()
9815 
    oprot.writeStructEnd()
9816 
 
3431 rajveer 9817 
  def validate(self):
9818 
    return
9819 
 
9820 
 
3427 chandransh 9821 
  def __repr__(self):
9822 
    L = ['%s=%r' % (key, value)
9823 
      for key, value in self.__dict__.iteritems()]
9824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9825 
 
9826 
  def __eq__(self, other):
9827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9828 
 
9829 
  def __ne__(self, other):
9830 
    return not (self == other)
9831 
 
1382 varun.gupt 9832 
class getReturnableOrdersForCustomer_args:
9833 
  """
9834 
  Attributes:
9835 
   - customer_id
9836 
   - limit
9837 
  """
9838 
 
9839 
  thrift_spec = (
9840 
    None, # 0
9841 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9842 
    (2, TType.I64, 'limit', None, None, ), # 2
9843 
  )
9844 
 
9845 
  def __init__(self, customer_id=None, limit=None,):
9846 
    self.customer_id = customer_id
9847 
    self.limit = limit
9848 
 
9849 
  def read(self, iprot):
9850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9852 
      return
9853 
    iprot.readStructBegin()
9854 
    while True:
9855 
      (fname, ftype, fid) = iprot.readFieldBegin()
9856 
      if ftype == TType.STOP:
9857 
        break
9858 
      if fid == 1:
9859 
        if ftype == TType.I64:
9860 
          self.customer_id = iprot.readI64();
9861 
        else:
9862 
          iprot.skip(ftype)
9863 
      elif fid == 2:
9864 
        if ftype == TType.I64:
9865 
          self.limit = iprot.readI64();
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      else:
9869 
        iprot.skip(ftype)
9870 
      iprot.readFieldEnd()
9871 
    iprot.readStructEnd()
9872 
 
9873 
  def write(self, oprot):
9874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9876 
      return
9877 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9878 
    if self.customer_id is not None:
1382 varun.gupt 9879 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9880 
      oprot.writeI64(self.customer_id)
9881 
      oprot.writeFieldEnd()
3431 rajveer 9882 
    if self.limit is not None:
1382 varun.gupt 9883 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9884 
      oprot.writeI64(self.limit)
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
3431 rajveer 9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
1382 varun.gupt 9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
9904 
class getReturnableOrdersForCustomer_result:
9905 
  """
9906 
  Attributes:
9907 
   - success
9908 
   - ex
9909 
  """
9910 
 
9911 
  thrift_spec = (
9912 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9914 
  )
9915 
 
9916 
  def __init__(self, success=None, ex=None,):
9917 
    self.success = success
9918 
    self.ex = ex
9919 
 
9920 
  def read(self, iprot):
9921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9923 
      return
9924 
    iprot.readStructBegin()
9925 
    while True:
9926 
      (fname, ftype, fid) = iprot.readFieldBegin()
9927 
      if ftype == TType.STOP:
9928 
        break
9929 
      if fid == 0:
9930 
        if ftype == TType.LIST:
9931 
          self.success = []
6031 rajveer 9932 
          (_etype129, _size126) = iprot.readListBegin()
9933 
          for _i130 in xrange(_size126):
9934 
            _elem131 = iprot.readI64();
9935 
            self.success.append(_elem131)
1382 varun.gupt 9936 
          iprot.readListEnd()
9937 
        else:
9938 
          iprot.skip(ftype)
9939 
      elif fid == 1:
9940 
        if ftype == TType.STRUCT:
9941 
          self.ex = TransactionServiceException()
9942 
          self.ex.read(iprot)
9943 
        else:
9944 
          iprot.skip(ftype)
9945 
      else:
9946 
        iprot.skip(ftype)
9947 
      iprot.readFieldEnd()
9948 
    iprot.readStructEnd()
9949 
 
9950 
  def write(self, oprot):
9951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9953 
      return
9954 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9955 
    if self.success is not None:
1382 varun.gupt 9956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9957 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 9958 
      for iter132 in self.success:
9959 
        oprot.writeI64(iter132)
1382 varun.gupt 9960 
      oprot.writeListEnd()
9961 
      oprot.writeFieldEnd()
3431 rajveer 9962 
    if self.ex is not None:
1382 varun.gupt 9963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9964 
      self.ex.write(oprot)
9965 
      oprot.writeFieldEnd()
9966 
    oprot.writeFieldStop()
9967 
    oprot.writeStructEnd()
9968 
 
3431 rajveer 9969 
  def validate(self):
9970 
    return
9971 
 
9972 
 
1382 varun.gupt 9973 
  def __repr__(self):
9974 
    L = ['%s=%r' % (key, value)
9975 
      for key, value in self.__dict__.iteritems()]
9976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9977 
 
9978 
  def __eq__(self, other):
9979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9980 
 
9981 
  def __ne__(self, other):
9982 
    return not (self == other)
9983 
 
9984 
class getCancellableOrdersForCustomer_args:
9985 
  """
9986 
  Attributes:
9987 
   - customer_id
9988 
   - limit
9989 
  """
9990 
 
9991 
  thrift_spec = (
9992 
    None, # 0
9993 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9994 
    (2, TType.I64, 'limit', None, None, ), # 2
9995 
  )
9996 
 
9997 
  def __init__(self, customer_id=None, limit=None,):
9998 
    self.customer_id = customer_id
9999 
    self.limit = limit
10000 
 
10001 
  def read(self, iprot):
10002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10004 
      return
10005 
    iprot.readStructBegin()
10006 
    while True:
10007 
      (fname, ftype, fid) = iprot.readFieldBegin()
10008 
      if ftype == TType.STOP:
10009 
        break
10010 
      if fid == 1:
10011 
        if ftype == TType.I64:
10012 
          self.customer_id = iprot.readI64();
10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      elif fid == 2:
10016 
        if ftype == TType.I64:
10017 
          self.limit = iprot.readI64();
10018 
        else:
10019 
          iprot.skip(ftype)
10020 
      else:
10021 
        iprot.skip(ftype)
10022 
      iprot.readFieldEnd()
10023 
    iprot.readStructEnd()
10024 
 
10025 
  def write(self, oprot):
10026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10028 
      return
10029 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10030 
    if self.customer_id is not None:
1382 varun.gupt 10031 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10032 
      oprot.writeI64(self.customer_id)
10033 
      oprot.writeFieldEnd()
3431 rajveer 10034 
    if self.limit is not None:
1382 varun.gupt 10035 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10036 
      oprot.writeI64(self.limit)
10037 
      oprot.writeFieldEnd()
10038 
    oprot.writeFieldStop()
10039 
    oprot.writeStructEnd()
10040 
 
3431 rajveer 10041 
  def validate(self):
10042 
    return
10043 
 
10044 
 
1382 varun.gupt 10045 
  def __repr__(self):
10046 
    L = ['%s=%r' % (key, value)
10047 
      for key, value in self.__dict__.iteritems()]
10048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10049 
 
10050 
  def __eq__(self, other):
10051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10052 
 
10053 
  def __ne__(self, other):
10054 
    return not (self == other)
10055 
 
10056 
class getCancellableOrdersForCustomer_result:
10057 
  """
10058 
  Attributes:
10059 
   - success
10060 
   - ex
10061 
  """
10062 
 
10063 
  thrift_spec = (
10064 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10066 
  )
10067 
 
10068 
  def __init__(self, success=None, ex=None,):
10069 
    self.success = success
10070 
    self.ex = ex
10071 
 
10072 
  def read(self, iprot):
10073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10075 
      return
10076 
    iprot.readStructBegin()
10077 
    while True:
10078 
      (fname, ftype, fid) = iprot.readFieldBegin()
10079 
      if ftype == TType.STOP:
10080 
        break
10081 
      if fid == 0:
10082 
        if ftype == TType.LIST:
10083 
          self.success = []
6031 rajveer 10084 
          (_etype136, _size133) = iprot.readListBegin()
10085 
          for _i137 in xrange(_size133):
10086 
            _elem138 = iprot.readI64();
10087 
            self.success.append(_elem138)
1382 varun.gupt 10088 
          iprot.readListEnd()
10089 
        else:
10090 
          iprot.skip(ftype)
10091 
      elif fid == 1:
10092 
        if ftype == TType.STRUCT:
10093 
          self.ex = TransactionServiceException()
10094 
          self.ex.read(iprot)
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10107 
    if self.success is not None:
1382 varun.gupt 10108 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10109 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10110 
      for iter139 in self.success:
10111 
        oprot.writeI64(iter139)
1382 varun.gupt 10112 
      oprot.writeListEnd()
10113 
      oprot.writeFieldEnd()
3431 rajveer 10114 
    if self.ex is not None:
1382 varun.gupt 10115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10116 
      self.ex.write(oprot)
10117 
      oprot.writeFieldEnd()
10118 
    oprot.writeFieldStop()
10119 
    oprot.writeStructEnd()
10120 
 
3431 rajveer 10121 
  def validate(self):
10122 
    return
10123 
 
10124 
 
1382 varun.gupt 10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
483 rajveer 10136 
class changeOrderStatus_args:
94 ashish 10137 
  """
10138 
  Attributes:
483 rajveer 10139 
   - orderId
10140 
   - status
10141 
   - description
94 ashish 10142 
  """
10143 
 
10144 
  thrift_spec = (
10145 
    None, # 0
483 rajveer 10146 
    (1, TType.I64, 'orderId', None, None, ), # 1
10147 
    (2, TType.I32, 'status', None, None, ), # 2
10148 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10149 
  )
10150 
 
483 rajveer 10151 
  def __init__(self, orderId=None, status=None, description=None,):
10152 
    self.orderId = orderId
10153 
    self.status = status
10154 
    self.description = description
94 ashish 10155 
 
10156 
  def read(self, iprot):
10157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10159 
      return
10160 
    iprot.readStructBegin()
10161 
    while True:
10162 
      (fname, ftype, fid) = iprot.readFieldBegin()
10163 
      if ftype == TType.STOP:
10164 
        break
10165 
      if fid == 1:
10166 
        if ftype == TType.I64:
483 rajveer 10167 
          self.orderId = iprot.readI64();
94 ashish 10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      elif fid == 2:
483 rajveer 10171 
        if ftype == TType.I32:
10172 
          self.status = iprot.readI32();
94 ashish 10173 
        else:
10174 
          iprot.skip(ftype)
483 rajveer 10175 
      elif fid == 3:
10176 
        if ftype == TType.STRING:
10177 
          self.description = iprot.readString();
10178 
        else:
10179 
          iprot.skip(ftype)
94 ashish 10180 
      else:
10181 
        iprot.skip(ftype)
10182 
      iprot.readFieldEnd()
10183 
    iprot.readStructEnd()
10184 
 
10185 
  def write(self, oprot):
10186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10188 
      return
483 rajveer 10189 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10190 
    if self.orderId is not None:
483 rajveer 10191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10192 
      oprot.writeI64(self.orderId)
94 ashish 10193 
      oprot.writeFieldEnd()
3431 rajveer 10194 
    if self.status is not None:
483 rajveer 10195 
      oprot.writeFieldBegin('status', TType.I32, 2)
10196 
      oprot.writeI32(self.status)
94 ashish 10197 
      oprot.writeFieldEnd()
3431 rajveer 10198 
    if self.description is not None:
483 rajveer 10199 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10200 
      oprot.writeString(self.description)
10201 
      oprot.writeFieldEnd()
94 ashish 10202 
    oprot.writeFieldStop()
10203 
    oprot.writeStructEnd()
10204 
 
3431 rajveer 10205 
  def validate(self):
10206 
    return
10207 
 
10208 
 
94 ashish 10209 
  def __repr__(self):
10210 
    L = ['%s=%r' % (key, value)
10211 
      for key, value in self.__dict__.iteritems()]
10212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10213 
 
10214 
  def __eq__(self, other):
10215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10216 
 
10217 
  def __ne__(self, other):
10218 
    return not (self == other)
10219 
 
483 rajveer 10220 
class changeOrderStatus_result:
94 ashish 10221 
  """
10222 
  Attributes:
10223 
   - success
10224 
   - ex
10225 
  """
10226 
 
10227 
  thrift_spec = (
10228 
    (0, TType.BOOL, 'success', None, None, ), # 0
10229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10230 
  )
10231 
 
10232 
  def __init__(self, success=None, ex=None,):
10233 
    self.success = success
10234 
    self.ex = ex
10235 
 
10236 
  def read(self, iprot):
10237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10239 
      return
10240 
    iprot.readStructBegin()
10241 
    while True:
10242 
      (fname, ftype, fid) = iprot.readFieldBegin()
10243 
      if ftype == TType.STOP:
10244 
        break
10245 
      if fid == 0:
10246 
        if ftype == TType.BOOL:
10247 
          self.success = iprot.readBool();
10248 
        else:
10249 
          iprot.skip(ftype)
10250 
      elif fid == 1:
10251 
        if ftype == TType.STRUCT:
10252 
          self.ex = TransactionServiceException()
10253 
          self.ex.read(iprot)
10254 
        else:
10255 
          iprot.skip(ftype)
10256 
      else:
10257 
        iprot.skip(ftype)
10258 
      iprot.readFieldEnd()
10259 
    iprot.readStructEnd()
10260 
 
10261 
  def write(self, oprot):
10262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10264 
      return
483 rajveer 10265 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10266 
    if self.success is not None:
94 ashish 10267 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10268 
      oprot.writeBool(self.success)
10269 
      oprot.writeFieldEnd()
3431 rajveer 10270 
    if self.ex is not None:
94 ashish 10271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10272 
      self.ex.write(oprot)
10273 
      oprot.writeFieldEnd()
10274 
    oprot.writeFieldStop()
10275 
    oprot.writeStructEnd()
10276 
 
3431 rajveer 10277 
  def validate(self):
10278 
    return
10279 
 
10280 
 
94 ashish 10281 
  def __repr__(self):
10282 
    L = ['%s=%r' % (key, value)
10283 
      for key, value in self.__dict__.iteritems()]
10284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10285 
 
10286 
  def __eq__(self, other):
10287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10288 
 
10289 
  def __ne__(self, other):
10290 
    return not (self == other)
10291 
 
3064 chandransh 10292 
class getOrdersForTransaction_args:
494 rajveer 10293 
  """
10294 
  Attributes:
3064 chandransh 10295 
   - transactionId
10296 
   - customerId
494 rajveer 10297 
  """
10298 
 
10299 
  thrift_spec = (
10300 
    None, # 0
3064 chandransh 10301 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10302 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10303 
  )
10304 
 
3064 chandransh 10305 
  def __init__(self, transactionId=None, customerId=None,):
10306 
    self.transactionId = transactionId
10307 
    self.customerId = customerId
494 rajveer 10308 
 
10309 
  def read(self, iprot):
10310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10312 
      return
10313 
    iprot.readStructBegin()
10314 
    while True:
10315 
      (fname, ftype, fid) = iprot.readFieldBegin()
10316 
      if ftype == TType.STOP:
10317 
        break
10318 
      if fid == 1:
10319 
        if ftype == TType.I64:
3064 chandransh 10320 
          self.transactionId = iprot.readI64();
494 rajveer 10321 
        else:
10322 
          iprot.skip(ftype)
10323 
      elif fid == 2:
3064 chandransh 10324 
        if ftype == TType.I64:
10325 
          self.customerId = iprot.readI64();
494 rajveer 10326 
        else:
10327 
          iprot.skip(ftype)
10328 
      else:
10329 
        iprot.skip(ftype)
10330 
      iprot.readFieldEnd()
10331 
    iprot.readStructEnd()
10332 
 
10333 
  def write(self, oprot):
10334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10336 
      return
3064 chandransh 10337 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10338 
    if self.transactionId is not None:
3064 chandransh 10339 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10340 
      oprot.writeI64(self.transactionId)
494 rajveer 10341 
      oprot.writeFieldEnd()
3431 rajveer 10342 
    if self.customerId is not None:
3064 chandransh 10343 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10344 
      oprot.writeI64(self.customerId)
494 rajveer 10345 
      oprot.writeFieldEnd()
10346 
    oprot.writeFieldStop()
10347 
    oprot.writeStructEnd()
10348 
 
3431 rajveer 10349 
  def validate(self):
10350 
    return
10351 
 
10352 
 
494 rajveer 10353 
  def __repr__(self):
10354 
    L = ['%s=%r' % (key, value)
10355 
      for key, value in self.__dict__.iteritems()]
10356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10357 
 
10358 
  def __eq__(self, other):
10359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10360 
 
10361 
  def __ne__(self, other):
10362 
    return not (self == other)
10363 
 
3064 chandransh 10364 
class getOrdersForTransaction_result:
494 rajveer 10365 
  """
10366 
  Attributes:
10367 
   - success
10368 
   - ex
10369 
  """
10370 
 
10371 
  thrift_spec = (
3064 chandransh 10372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10374 
  )
10375 
 
10376 
  def __init__(self, success=None, ex=None,):
10377 
    self.success = success
10378 
    self.ex = ex
10379 
 
10380 
  def read(self, iprot):
10381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10383 
      return
10384 
    iprot.readStructBegin()
10385 
    while True:
10386 
      (fname, ftype, fid) = iprot.readFieldBegin()
10387 
      if ftype == TType.STOP:
10388 
        break
10389 
      if fid == 0:
3064 chandransh 10390 
        if ftype == TType.LIST:
10391 
          self.success = []
6031 rajveer 10392 
          (_etype143, _size140) = iprot.readListBegin()
10393 
          for _i144 in xrange(_size140):
10394 
            _elem145 = Order()
10395 
            _elem145.read(iprot)
10396 
            self.success.append(_elem145)
3064 chandransh 10397 
          iprot.readListEnd()
494 rajveer 10398 
        else:
10399 
          iprot.skip(ftype)
10400 
      elif fid == 1:
10401 
        if ftype == TType.STRUCT:
10402 
          self.ex = TransactionServiceException()
10403 
          self.ex.read(iprot)
10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
3064 chandransh 10415 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10416 
    if self.success is not None:
3064 chandransh 10417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10419 
      for iter146 in self.success:
10420 
        iter146.write(oprot)
3064 chandransh 10421 
      oprot.writeListEnd()
494 rajveer 10422 
      oprot.writeFieldEnd()
3431 rajveer 10423 
    if self.ex is not None:
494 rajveer 10424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10425 
      self.ex.write(oprot)
10426 
      oprot.writeFieldEnd()
10427 
    oprot.writeFieldStop()
10428 
    oprot.writeStructEnd()
10429 
 
3431 rajveer 10430 
  def validate(self):
10431 
    return
10432 
 
10433 
 
494 rajveer 10434 
  def __repr__(self):
10435 
    L = ['%s=%r' % (key, value)
10436 
      for key, value in self.__dict__.iteritems()]
10437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10438 
 
10439 
  def __eq__(self, other):
10440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10441 
 
10442 
  def __ne__(self, other):
10443 
    return not (self == other)
10444 
 
3064 chandransh 10445 
class getOrdersForCustomer_args:
1149 chandransh 10446 
  """
10447 
  Attributes:
3064 chandransh 10448 
   - customerId
10449 
   - from_date
10450 
   - to_date
10451 
   - statuses
1149 chandransh 10452 
  """
10453 
 
10454 
  thrift_spec = (
10455 
    None, # 0
3064 chandransh 10456 
    (1, TType.I64, 'customerId', None, None, ), # 1
10457 
    (2, TType.I64, 'from_date', None, None, ), # 2
10458 
    (3, TType.I64, 'to_date', None, None, ), # 3
10459 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10460 
  )
10461 
 
3064 chandransh 10462 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10463 
    self.customerId = customerId
10464 
    self.from_date = from_date
10465 
    self.to_date = to_date
10466 
    self.statuses = statuses
1149 chandransh 10467 
 
10468 
  def read(self, iprot):
10469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10471 
      return
10472 
    iprot.readStructBegin()
10473 
    while True:
10474 
      (fname, ftype, fid) = iprot.readFieldBegin()
10475 
      if ftype == TType.STOP:
10476 
        break
10477 
      if fid == 1:
10478 
        if ftype == TType.I64:
3064 chandransh 10479 
          self.customerId = iprot.readI64();
1149 chandransh 10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      elif fid == 2:
10483 
        if ftype == TType.I64:
3064 chandransh 10484 
          self.from_date = iprot.readI64();
1149 chandransh 10485 
        else:
10486 
          iprot.skip(ftype)
2783 chandransh 10487 
      elif fid == 3:
10488 
        if ftype == TType.I64:
3064 chandransh 10489 
          self.to_date = iprot.readI64();
2783 chandransh 10490 
        else:
10491 
          iprot.skip(ftype)
10492 
      elif fid == 4:
3064 chandransh 10493 
        if ftype == TType.LIST:
10494 
          self.statuses = []
6031 rajveer 10495 
          (_etype150, _size147) = iprot.readListBegin()
10496 
          for _i151 in xrange(_size147):
10497 
            _elem152 = iprot.readI32();
10498 
            self.statuses.append(_elem152)
3064 chandransh 10499 
          iprot.readListEnd()
2783 chandransh 10500 
        else:
10501 
          iprot.skip(ftype)
1149 chandransh 10502 
      else:
10503 
        iprot.skip(ftype)
10504 
      iprot.readFieldEnd()
10505 
    iprot.readStructEnd()
10506 
 
10507 
  def write(self, oprot):
10508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10510 
      return
3064 chandransh 10511 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10512 
    if self.customerId is not None:
3064 chandransh 10513 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10514 
      oprot.writeI64(self.customerId)
1149 chandransh 10515 
      oprot.writeFieldEnd()
3431 rajveer 10516 
    if self.from_date is not None:
3064 chandransh 10517 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10518 
      oprot.writeI64(self.from_date)
1149 chandransh 10519 
      oprot.writeFieldEnd()
3431 rajveer 10520 
    if self.to_date is not None:
3064 chandransh 10521 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10522 
      oprot.writeI64(self.to_date)
2783 chandransh 10523 
      oprot.writeFieldEnd()
3431 rajveer 10524 
    if self.statuses is not None:
3064 chandransh 10525 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10526 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10527 
      for iter153 in self.statuses:
10528 
        oprot.writeI32(iter153)
3064 chandransh 10529 
      oprot.writeListEnd()
2783 chandransh 10530 
      oprot.writeFieldEnd()
1149 chandransh 10531 
    oprot.writeFieldStop()
10532 
    oprot.writeStructEnd()
10533 
 
3431 rajveer 10534 
  def validate(self):
10535 
    return
10536 
 
10537 
 
1149 chandransh 10538 
  def __repr__(self):
10539 
    L = ['%s=%r' % (key, value)
10540 
      for key, value in self.__dict__.iteritems()]
10541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10542 
 
10543 
  def __eq__(self, other):
10544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10545 
 
10546 
  def __ne__(self, other):
10547 
    return not (self == other)
10548 
 
3064 chandransh 10549 
class getOrdersForCustomer_result:
1149 chandransh 10550 
  """
10551 
  Attributes:
10552 
   - success
10553 
   - ex
10554 
  """
10555 
 
10556 
  thrift_spec = (
3064 chandransh 10557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10559 
  )
10560 
 
10561 
  def __init__(self, success=None, ex=None,):
10562 
    self.success = success
10563 
    self.ex = ex
10564 
 
10565 
  def read(self, iprot):
10566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10568 
      return
10569 
    iprot.readStructBegin()
10570 
    while True:
10571 
      (fname, ftype, fid) = iprot.readFieldBegin()
10572 
      if ftype == TType.STOP:
10573 
        break
10574 
      if fid == 0:
3064 chandransh 10575 
        if ftype == TType.LIST:
10576 
          self.success = []
6031 rajveer 10577 
          (_etype157, _size154) = iprot.readListBegin()
10578 
          for _i158 in xrange(_size154):
10579 
            _elem159 = Order()
10580 
            _elem159.read(iprot)
10581 
            self.success.append(_elem159)
3064 chandransh 10582 
          iprot.readListEnd()
1149 chandransh 10583 
        else:
10584 
          iprot.skip(ftype)
10585 
      elif fid == 1:
10586 
        if ftype == TType.STRUCT:
10587 
          self.ex = TransactionServiceException()
10588 
          self.ex.read(iprot)
10589 
        else:
10590 
          iprot.skip(ftype)
10591 
      else:
10592 
        iprot.skip(ftype)
10593 
      iprot.readFieldEnd()
10594 
    iprot.readStructEnd()
10595 
 
10596 
  def write(self, oprot):
10597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10599 
      return
3064 chandransh 10600 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10601 
    if self.success is not None:
3064 chandransh 10602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10604 
      for iter160 in self.success:
10605 
        iter160.write(oprot)
3064 chandransh 10606 
      oprot.writeListEnd()
1149 chandransh 10607 
      oprot.writeFieldEnd()
3431 rajveer 10608 
    if self.ex is not None:
1149 chandransh 10609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10610 
      self.ex.write(oprot)
10611 
      oprot.writeFieldEnd()
10612 
    oprot.writeFieldStop()
10613 
    oprot.writeStructEnd()
10614 
 
3431 rajveer 10615 
  def validate(self):
10616 
    return
10617 
 
10618 
 
1149 chandransh 10619 
  def __repr__(self):
10620 
    L = ['%s=%r' % (key, value)
10621 
      for key, value in self.__dict__.iteritems()]
10622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10623 
 
10624 
  def __eq__(self, other):
10625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10626 
 
10627 
  def __ne__(self, other):
10628 
    return not (self == other)
10629 
 
3064 chandransh 10630 
class createOrder_args:
921 rajveer 10631 
  """
10632 
  Attributes:
3064 chandransh 10633 
   - order
921 rajveer 10634 
  """
10635 
 
10636 
  thrift_spec = (
10637 
    None, # 0
3064 chandransh 10638 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10639 
  )
10640 
 
3064 chandransh 10641 
  def __init__(self, order=None,):
10642 
    self.order = order
921 rajveer 10643 
 
10644 
  def read(self, iprot):
10645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10647 
      return
10648 
    iprot.readStructBegin()
10649 
    while True:
10650 
      (fname, ftype, fid) = iprot.readFieldBegin()
10651 
      if ftype == TType.STOP:
10652 
        break
10653 
      if fid == 1:
3064 chandransh 10654 
        if ftype == TType.STRUCT:
10655 
          self.order = Order()
10656 
          self.order.read(iprot)
921 rajveer 10657 
        else:
10658 
          iprot.skip(ftype)
10659 
      else:
10660 
        iprot.skip(ftype)
10661 
      iprot.readFieldEnd()
10662 
    iprot.readStructEnd()
10663 
 
10664 
  def write(self, oprot):
10665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10667 
      return
3064 chandransh 10668 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10669 
    if self.order is not None:
3064 chandransh 10670 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10671 
      self.order.write(oprot)
921 rajveer 10672 
      oprot.writeFieldEnd()
10673 
    oprot.writeFieldStop()
10674 
    oprot.writeStructEnd()
10675 
 
3431 rajveer 10676 
  def validate(self):
10677 
    return
10678 
 
10679 
 
921 rajveer 10680 
  def __repr__(self):
10681 
    L = ['%s=%r' % (key, value)
10682 
      for key, value in self.__dict__.iteritems()]
10683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10684 
 
10685 
  def __eq__(self, other):
10686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10687 
 
10688 
  def __ne__(self, other):
10689 
    return not (self == other)
10690 
 
3064 chandransh 10691 
class createOrder_result:
921 rajveer 10692 
  """
10693 
  Attributes:
10694 
   - success
10695 
   - ex
10696 
  """
10697 
 
10698 
  thrift_spec = (
3064 chandransh 10699 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10700 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10701 
  )
10702 
 
10703 
  def __init__(self, success=None, ex=None,):
10704 
    self.success = success
10705 
    self.ex = ex
10706 
 
10707 
  def read(self, iprot):
10708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10710 
      return
10711 
    iprot.readStructBegin()
10712 
    while True:
10713 
      (fname, ftype, fid) = iprot.readFieldBegin()
10714 
      if ftype == TType.STOP:
10715 
        break
10716 
      if fid == 0:
3064 chandransh 10717 
        if ftype == TType.I64:
10718 
          self.success = iprot.readI64();
921 rajveer 10719 
        else:
10720 
          iprot.skip(ftype)
10721 
      elif fid == 1:
10722 
        if ftype == TType.STRUCT:
10723 
          self.ex = TransactionServiceException()
10724 
          self.ex.read(iprot)
10725 
        else:
10726 
          iprot.skip(ftype)
10727 
      else:
10728 
        iprot.skip(ftype)
10729 
      iprot.readFieldEnd()
10730 
    iprot.readStructEnd()
10731 
 
10732 
  def write(self, oprot):
10733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10735 
      return
3064 chandransh 10736 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10737 
    if self.success is not None:
3064 chandransh 10738 
      oprot.writeFieldBegin('success', TType.I64, 0)
10739 
      oprot.writeI64(self.success)
921 rajveer 10740 
      oprot.writeFieldEnd()
3431 rajveer 10741 
    if self.ex is not None:
921 rajveer 10742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10743 
      self.ex.write(oprot)
10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
3431 rajveer 10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
921 rajveer 10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
3064 chandransh 10763 
class getOrder_args:
921 rajveer 10764 
  """
10765 
  Attributes:
3064 chandransh 10766 
   - id
921 rajveer 10767 
  """
10768 
 
10769 
  thrift_spec = (
10770 
    None, # 0
3064 chandransh 10771 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10772 
  )
10773 
 
3064 chandransh 10774 
  def __init__(self, id=None,):
10775 
    self.id = id
921 rajveer 10776 
 
10777 
  def read(self, iprot):
10778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10780 
      return
10781 
    iprot.readStructBegin()
10782 
    while True:
10783 
      (fname, ftype, fid) = iprot.readFieldBegin()
10784 
      if ftype == TType.STOP:
10785 
        break
10786 
      if fid == 1:
10787 
        if ftype == TType.I64:
3064 chandransh 10788 
          self.id = iprot.readI64();
921 rajveer 10789 
        else:
10790 
          iprot.skip(ftype)
10791 
      else:
10792 
        iprot.skip(ftype)
10793 
      iprot.readFieldEnd()
10794 
    iprot.readStructEnd()
10795 
 
10796 
  def write(self, oprot):
10797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10799 
      return
3064 chandransh 10800 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10801 
    if self.id is not None:
3064 chandransh 10802 
      oprot.writeFieldBegin('id', TType.I64, 1)
10803 
      oprot.writeI64(self.id)
921 rajveer 10804 
      oprot.writeFieldEnd()
10805 
    oprot.writeFieldStop()
10806 
    oprot.writeStructEnd()
10807 
 
3431 rajveer 10808 
  def validate(self):
10809 
    return
10810 
 
10811 
 
921 rajveer 10812 
  def __repr__(self):
10813 
    L = ['%s=%r' % (key, value)
10814 
      for key, value in self.__dict__.iteritems()]
10815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10816 
 
10817 
  def __eq__(self, other):
10818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10819 
 
10820 
  def __ne__(self, other):
10821 
    return not (self == other)
10822 
 
3064 chandransh 10823 
class getOrder_result:
921 rajveer 10824 
  """
10825 
  Attributes:
10826 
   - success
10827 
   - ex
10828 
  """
10829 
 
10830 
  thrift_spec = (
3064 chandransh 10831 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10833 
  )
10834 
 
10835 
  def __init__(self, success=None, ex=None,):
10836 
    self.success = success
10837 
    self.ex = ex
10838 
 
10839 
  def read(self, iprot):
10840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10842 
      return
10843 
    iprot.readStructBegin()
10844 
    while True:
10845 
      (fname, ftype, fid) = iprot.readFieldBegin()
10846 
      if ftype == TType.STOP:
10847 
        break
10848 
      if fid == 0:
3064 chandransh 10849 
        if ftype == TType.STRUCT:
10850 
          self.success = Order()
10851 
          self.success.read(iprot)
921 rajveer 10852 
        else:
10853 
          iprot.skip(ftype)
10854 
      elif fid == 1:
10855 
        if ftype == TType.STRUCT:
10856 
          self.ex = TransactionServiceException()
10857 
          self.ex.read(iprot)
10858 
        else:
10859 
          iprot.skip(ftype)
10860 
      else:
10861 
        iprot.skip(ftype)
10862 
      iprot.readFieldEnd()
10863 
    iprot.readStructEnd()
10864 
 
10865 
  def write(self, oprot):
10866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10868 
      return
3064 chandransh 10869 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10870 
    if self.success is not None:
3064 chandransh 10871 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10872 
      self.success.write(oprot)
921 rajveer 10873 
      oprot.writeFieldEnd()
3431 rajveer 10874 
    if self.ex is not None:
921 rajveer 10875 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10876 
      self.ex.write(oprot)
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
3431 rajveer 10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
921 rajveer 10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
3064 chandransh 10896 
class getLineItemsForOrder_args:
94 ashish 10897 
  """
10898 
  Attributes:
3064 chandransh 10899 
   - orderId
94 ashish 10900 
  """
10901 
 
10902 
  thrift_spec = (
10903 
    None, # 0
3064 chandransh 10904 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10905 
  )
10906 
 
3064 chandransh 10907 
  def __init__(self, orderId=None,):
10908 
    self.orderId = orderId
94 ashish 10909 
 
10910 
  def read(self, iprot):
10911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10913 
      return
10914 
    iprot.readStructBegin()
10915 
    while True:
10916 
      (fname, ftype, fid) = iprot.readFieldBegin()
10917 
      if ftype == TType.STOP:
10918 
        break
10919 
      if fid == 1:
10920 
        if ftype == TType.I64:
3064 chandransh 10921 
          self.orderId = iprot.readI64();
94 ashish 10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      else:
10925 
        iprot.skip(ftype)
10926 
      iprot.readFieldEnd()
10927 
    iprot.readStructEnd()
10928 
 
10929 
  def write(self, oprot):
10930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10932 
      return
3064 chandransh 10933 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10934 
    if self.orderId is not None:
3064 chandransh 10935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10936 
      oprot.writeI64(self.orderId)
94 ashish 10937 
      oprot.writeFieldEnd()
10938 
    oprot.writeFieldStop()
10939 
    oprot.writeStructEnd()
10940 
 
3431 rajveer 10941 
  def validate(self):
10942 
    return
10943 
 
10944 
 
94 ashish 10945 
  def __repr__(self):
10946 
    L = ['%s=%r' % (key, value)
10947 
      for key, value in self.__dict__.iteritems()]
10948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10949 
 
10950 
  def __eq__(self, other):
10951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10952 
 
10953 
  def __ne__(self, other):
10954 
    return not (self == other)
10955 
 
3064 chandransh 10956 
class getLineItemsForOrder_result:
94 ashish 10957 
  """
10958 
  Attributes:
10959 
   - success
10960 
   - ex
10961 
  """
10962 
 
10963 
  thrift_spec = (
3064 chandransh 10964 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10966 
  )
10967 
 
10968 
  def __init__(self, success=None, ex=None,):
10969 
    self.success = success
10970 
    self.ex = ex
10971 
 
10972 
  def read(self, iprot):
10973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10975 
      return
10976 
    iprot.readStructBegin()
10977 
    while True:
10978 
      (fname, ftype, fid) = iprot.readFieldBegin()
10979 
      if ftype == TType.STOP:
10980 
        break
10981 
      if fid == 0:
483 rajveer 10982 
        if ftype == TType.LIST:
10983 
          self.success = []
6031 rajveer 10984 
          (_etype164, _size161) = iprot.readListBegin()
10985 
          for _i165 in xrange(_size161):
10986 
            _elem166 = LineItem()
10987 
            _elem166.read(iprot)
10988 
            self.success.append(_elem166)
483 rajveer 10989 
          iprot.readListEnd()
94 ashish 10990 
        else:
10991 
          iprot.skip(ftype)
10992 
      elif fid == 1:
10993 
        if ftype == TType.STRUCT:
10994 
          self.ex = TransactionServiceException()
10995 
          self.ex.read(iprot)
10996 
        else:
10997 
          iprot.skip(ftype)
10998 
      else:
10999 
        iprot.skip(ftype)
11000 
      iprot.readFieldEnd()
11001 
    iprot.readStructEnd()
11002 
 
11003 
  def write(self, oprot):
11004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11006 
      return
3064 chandransh 11007 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11008 
    if self.success is not None:
483 rajveer 11009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11010 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11011 
      for iter167 in self.success:
11012 
        iter167.write(oprot)
483 rajveer 11013 
      oprot.writeListEnd()
94 ashish 11014 
      oprot.writeFieldEnd()
3431 rajveer 11015 
    if self.ex is not None:
94 ashish 11016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11017 
      self.ex.write(oprot)
11018 
      oprot.writeFieldEnd()
11019 
    oprot.writeFieldStop()
11020 
    oprot.writeStructEnd()
11021 
 
3431 rajveer 11022 
  def validate(self):
11023 
    return
11024 
 
11025 
 
94 ashish 11026 
  def __repr__(self):
11027 
    L = ['%s=%r' % (key, value)
11028 
      for key, value in self.__dict__.iteritems()]
11029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11030 
 
11031 
  def __eq__(self, other):
11032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11033 
 
11034 
  def __ne__(self, other):
11035 
    return not (self == other)
11036 
 
4999 phani.kuma 11037 
class getOrderList_args:
11038 
  """
11039 
  Attributes:
11040 
   - order_ids
11041 
  """
11042 
 
11043 
  thrift_spec = (
11044 
    None, # 0
11045 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11046 
  )
11047 
 
11048 
  def __init__(self, order_ids=None,):
11049 
    self.order_ids = order_ids
11050 
 
11051 
  def read(self, iprot):
11052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11054 
      return
11055 
    iprot.readStructBegin()
11056 
    while True:
11057 
      (fname, ftype, fid) = iprot.readFieldBegin()
11058 
      if ftype == TType.STOP:
11059 
        break
11060 
      if fid == 1:
11061 
        if ftype == TType.LIST:
11062 
          self.order_ids = []
6031 rajveer 11063 
          (_etype171, _size168) = iprot.readListBegin()
11064 
          for _i172 in xrange(_size168):
11065 
            _elem173 = iprot.readI64();
11066 
            self.order_ids.append(_elem173)
4999 phani.kuma 11067 
          iprot.readListEnd()
11068 
        else:
11069 
          iprot.skip(ftype)
11070 
      else:
11071 
        iprot.skip(ftype)
11072 
      iprot.readFieldEnd()
11073 
    iprot.readStructEnd()
11074 
 
11075 
  def write(self, oprot):
11076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11078 
      return
11079 
    oprot.writeStructBegin('getOrderList_args')
11080 
    if self.order_ids is not None:
11081 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11082 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11083 
      for iter174 in self.order_ids:
11084 
        oprot.writeI64(iter174)
4999 phani.kuma 11085 
      oprot.writeListEnd()
11086 
      oprot.writeFieldEnd()
11087 
    oprot.writeFieldStop()
11088 
    oprot.writeStructEnd()
11089 
 
11090 
  def validate(self):
11091 
    return
11092 
 
11093 
 
11094 
  def __repr__(self):
11095 
    L = ['%s=%r' % (key, value)
11096 
      for key, value in self.__dict__.iteritems()]
11097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11098 
 
11099 
  def __eq__(self, other):
11100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11101 
 
11102 
  def __ne__(self, other):
11103 
    return not (self == other)
11104 
 
11105 
class getOrderList_result:
11106 
  """
11107 
  Attributes:
11108 
   - success
11109 
  """
11110 
 
11111 
  thrift_spec = (
11112 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11113 
  )
11114 
 
11115 
  def __init__(self, success=None,):
11116 
    self.success = success
11117 
 
11118 
  def read(self, iprot):
11119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11121 
      return
11122 
    iprot.readStructBegin()
11123 
    while True:
11124 
      (fname, ftype, fid) = iprot.readFieldBegin()
11125 
      if ftype == TType.STOP:
11126 
        break
11127 
      if fid == 0:
11128 
        if ftype == TType.LIST:
11129 
          self.success = []
6031 rajveer 11130 
          (_etype178, _size175) = iprot.readListBegin()
11131 
          for _i179 in xrange(_size175):
11132 
            _elem180 = Order()
11133 
            _elem180.read(iprot)
11134 
            self.success.append(_elem180)
4999 phani.kuma 11135 
          iprot.readListEnd()
11136 
        else:
11137 
          iprot.skip(ftype)
11138 
      else:
11139 
        iprot.skip(ftype)
11140 
      iprot.readFieldEnd()
11141 
    iprot.readStructEnd()
11142 
 
11143 
  def write(self, oprot):
11144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11146 
      return
11147 
    oprot.writeStructBegin('getOrderList_result')
11148 
    if self.success is not None:
11149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11151 
      for iter181 in self.success:
11152 
        iter181.write(oprot)
4999 phani.kuma 11153 
      oprot.writeListEnd()
11154 
      oprot.writeFieldEnd()
11155 
    oprot.writeFieldStop()
11156 
    oprot.writeStructEnd()
11157 
 
11158 
  def validate(self):
11159 
    return
11160 
 
11161 
 
11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
5386 phani.kuma 11173 
class getOrderListForVendor_args:
11174 
  """
11175 
  Attributes:
11176 
   - order_ids
11177 
   - vendorId
11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    None, # 0
11182 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11183 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11184 
  )
11185 
 
11186 
  def __init__(self, order_ids=None, vendorId=None,):
11187 
    self.order_ids = order_ids
11188 
    self.vendorId = vendorId
11189 
 
11190 
  def read(self, iprot):
11191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11193 
      return
11194 
    iprot.readStructBegin()
11195 
    while True:
11196 
      (fname, ftype, fid) = iprot.readFieldBegin()
11197 
      if ftype == TType.STOP:
11198 
        break
11199 
      if fid == 1:
11200 
        if ftype == TType.LIST:
11201 
          self.order_ids = []
6031 rajveer 11202 
          (_etype185, _size182) = iprot.readListBegin()
11203 
          for _i186 in xrange(_size182):
11204 
            _elem187 = iprot.readI64();
11205 
            self.order_ids.append(_elem187)
5386 phani.kuma 11206 
          iprot.readListEnd()
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      elif fid == 2:
11210 
        if ftype == TType.I64:
11211 
          self.vendorId = iprot.readI64();
11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      else:
11215 
        iprot.skip(ftype)
11216 
      iprot.readFieldEnd()
11217 
    iprot.readStructEnd()
11218 
 
11219 
  def write(self, oprot):
11220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11222 
      return
11223 
    oprot.writeStructBegin('getOrderListForVendor_args')
11224 
    if self.order_ids is not None:
11225 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11226 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11227 
      for iter188 in self.order_ids:
11228 
        oprot.writeI64(iter188)
5386 phani.kuma 11229 
      oprot.writeListEnd()
11230 
      oprot.writeFieldEnd()
11231 
    if self.vendorId is not None:
11232 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11233 
      oprot.writeI64(self.vendorId)
11234 
      oprot.writeFieldEnd()
11235 
    oprot.writeFieldStop()
11236 
    oprot.writeStructEnd()
11237 
 
11238 
  def validate(self):
11239 
    return
11240 
 
11241 
 
11242 
  def __repr__(self):
11243 
    L = ['%s=%r' % (key, value)
11244 
      for key, value in self.__dict__.iteritems()]
11245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11246 
 
11247 
  def __eq__(self, other):
11248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11249 
 
11250 
  def __ne__(self, other):
11251 
    return not (self == other)
11252 
 
11253 
class getOrderListForVendor_result:
11254 
  """
11255 
  Attributes:
11256 
   - success
11257 
  """
11258 
 
11259 
  thrift_spec = (
11260 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11261 
  )
11262 
 
11263 
  def __init__(self, success=None,):
11264 
    self.success = success
11265 
 
11266 
  def read(self, iprot):
11267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11269 
      return
11270 
    iprot.readStructBegin()
11271 
    while True:
11272 
      (fname, ftype, fid) = iprot.readFieldBegin()
11273 
      if ftype == TType.STOP:
11274 
        break
11275 
      if fid == 0:
11276 
        if ftype == TType.LIST:
11277 
          self.success = []
6031 rajveer 11278 
          (_etype192, _size189) = iprot.readListBegin()
11279 
          for _i193 in xrange(_size189):
11280 
            _elem194 = Order()
11281 
            _elem194.read(iprot)
11282 
            self.success.append(_elem194)
5386 phani.kuma 11283 
          iprot.readListEnd()
11284 
        else:
11285 
          iprot.skip(ftype)
11286 
      else:
11287 
        iprot.skip(ftype)
11288 
      iprot.readFieldEnd()
11289 
    iprot.readStructEnd()
11290 
 
11291 
  def write(self, oprot):
11292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11294 
      return
11295 
    oprot.writeStructBegin('getOrderListForVendor_result')
11296 
    if self.success is not None:
11297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11299 
      for iter195 in self.success:
11300 
        iter195.write(oprot)
5386 phani.kuma 11301 
      oprot.writeListEnd()
11302 
      oprot.writeFieldEnd()
11303 
    oprot.writeFieldStop()
11304 
    oprot.writeStructEnd()
11305 
 
11306 
  def validate(self):
11307 
    return
11308 
 
11309 
 
11310 
  def __repr__(self):
11311 
    L = ['%s=%r' % (key, value)
11312 
      for key, value in self.__dict__.iteritems()]
11313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11314 
 
11315 
  def __eq__(self, other):
11316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11317 
 
11318 
  def __ne__(self, other):
11319 
    return not (self == other)
11320 
 
3064 chandransh 11321 
class getOrderForCustomer_args:
94 ashish 11322 
  """
11323 
  Attributes:
3064 chandransh 11324 
   - orderId
483 rajveer 11325 
   - customerId
94 ashish 11326 
  """
11327 
 
11328 
  thrift_spec = (
11329 
    None, # 0
3064 chandransh 11330 
    (1, TType.I64, 'orderId', None, None, ), # 1
11331 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11332 
  )
11333 
 
3064 chandransh 11334 
  def __init__(self, orderId=None, customerId=None,):
11335 
    self.orderId = orderId
483 rajveer 11336 
    self.customerId = customerId
94 ashish 11337 
 
11338 
  def read(self, iprot):
11339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11341 
      return
11342 
    iprot.readStructBegin()
11343 
    while True:
11344 
      (fname, ftype, fid) = iprot.readFieldBegin()
11345 
      if ftype == TType.STOP:
11346 
        break
11347 
      if fid == 1:
11348 
        if ftype == TType.I64:
3064 chandransh 11349 
          self.orderId = iprot.readI64();
94 ashish 11350 
        else:
11351 
          iprot.skip(ftype)
11352 
      elif fid == 2:
11353 
        if ftype == TType.I64:
3064 chandransh 11354 
          self.customerId = iprot.readI64();
94 ashish 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('getOrderForCustomer_args')
3431 rajveer 11367 
    if self.orderId is not None:
3064 chandransh 11368 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11369 
      oprot.writeI64(self.orderId)
11370 
      oprot.writeFieldEnd()
3431 rajveer 11371 
    if self.customerId is not None:
3064 chandransh 11372 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11373 
      oprot.writeI64(self.customerId)
94 ashish 11374 
      oprot.writeFieldEnd()
11375 
    oprot.writeFieldStop()
11376 
    oprot.writeStructEnd()
11377 
 
3431 rajveer 11378 
  def validate(self):
11379 
    return
11380 
 
11381 
 
94 ashish 11382 
  def __repr__(self):
11383 
    L = ['%s=%r' % (key, value)
11384 
      for key, value in self.__dict__.iteritems()]
11385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11386 
 
11387 
  def __eq__(self, other):
11388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11389 
 
11390 
  def __ne__(self, other):
11391 
    return not (self == other)
11392 
 
3064 chandransh 11393 
class getOrderForCustomer_result:
94 ashish 11394 
  """
11395 
  Attributes:
11396 
   - success
11397 
   - ex
11398 
  """
11399 
 
11400 
  thrift_spec = (
3064 chandransh 11401 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11403 
  )
11404 
 
11405 
  def __init__(self, success=None, ex=None,):
11406 
    self.success = success
11407 
    self.ex = ex
11408 
 
11409 
  def read(self, iprot):
11410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11412 
      return
11413 
    iprot.readStructBegin()
11414 
    while True:
11415 
      (fname, ftype, fid) = iprot.readFieldBegin()
11416 
      if ftype == TType.STOP:
11417 
        break
11418 
      if fid == 0:
3064 chandransh 11419 
        if ftype == TType.STRUCT:
11420 
          self.success = Order()
11421 
          self.success.read(iprot)
94 ashish 11422 
        else:
11423 
          iprot.skip(ftype)
11424 
      elif fid == 1:
11425 
        if ftype == TType.STRUCT:
11426 
          self.ex = TransactionServiceException()
11427 
          self.ex.read(iprot)
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      else:
11431 
        iprot.skip(ftype)
11432 
      iprot.readFieldEnd()
11433 
    iprot.readStructEnd()
11434 
 
11435 
  def write(self, oprot):
11436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11438 
      return
3064 chandransh 11439 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11440 
    if self.success is not None:
3064 chandransh 11441 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11442 
      self.success.write(oprot)
94 ashish 11443 
      oprot.writeFieldEnd()
3431 rajveer 11444 
    if self.ex is not None:
94 ashish 11445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11446 
      self.ex.write(oprot)
11447 
      oprot.writeFieldEnd()
11448 
    oprot.writeFieldStop()
11449 
    oprot.writeStructEnd()
11450 
 
3431 rajveer 11451 
  def validate(self):
11452 
    return
11453 
 
11454 
 
94 ashish 11455 
  def __repr__(self):
11456 
    L = ['%s=%r' % (key, value)
11457 
      for key, value in self.__dict__.iteritems()]
11458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11459 
 
11460 
  def __eq__(self, other):
11461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11462 
 
11463 
  def __ne__(self, other):
11464 
    return not (self == other)
11465 
 
3064 chandransh 11466 
class getAlerts_args:
94 ashish 11467 
  """
11468 
  Attributes:
4394 rajveer 11469 
   - type
4444 rajveer 11470 
   - warehouseId
4394 rajveer 11471 
   - status
11472 
   - timestamp
94 ashish 11473 
  """
11474 
 
11475 
  thrift_spec = (
11476 
    None, # 0
4394 rajveer 11477 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11478 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11479 
    (3, TType.I64, 'status', None, None, ), # 3
11480 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11481 
  )
11482 
 
4444 rajveer 11483 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11484 
    self.type = type
4444 rajveer 11485 
    self.warehouseId = warehouseId
4394 rajveer 11486 
    self.status = status
11487 
    self.timestamp = timestamp
94 ashish 11488 
 
11489 
  def read(self, iprot):
11490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11492 
      return
11493 
    iprot.readStructBegin()
11494 
    while True:
11495 
      (fname, ftype, fid) = iprot.readFieldBegin()
11496 
      if ftype == TType.STOP:
11497 
        break
11498 
      if fid == 1:
3064 chandransh 11499 
        if ftype == TType.I64:
4394 rajveer 11500 
          self.type = iprot.readI64();
94 ashish 11501 
        else:
11502 
          iprot.skip(ftype)
3064 chandransh 11503 
      elif fid == 2:
4394 rajveer 11504 
        if ftype == TType.I64:
4444 rajveer 11505 
          self.warehouseId = iprot.readI64();
3064 chandransh 11506 
        else:
11507 
          iprot.skip(ftype)
4394 rajveer 11508 
      elif fid == 3:
11509 
        if ftype == TType.I64:
4444 rajveer 11510 
          self.status = iprot.readI64();
11511 
        else:
11512 
          iprot.skip(ftype)
11513 
      elif fid == 4:
11514 
        if ftype == TType.I64:
4394 rajveer 11515 
          self.timestamp = iprot.readI64();
11516 
        else:
11517 
          iprot.skip(ftype)
94 ashish 11518 
      else:
11519 
        iprot.skip(ftype)
11520 
      iprot.readFieldEnd()
11521 
    iprot.readStructEnd()
11522 
 
11523 
  def write(self, oprot):
11524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11526 
      return
3064 chandransh 11527 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11528 
    if self.type is not None:
11529 
      oprot.writeFieldBegin('type', TType.I64, 1)
11530 
      oprot.writeI64(self.type)
94 ashish 11531 
      oprot.writeFieldEnd()
4444 rajveer 11532 
    if self.warehouseId is not None:
11533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11534 
      oprot.writeI64(self.warehouseId)
11535 
      oprot.writeFieldEnd()
4394 rajveer 11536 
    if self.status is not None:
4444 rajveer 11537 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11538 
      oprot.writeI64(self.status)
3064 chandransh 11539 
      oprot.writeFieldEnd()
4394 rajveer 11540 
    if self.timestamp is not None:
4444 rajveer 11541 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11542 
      oprot.writeI64(self.timestamp)
11543 
      oprot.writeFieldEnd()
94 ashish 11544 
    oprot.writeFieldStop()
11545 
    oprot.writeStructEnd()
11546 
 
3431 rajveer 11547 
  def validate(self):
11548 
    return
11549 
 
11550 
 
94 ashish 11551 
  def __repr__(self):
11552 
    L = ['%s=%r' % (key, value)
11553 
      for key, value in self.__dict__.iteritems()]
11554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11555 
 
11556 
  def __eq__(self, other):
11557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11558 
 
11559 
  def __ne__(self, other):
11560 
    return not (self == other)
11561 
 
3064 chandransh 11562 
class getAlerts_result:
94 ashish 11563 
  """
11564 
  Attributes:
11565 
   - success
11566 
  """
11567 
 
11568 
  thrift_spec = (
3064 chandransh 11569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11570 
  )
11571 
 
3064 chandransh 11572 
  def __init__(self, success=None,):
94 ashish 11573 
    self.success = success
11574 
 
11575 
  def read(self, iprot):
11576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11578 
      return
11579 
    iprot.readStructBegin()
11580 
    while True:
11581 
      (fname, ftype, fid) = iprot.readFieldBegin()
11582 
      if ftype == TType.STOP:
11583 
        break
11584 
      if fid == 0:
3064 chandransh 11585 
        if ftype == TType.LIST:
11586 
          self.success = []
6031 rajveer 11587 
          (_etype199, _size196) = iprot.readListBegin()
11588 
          for _i200 in xrange(_size196):
11589 
            _elem201 = Alert()
11590 
            _elem201.read(iprot)
11591 
            self.success.append(_elem201)
3064 chandransh 11592 
          iprot.readListEnd()
94 ashish 11593 
        else:
11594 
          iprot.skip(ftype)
11595 
      else:
11596 
        iprot.skip(ftype)
11597 
      iprot.readFieldEnd()
11598 
    iprot.readStructEnd()
11599 
 
11600 
  def write(self, oprot):
11601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11603 
      return
3064 chandransh 11604 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11605 
    if self.success is not None:
3064 chandransh 11606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11608 
      for iter202 in self.success:
11609 
        iter202.write(oprot)
3064 chandransh 11610 
      oprot.writeListEnd()
94 ashish 11611 
      oprot.writeFieldEnd()
11612 
    oprot.writeFieldStop()
11613 
    oprot.writeStructEnd()
11614 
 
3431 rajveer 11615 
  def validate(self):
11616 
    return
11617 
 
11618 
 
94 ashish 11619 
  def __repr__(self):
11620 
    L = ['%s=%r' % (key, value)
11621 
      for key, value in self.__dict__.iteritems()]
11622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11623 
 
11624 
  def __eq__(self, other):
11625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11626 
 
11627 
  def __ne__(self, other):
11628 
    return not (self == other)
11629 
 
4394 rajveer 11630 
class addAlert_args:
94 ashish 11631 
  """
11632 
  Attributes:
3064 chandransh 11633 
   - type
4444 rajveer 11634 
   - warehouseId
4394 rajveer 11635 
   - description
94 ashish 11636 
  """
11637 
 
11638 
  thrift_spec = (
11639 
    None, # 0
4394 rajveer 11640 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11641 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11642 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11643 
  )
11644 
 
4444 rajveer 11645 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11646 
    self.type = type
4444 rajveer 11647 
    self.warehouseId = warehouseId
4394 rajveer 11648 
    self.description = description
94 ashish 11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      if fid == 1:
11660 
        if ftype == TType.I64:
4394 rajveer 11661 
          self.type = iprot.readI64();
94 ashish 11662 
        else:
11663 
          iprot.skip(ftype)
3064 chandransh 11664 
      elif fid == 2:
4444 rajveer 11665 
        if ftype == TType.I64:
11666 
          self.warehouseId = iprot.readI64();
11667 
        else:
11668 
          iprot.skip(ftype)
11669 
      elif fid == 3:
3064 chandransh 11670 
        if ftype == TType.STRING:
4394 rajveer 11671 
          self.description = iprot.readString();
3064 chandransh 11672 
        else:
11673 
          iprot.skip(ftype)
94 ashish 11674 
      else:
11675 
        iprot.skip(ftype)
11676 
      iprot.readFieldEnd()
11677 
    iprot.readStructEnd()
11678 
 
11679 
  def write(self, oprot):
11680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11682 
      return
4394 rajveer 11683 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11684 
    if self.type is not None:
4394 rajveer 11685 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11686 
      oprot.writeI64(self.type)
11687 
      oprot.writeFieldEnd()
4444 rajveer 11688 
    if self.warehouseId is not None:
11689 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11690 
      oprot.writeI64(self.warehouseId)
11691 
      oprot.writeFieldEnd()
4394 rajveer 11692 
    if self.description is not None:
4444 rajveer 11693 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11694 
      oprot.writeString(self.description)
3064 chandransh 11695 
      oprot.writeFieldEnd()
94 ashish 11696 
    oprot.writeFieldStop()
11697 
    oprot.writeStructEnd()
11698 
 
3431 rajveer 11699 
  def validate(self):
11700 
    return
11701 
 
11702 
 
94 ashish 11703 
  def __repr__(self):
11704 
    L = ['%s=%r' % (key, value)
11705 
      for key, value in self.__dict__.iteritems()]
11706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11707 
 
11708 
  def __eq__(self, other):
11709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11710 
 
11711 
  def __ne__(self, other):
11712 
    return not (self == other)
11713 
 
4394 rajveer 11714 
class addAlert_result:
3064 chandransh 11715 
 
11716 
  thrift_spec = (
11717 
  )
11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      else:
11729 
        iprot.skip(ftype)
11730 
      iprot.readFieldEnd()
11731 
    iprot.readStructEnd()
11732 
 
11733 
  def write(self, oprot):
11734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11736 
      return
4394 rajveer 11737 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
3431 rajveer 11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
3064 chandransh 11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
4444 rajveer 11756 
class markAlertsAsSeen_args:
11757 
  """
11758 
  Attributes:
11759 
   - warehouseId
11760 
  """
11761 
 
11762 
  thrift_spec = (
11763 
    None, # 0
11764 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11765 
  )
11766 
 
11767 
  def __init__(self, warehouseId=None,):
11768 
    self.warehouseId = warehouseId
11769 
 
11770 
  def read(self, iprot):
11771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11773 
      return
11774 
    iprot.readStructBegin()
11775 
    while True:
11776 
      (fname, ftype, fid) = iprot.readFieldBegin()
11777 
      if ftype == TType.STOP:
11778 
        break
11779 
      if fid == 1:
11780 
        if ftype == TType.I64:
11781 
          self.warehouseId = iprot.readI64();
11782 
        else:
11783 
          iprot.skip(ftype)
11784 
      else:
11785 
        iprot.skip(ftype)
11786 
      iprot.readFieldEnd()
11787 
    iprot.readStructEnd()
11788 
 
11789 
  def write(self, oprot):
11790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11792 
      return
11793 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11794 
    if self.warehouseId is not None:
11795 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11796 
      oprot.writeI64(self.warehouseId)
11797 
      oprot.writeFieldEnd()
11798 
    oprot.writeFieldStop()
11799 
    oprot.writeStructEnd()
11800 
 
11801 
  def validate(self):
11802 
    return
11803 
 
11804 
 
11805 
  def __repr__(self):
11806 
    L = ['%s=%r' % (key, value)
11807 
      for key, value in self.__dict__.iteritems()]
11808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11809 
 
11810 
  def __eq__(self, other):
11811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11812 
 
11813 
  def __ne__(self, other):
11814 
    return not (self == other)
11815 
 
11816 
class markAlertsAsSeen_result:
11817 
 
11818 
  thrift_spec = (
11819 
  )
11820 
 
11821 
  def read(self, iprot):
11822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11824 
      return
11825 
    iprot.readStructBegin()
11826 
    while True:
11827 
      (fname, ftype, fid) = iprot.readFieldBegin()
11828 
      if ftype == TType.STOP:
11829 
        break
11830 
      else:
11831 
        iprot.skip(ftype)
11832 
      iprot.readFieldEnd()
11833 
    iprot.readStructEnd()
11834 
 
11835 
  def write(self, oprot):
11836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11838 
      return
11839 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11840 
    oprot.writeFieldStop()
11841 
    oprot.writeStructEnd()
11842 
 
11843 
  def validate(self):
11844 
    return
11845 
 
11846 
 
11847 
  def __repr__(self):
11848 
    L = ['%s=%r' % (key, value)
11849 
      for key, value in self.__dict__.iteritems()]
11850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11851 
 
11852 
  def __eq__(self, other):
11853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11854 
 
11855 
  def __ne__(self, other):
11856 
    return not (self == other)
11857 
 
3064 chandransh 11858 
class getValidOrderCount_args:
11859 
 
11860 
  thrift_spec = (
11861 
  )
11862 
 
11863 
  def read(self, iprot):
11864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11866 
      return
11867 
    iprot.readStructBegin()
11868 
    while True:
11869 
      (fname, ftype, fid) = iprot.readFieldBegin()
11870 
      if ftype == TType.STOP:
11871 
        break
11872 
      else:
11873 
        iprot.skip(ftype)
11874 
      iprot.readFieldEnd()
11875 
    iprot.readStructEnd()
11876 
 
11877 
  def write(self, oprot):
11878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11880 
      return
11881 
    oprot.writeStructBegin('getValidOrderCount_args')
11882 
    oprot.writeFieldStop()
11883 
    oprot.writeStructEnd()
11884 
 
3431 rajveer 11885 
  def validate(self):
11886 
    return
11887 
 
11888 
 
3064 chandransh 11889 
  def __repr__(self):
11890 
    L = ['%s=%r' % (key, value)
11891 
      for key, value in self.__dict__.iteritems()]
11892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11893 
 
11894 
  def __eq__(self, other):
11895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11896 
 
11897 
  def __ne__(self, other):
11898 
    return not (self == other)
11899 
 
11900 
class getValidOrderCount_result:
94 ashish 11901 
  """
11902 
  Attributes:
11903 
   - success
11904 
  """
11905 
 
11906 
  thrift_spec = (
3064 chandransh 11907 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11908 
  )
11909 
 
3064 chandransh 11910 
  def __init__(self, success=None,):
94 ashish 11911 
    self.success = success
11912 
 
11913 
  def read(self, iprot):
11914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11916 
      return
11917 
    iprot.readStructBegin()
11918 
    while True:
11919 
      (fname, ftype, fid) = iprot.readFieldBegin()
11920 
      if ftype == TType.STOP:
11921 
        break
11922 
      if fid == 0:
3064 chandransh 11923 
        if ftype == TType.I64:
11924 
          self.success = iprot.readI64();
94 ashish 11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      else:
11928 
        iprot.skip(ftype)
11929 
      iprot.readFieldEnd()
11930 
    iprot.readStructEnd()
11931 
 
11932 
  def write(self, oprot):
11933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11935 
      return
3064 chandransh 11936 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11937 
    if self.success is not None:
3064 chandransh 11938 
      oprot.writeFieldBegin('success', TType.I64, 0)
11939 
      oprot.writeI64(self.success)
94 ashish 11940 
      oprot.writeFieldEnd()
11941 
    oprot.writeFieldStop()
11942 
    oprot.writeStructEnd()
11943 
 
3431 rajveer 11944 
  def validate(self):
11945 
    return
11946 
 
11947 
 
94 ashish 11948 
  def __repr__(self):
11949 
    L = ['%s=%r' % (key, value)
11950 
      for key, value in self.__dict__.iteritems()]
11951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11952 
 
11953 
  def __eq__(self, other):
11954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11955 
 
11956 
  def __ne__(self, other):
11957 
    return not (self == other)
11958 
 
3064 chandransh 11959 
class getNoOfCustomersWithSuccessfulTransaction_args:
11960 
 
11961 
  thrift_spec = (
11962 
  )
11963 
 
11964 
  def read(self, iprot):
11965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11967 
      return
11968 
    iprot.readStructBegin()
11969 
    while True:
11970 
      (fname, ftype, fid) = iprot.readFieldBegin()
11971 
      if ftype == TType.STOP:
11972 
        break
11973 
      else:
11974 
        iprot.skip(ftype)
11975 
      iprot.readFieldEnd()
11976 
    iprot.readStructEnd()
11977 
 
11978 
  def write(self, oprot):
11979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11981 
      return
11982 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11983 
    oprot.writeFieldStop()
11984 
    oprot.writeStructEnd()
11985 
 
3431 rajveer 11986 
  def validate(self):
11987 
    return
11988 
 
11989 
 
3064 chandransh 11990 
  def __repr__(self):
11991 
    L = ['%s=%r' % (key, value)
11992 
      for key, value in self.__dict__.iteritems()]
11993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11994 
 
11995 
  def __eq__(self, other):
11996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11997 
 
11998 
  def __ne__(self, other):
11999 
    return not (self == other)
12000 
 
12001 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12002 
  """
12003 
  Attributes:
3064 chandransh 12004 
   - success
94 ashish 12005 
  """
12006 
 
12007 
  thrift_spec = (
3064 chandransh 12008 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12009 
  )
12010 
 
3064 chandransh 12011 
  def __init__(self, success=None,):
12012 
    self.success = success
94 ashish 12013 
 
12014 
  def read(self, iprot):
12015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12017 
      return
12018 
    iprot.readStructBegin()
12019 
    while True:
12020 
      (fname, ftype, fid) = iprot.readFieldBegin()
12021 
      if ftype == TType.STOP:
12022 
        break
3064 chandransh 12023 
      if fid == 0:
94 ashish 12024 
        if ftype == TType.I64:
3064 chandransh 12025 
          self.success = iprot.readI64();
94 ashish 12026 
        else:
12027 
          iprot.skip(ftype)
12028 
      else:
12029 
        iprot.skip(ftype)
12030 
      iprot.readFieldEnd()
12031 
    iprot.readStructEnd()
12032 
 
12033 
  def write(self, oprot):
12034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12036 
      return
3064 chandransh 12037 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12038 
    if self.success is not None:
3064 chandransh 12039 
      oprot.writeFieldBegin('success', TType.I64, 0)
12040 
      oprot.writeI64(self.success)
94 ashish 12041 
      oprot.writeFieldEnd()
12042 
    oprot.writeFieldStop()
12043 
    oprot.writeStructEnd()
12044 
 
3431 rajveer 12045 
  def validate(self):
12046 
    return
12047 
 
12048 
 
94 ashish 12049 
  def __repr__(self):
12050 
    L = ['%s=%r' % (key, value)
12051 
      for key, value in self.__dict__.iteritems()]
12052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12053 
 
12054 
  def __eq__(self, other):
12055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12056 
 
12057 
  def __ne__(self, other):
12058 
    return not (self == other)
12059 
 
3064 chandransh 12060 
class getValidOrdersAmountRange_args:
12061 
 
12062 
  thrift_spec = (
12063 
  )
12064 
 
12065 
  def read(self, iprot):
12066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12068 
      return
12069 
    iprot.readStructBegin()
12070 
    while True:
12071 
      (fname, ftype, fid) = iprot.readFieldBegin()
12072 
      if ftype == TType.STOP:
12073 
        break
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
12083 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12084 
    oprot.writeFieldStop()
12085 
    oprot.writeStructEnd()
12086 
 
3431 rajveer 12087 
  def validate(self):
12088 
    return
12089 
 
12090 
 
3064 chandransh 12091 
  def __repr__(self):
12092 
    L = ['%s=%r' % (key, value)
12093 
      for key, value in self.__dict__.iteritems()]
12094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12095 
 
12096 
  def __eq__(self, other):
12097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12098 
 
12099 
  def __ne__(self, other):
12100 
    return not (self == other)
12101 
 
12102 
class getValidOrdersAmountRange_result:
94 ashish 12103 
  """
12104 
  Attributes:
12105 
   - success
12106 
  """
12107 
 
12108 
  thrift_spec = (
3064 chandransh 12109 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12110 
  )
12111 
 
3064 chandransh 12112 
  def __init__(self, success=None,):
94 ashish 12113 
    self.success = success
12114 
 
12115 
  def read(self, iprot):
12116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12118 
      return
12119 
    iprot.readStructBegin()
12120 
    while True:
12121 
      (fname, ftype, fid) = iprot.readFieldBegin()
12122 
      if ftype == TType.STOP:
12123 
        break
12124 
      if fid == 0:
483 rajveer 12125 
        if ftype == TType.LIST:
12126 
          self.success = []
6031 rajveer 12127 
          (_etype206, _size203) = iprot.readListBegin()
12128 
          for _i207 in xrange(_size203):
12129 
            _elem208 = iprot.readDouble();
12130 
            self.success.append(_elem208)
483 rajveer 12131 
          iprot.readListEnd()
94 ashish 12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      else:
12135 
        iprot.skip(ftype)
12136 
      iprot.readFieldEnd()
12137 
    iprot.readStructEnd()
12138 
 
12139 
  def write(self, oprot):
12140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12142 
      return
3064 chandransh 12143 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12144 
    if self.success is not None:
483 rajveer 12145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12146 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12147 
      for iter209 in self.success:
12148 
        oprot.writeDouble(iter209)
483 rajveer 12149 
      oprot.writeListEnd()
94 ashish 12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
3431 rajveer 12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
94 ashish 12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
3064 chandransh 12169 
class getValidOrders_args:
1528 ankur.sing 12170 
  """
12171 
  Attributes:
3064 chandransh 12172 
   - limit
5874 rajveer 12173 
   - onlyStore
1528 ankur.sing 12174 
  """
12175 
 
12176 
  thrift_spec = (
12177 
    None, # 0
3064 chandransh 12178 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12179 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12180 
  )
12181 
 
5874 rajveer 12182 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12183 
    self.limit = limit
5874 rajveer 12184 
    self.onlyStore = onlyStore
1528 ankur.sing 12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 1:
12196 
        if ftype == TType.I64:
3064 chandransh 12197 
          self.limit = iprot.readI64();
1528 ankur.sing 12198 
        else:
12199 
          iprot.skip(ftype)
5874 rajveer 12200 
      elif fid == 2:
12201 
        if ftype == TType.BOOL:
12202 
          self.onlyStore = iprot.readBool();
12203 
        else:
12204 
          iprot.skip(ftype)
1528 ankur.sing 12205 
      else:
12206 
        iprot.skip(ftype)
12207 
      iprot.readFieldEnd()
12208 
    iprot.readStructEnd()
12209 
 
12210 
  def write(self, oprot):
12211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12213 
      return
3064 chandransh 12214 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12215 
    if self.limit is not None:
3064 chandransh 12216 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12217 
      oprot.writeI64(self.limit)
1528 ankur.sing 12218 
      oprot.writeFieldEnd()
5874 rajveer 12219 
    if self.onlyStore is not None:
12220 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12221 
      oprot.writeBool(self.onlyStore)
12222 
      oprot.writeFieldEnd()
1528 ankur.sing 12223 
    oprot.writeFieldStop()
12224 
    oprot.writeStructEnd()
12225 
 
3431 rajveer 12226 
  def validate(self):
12227 
    return
12228 
 
12229 
 
1528 ankur.sing 12230 
  def __repr__(self):
12231 
    L = ['%s=%r' % (key, value)
12232 
      for key, value in self.__dict__.iteritems()]
12233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12234 
 
12235 
  def __eq__(self, other):
12236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12237 
 
12238 
  def __ne__(self, other):
12239 
    return not (self == other)
12240 
 
3064 chandransh 12241 
class getValidOrders_result:
1528 ankur.sing 12242 
  """
12243 
  Attributes:
12244 
   - success
12245 
  """
12246 
 
12247 
  thrift_spec = (
3064 chandransh 12248 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12249 
  )
12250 
 
3064 chandransh 12251 
  def __init__(self, success=None,):
1528 ankur.sing 12252 
    self.success = success
12253 
 
12254 
  def read(self, iprot):
12255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12257 
      return
12258 
    iprot.readStructBegin()
12259 
    while True:
12260 
      (fname, ftype, fid) = iprot.readFieldBegin()
12261 
      if ftype == TType.STOP:
12262 
        break
12263 
      if fid == 0:
3064 chandransh 12264 
        if ftype == TType.LIST:
12265 
          self.success = []
6031 rajveer 12266 
          (_etype213, _size210) = iprot.readListBegin()
12267 
          for _i214 in xrange(_size210):
12268 
            _elem215 = Order()
12269 
            _elem215.read(iprot)
12270 
            self.success.append(_elem215)
3064 chandransh 12271 
          iprot.readListEnd()
1528 ankur.sing 12272 
        else:
12273 
          iprot.skip(ftype)
12274 
      else:
12275 
        iprot.skip(ftype)
12276 
      iprot.readFieldEnd()
12277 
    iprot.readStructEnd()
12278 
 
12279 
  def write(self, oprot):
12280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12282 
      return
3064 chandransh 12283 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12284 
    if self.success is not None:
3064 chandransh 12285 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12286 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12287 
      for iter216 in self.success:
12288 
        iter216.write(oprot)
3064 chandransh 12289 
      oprot.writeListEnd()
1528 ankur.sing 12290 
      oprot.writeFieldEnd()
12291 
    oprot.writeFieldStop()
12292 
    oprot.writeStructEnd()
12293 
 
3431 rajveer 12294 
  def validate(self):
12295 
    return
12296 
 
12297 
 
1528 ankur.sing 12298 
  def __repr__(self):
12299 
    L = ['%s=%r' % (key, value)
12300 
      for key, value in self.__dict__.iteritems()]
12301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12302 
 
12303 
  def __eq__(self, other):
12304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12305 
 
12306 
  def __ne__(self, other):
12307 
    return not (self == other)
12308 
 
1220 chandransh 12309 
class batchOrders_args:
12310 
  """
12311 
  Attributes:
12312 
   - warehouseId
12313 
  """
12314 
 
12315 
  thrift_spec = (
12316 
    None, # 0
12317 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12318 
  )
12319 
 
12320 
  def __init__(self, warehouseId=None,):
12321 
    self.warehouseId = warehouseId
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 
      if fid == 1:
12333 
        if ftype == TType.I64:
12334 
          self.warehouseId = iprot.readI64();
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      else:
12338 
        iprot.skip(ftype)
12339 
      iprot.readFieldEnd()
12340 
    iprot.readStructEnd()
12341 
 
12342 
  def write(self, oprot):
12343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12345 
      return
12346 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12347 
    if self.warehouseId is not None:
1220 chandransh 12348 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12349 
      oprot.writeI64(self.warehouseId)
12350 
      oprot.writeFieldEnd()
12351 
    oprot.writeFieldStop()
12352 
    oprot.writeStructEnd()
12353 
 
3431 rajveer 12354 
  def validate(self):
12355 
    return
12356 
 
12357 
 
1220 chandransh 12358 
  def __repr__(self):
12359 
    L = ['%s=%r' % (key, value)
12360 
      for key, value in self.__dict__.iteritems()]
12361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12362 
 
12363 
  def __eq__(self, other):
12364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12365 
 
12366 
  def __ne__(self, other):
12367 
    return not (self == other)
12368 
 
12369 
class batchOrders_result:
12370 
  """
12371 
  Attributes:
12372 
   - success
12373 
   - ex
12374 
  """
12375 
 
12376 
  thrift_spec = (
12377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12379 
  )
12380 
 
12381 
  def __init__(self, success=None, ex=None,):
12382 
    self.success = success
12383 
    self.ex = ex
12384 
 
12385 
  def read(self, iprot):
12386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12388 
      return
12389 
    iprot.readStructBegin()
12390 
    while True:
12391 
      (fname, ftype, fid) = iprot.readFieldBegin()
12392 
      if ftype == TType.STOP:
12393 
        break
12394 
      if fid == 0:
12395 
        if ftype == TType.LIST:
12396 
          self.success = []
6031 rajveer 12397 
          (_etype220, _size217) = iprot.readListBegin()
12398 
          for _i221 in xrange(_size217):
12399 
            _elem222 = Order()
12400 
            _elem222.read(iprot)
12401 
            self.success.append(_elem222)
1220 chandransh 12402 
          iprot.readListEnd()
12403 
        else:
12404 
          iprot.skip(ftype)
12405 
      elif fid == 1:
12406 
        if ftype == TType.STRUCT:
12407 
          self.ex = TransactionServiceException()
12408 
          self.ex.read(iprot)
12409 
        else:
12410 
          iprot.skip(ftype)
12411 
      else:
12412 
        iprot.skip(ftype)
12413 
      iprot.readFieldEnd()
12414 
    iprot.readStructEnd()
12415 
 
12416 
  def write(self, oprot):
12417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12419 
      return
12420 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12421 
    if self.success is not None:
1220 chandransh 12422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12424 
      for iter223 in self.success:
12425 
        iter223.write(oprot)
1220 chandransh 12426 
      oprot.writeListEnd()
12427 
      oprot.writeFieldEnd()
3431 rajveer 12428 
    if self.ex is not None:
1220 chandransh 12429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12430 
      self.ex.write(oprot)
12431 
      oprot.writeFieldEnd()
12432 
    oprot.writeFieldStop()
12433 
    oprot.writeStructEnd()
12434 
 
3431 rajveer 12435 
  def validate(self):
12436 
    return
12437 
 
12438 
 
1220 chandransh 12439 
  def __repr__(self):
12440 
    L = ['%s=%r' % (key, value)
12441 
      for key, value in self.__dict__.iteritems()]
12442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12443 
 
12444 
  def __eq__(self, other):
12445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12446 
 
12447 
  def __ne__(self, other):
12448 
    return not (self == other)
12449 
 
1208 chandransh 12450 
class markOrderAsOutOfStock_args:
12451 
  """
12452 
  Attributes:
12453 
   - orderId
12454 
  """
12455 
 
12456 
  thrift_spec = (
12457 
    None, # 0
12458 
    (1, TType.I64, 'orderId', None, None, ), # 1
12459 
  )
12460 
 
12461 
  def __init__(self, orderId=None,):
12462 
    self.orderId = orderId
12463 
 
12464 
  def read(self, iprot):
12465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12467 
      return
12468 
    iprot.readStructBegin()
12469 
    while True:
12470 
      (fname, ftype, fid) = iprot.readFieldBegin()
12471 
      if ftype == TType.STOP:
12472 
        break
12473 
      if fid == 1:
12474 
        if ftype == TType.I64:
12475 
          self.orderId = iprot.readI64();
12476 
        else:
12477 
          iprot.skip(ftype)
12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
12487 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12488 
    if self.orderId is not None:
1208 chandransh 12489 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12490 
      oprot.writeI64(self.orderId)
12491 
      oprot.writeFieldEnd()
12492 
    oprot.writeFieldStop()
12493 
    oprot.writeStructEnd()
12494 
 
3431 rajveer 12495 
  def validate(self):
12496 
    return
12497 
 
12498 
 
1208 chandransh 12499 
  def __repr__(self):
12500 
    L = ['%s=%r' % (key, value)
12501 
      for key, value in self.__dict__.iteritems()]
12502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12503 
 
12504 
  def __eq__(self, other):
12505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12506 
 
12507 
  def __ne__(self, other):
12508 
    return not (self == other)
12509 
 
12510 
class markOrderAsOutOfStock_result:
12511 
  """
12512 
  Attributes:
12513 
   - success
12514 
   - ex
12515 
  """
12516 
 
12517 
  thrift_spec = (
12518 
    (0, TType.BOOL, 'success', None, None, ), # 0
12519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12520 
  )
12521 
 
12522 
  def __init__(self, success=None, ex=None,):
12523 
    self.success = success
12524 
    self.ex = ex
12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      if fid == 0:
12536 
        if ftype == TType.BOOL:
12537 
          self.success = iprot.readBool();
12538 
        else:
12539 
          iprot.skip(ftype)
12540 
      elif fid == 1:
12541 
        if ftype == TType.STRUCT:
12542 
          self.ex = TransactionServiceException()
12543 
          self.ex.read(iprot)
12544 
        else:
12545 
          iprot.skip(ftype)
12546 
      else:
12547 
        iprot.skip(ftype)
12548 
      iprot.readFieldEnd()
12549 
    iprot.readStructEnd()
12550 
 
12551 
  def write(self, oprot):
12552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12554 
      return
12555 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12556 
    if self.success is not None:
1208 chandransh 12557 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12558 
      oprot.writeBool(self.success)
12559 
      oprot.writeFieldEnd()
3431 rajveer 12560 
    if self.ex is not None:
1208 chandransh 12561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12562 
      self.ex.write(oprot)
12563 
      oprot.writeFieldEnd()
12564 
    oprot.writeFieldStop()
12565 
    oprot.writeStructEnd()
12566 
 
3431 rajveer 12567 
  def validate(self):
12568 
    return
12569 
 
12570 
 
1208 chandransh 12571 
  def __repr__(self):
12572 
    L = ['%s=%r' % (key, value)
12573 
      for key, value in self.__dict__.iteritems()]
12574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12575 
 
12576 
  def __eq__(self, other):
12577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12578 
 
12579 
  def __ne__(self, other):
12580 
    return not (self == other)
12581 
 
3064 chandransh 12582 
class verifyOrder_args:
759 chandransh 12583 
  """
12584 
  Attributes:
3064 chandransh 12585 
   - orderId
759 chandransh 12586 
  """
12587 
 
12588 
  thrift_spec = (
12589 
    None, # 0
3064 chandransh 12590 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12591 
  )
12592 
 
3064 chandransh 12593 
  def __init__(self, orderId=None,):
12594 
    self.orderId = orderId
759 chandransh 12595 
 
12596 
  def read(self, iprot):
12597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12599 
      return
12600 
    iprot.readStructBegin()
12601 
    while True:
12602 
      (fname, ftype, fid) = iprot.readFieldBegin()
12603 
      if ftype == TType.STOP:
12604 
        break
12605 
      if fid == 1:
12606 
        if ftype == TType.I64:
3064 chandransh 12607 
          self.orderId = iprot.readI64();
759 chandransh 12608 
        else:
12609 
          iprot.skip(ftype)
12610 
      else:
12611 
        iprot.skip(ftype)
12612 
      iprot.readFieldEnd()
12613 
    iprot.readStructEnd()
12614 
 
12615 
  def write(self, oprot):
12616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12618 
      return
3064 chandransh 12619 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12620 
    if self.orderId is not None:
3064 chandransh 12621 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12622 
      oprot.writeI64(self.orderId)
759 chandransh 12623 
      oprot.writeFieldEnd()
12624 
    oprot.writeFieldStop()
12625 
    oprot.writeStructEnd()
12626 
 
3431 rajveer 12627 
  def validate(self):
12628 
    return
12629 
 
12630 
 
759 chandransh 12631 
  def __repr__(self):
12632 
    L = ['%s=%r' % (key, value)
12633 
      for key, value in self.__dict__.iteritems()]
12634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12635 
 
12636 
  def __eq__(self, other):
12637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12638 
 
12639 
  def __ne__(self, other):
12640 
    return not (self == other)
12641 
 
3064 chandransh 12642 
class verifyOrder_result:
759 chandransh 12643 
  """
12644 
  Attributes:
12645 
   - success
12646 
   - ex
12647 
  """
12648 
 
12649 
  thrift_spec = (
12650 
    (0, TType.BOOL, 'success', None, None, ), # 0
12651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12652 
  )
12653 
 
12654 
  def __init__(self, success=None, ex=None,):
12655 
    self.success = success
12656 
    self.ex = ex
12657 
 
12658 
  def read(self, iprot):
12659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12661 
      return
12662 
    iprot.readStructBegin()
12663 
    while True:
12664 
      (fname, ftype, fid) = iprot.readFieldBegin()
12665 
      if ftype == TType.STOP:
12666 
        break
12667 
      if fid == 0:
12668 
        if ftype == TType.BOOL:
12669 
          self.success = iprot.readBool();
12670 
        else:
12671 
          iprot.skip(ftype)
12672 
      elif fid == 1:
12673 
        if ftype == TType.STRUCT:
12674 
          self.ex = TransactionServiceException()
12675 
          self.ex.read(iprot)
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      else:
12679 
        iprot.skip(ftype)
12680 
      iprot.readFieldEnd()
12681 
    iprot.readStructEnd()
12682 
 
12683 
  def write(self, oprot):
12684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12686 
      return
3064 chandransh 12687 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12688 
    if self.success is not None:
759 chandransh 12689 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12690 
      oprot.writeBool(self.success)
12691 
      oprot.writeFieldEnd()
3431 rajveer 12692 
    if self.ex is not None:
759 chandransh 12693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12694 
      self.ex.write(oprot)
12695 
      oprot.writeFieldEnd()
12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
3431 rajveer 12699 
  def validate(self):
12700 
    return
12701 
 
12702 
 
759 chandransh 12703 
  def __repr__(self):
12704 
    L = ['%s=%r' % (key, value)
12705 
      for key, value in self.__dict__.iteritems()]
12706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12707 
 
12708 
  def __eq__(self, other):
12709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12710 
 
12711 
  def __ne__(self, other):
12712 
    return not (self == other)
12713 
 
3064 chandransh 12714 
class acceptOrder_args:
1113 chandransh 12715 
  """
12716 
  Attributes:
3064 chandransh 12717 
   - orderId
1113 chandransh 12718 
  """
12719 
 
12720 
  thrift_spec = (
12721 
    None, # 0
3064 chandransh 12722 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12723 
  )
12724 
 
3064 chandransh 12725 
  def __init__(self, orderId=None,):
12726 
    self.orderId = orderId
1113 chandransh 12727 
 
12728 
  def read(self, iprot):
12729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12731 
      return
12732 
    iprot.readStructBegin()
12733 
    while True:
12734 
      (fname, ftype, fid) = iprot.readFieldBegin()
12735 
      if ftype == TType.STOP:
12736 
        break
12737 
      if fid == 1:
12738 
        if ftype == TType.I64:
3064 chandransh 12739 
          self.orderId = iprot.readI64();
1113 chandransh 12740 
        else:
12741 
          iprot.skip(ftype)
12742 
      else:
12743 
        iprot.skip(ftype)
12744 
      iprot.readFieldEnd()
12745 
    iprot.readStructEnd()
12746 
 
12747 
  def write(self, oprot):
12748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12750 
      return
3064 chandransh 12751 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12752 
    if self.orderId is not None:
3064 chandransh 12753 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12754 
      oprot.writeI64(self.orderId)
1113 chandransh 12755 
      oprot.writeFieldEnd()
12756 
    oprot.writeFieldStop()
12757 
    oprot.writeStructEnd()
12758 
 
3431 rajveer 12759 
  def validate(self):
12760 
    return
12761 
 
12762 
 
1113 chandransh 12763 
  def __repr__(self):
12764 
    L = ['%s=%r' % (key, value)
12765 
      for key, value in self.__dict__.iteritems()]
12766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12767 
 
12768 
  def __eq__(self, other):
12769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12770 
 
12771 
  def __ne__(self, other):
12772 
    return not (self == other)
12773 
 
3064 chandransh 12774 
class acceptOrder_result:
1113 chandransh 12775 
  """
12776 
  Attributes:
12777 
   - success
12778 
   - ex
12779 
  """
12780 
 
12781 
  thrift_spec = (
3064 chandransh 12782 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12784 
  )
12785 
 
12786 
  def __init__(self, success=None, ex=None,):
12787 
    self.success = success
12788 
    self.ex = ex
12789 
 
12790 
  def read(self, iprot):
12791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12793 
      return
12794 
    iprot.readStructBegin()
12795 
    while True:
12796 
      (fname, ftype, fid) = iprot.readFieldBegin()
12797 
      if ftype == TType.STOP:
12798 
        break
12799 
      if fid == 0:
3064 chandransh 12800 
        if ftype == TType.BOOL:
12801 
          self.success = iprot.readBool();
1113 chandransh 12802 
        else:
12803 
          iprot.skip(ftype)
12804 
      elif fid == 1:
12805 
        if ftype == TType.STRUCT:
12806 
          self.ex = TransactionServiceException()
12807 
          self.ex.read(iprot)
12808 
        else:
12809 
          iprot.skip(ftype)
12810 
      else:
12811 
        iprot.skip(ftype)
12812 
      iprot.readFieldEnd()
12813 
    iprot.readStructEnd()
12814 
 
12815 
  def write(self, oprot):
12816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12818 
      return
3064 chandransh 12819 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12820 
    if self.success is not None:
3064 chandransh 12821 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12822 
      oprot.writeBool(self.success)
1113 chandransh 12823 
      oprot.writeFieldEnd()
3431 rajveer 12824 
    if self.ex is not None:
1113 chandransh 12825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12826 
      self.ex.write(oprot)
12827 
      oprot.writeFieldEnd()
12828 
    oprot.writeFieldStop()
12829 
    oprot.writeStructEnd()
12830 
 
3431 rajveer 12831 
  def validate(self):
12832 
    return
12833 
 
12834 
 
1113 chandransh 12835 
  def __repr__(self):
12836 
    L = ['%s=%r' % (key, value)
12837 
      for key, value in self.__dict__.iteritems()]
12838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12839 
 
12840 
  def __eq__(self, other):
12841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12842 
 
12843 
  def __ne__(self, other):
12844 
    return not (self == other)
12845 
 
3064 chandransh 12846 
class addBillingDetails_args:
1135 chandransh 12847 
  """
12848 
  Attributes:
3064 chandransh 12849 
   - orderId
12850 
   - invoice_number
4658 mandeep.dh 12851 
   - serialNumber
4283 anupam.sin 12852 
   - itemNumber
3064 chandransh 12853 
   - billed_by
4264 rajveer 12854 
   - jacketNumber
4283 anupam.sin 12855 
   - billingType
5110 mandeep.dh 12856 
   - fulfilmentWarehouseId
4763 rajveer 12857 
   - authorize
1135 chandransh 12858 
  """
12859 
 
12860 
  thrift_spec = (
12861 
    None, # 0
3064 chandransh 12862 
    (1, TType.I64, 'orderId', None, None, ), # 1
12863 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12864 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12865 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12866 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12867 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12868 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12869 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12870 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12871 
  )
12872 
 
5110 mandeep.dh 12873 
  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 12874 
    self.orderId = orderId
12875 
    self.invoice_number = invoice_number
4658 mandeep.dh 12876 
    self.serialNumber = serialNumber
4283 anupam.sin 12877 
    self.itemNumber = itemNumber
3064 chandransh 12878 
    self.billed_by = billed_by
4264 rajveer 12879 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12880 
    self.billingType = billingType
5110 mandeep.dh 12881 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12882 
    self.authorize = authorize
1135 chandransh 12883 
 
12884 
  def read(self, iprot):
12885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12887 
      return
12888 
    iprot.readStructBegin()
12889 
    while True:
12890 
      (fname, ftype, fid) = iprot.readFieldBegin()
12891 
      if ftype == TType.STOP:
12892 
        break
12893 
      if fid == 1:
12894 
        if ftype == TType.I64:
3064 chandransh 12895 
          self.orderId = iprot.readI64();
1135 chandransh 12896 
        else:
12897 
          iprot.skip(ftype)
12898 
      elif fid == 2:
3064 chandransh 12899 
        if ftype == TType.STRING:
12900 
          self.invoice_number = iprot.readString();
1135 chandransh 12901 
        else:
12902 
          iprot.skip(ftype)
3064 chandransh 12903 
      elif fid == 3:
5411 rajveer 12904 
        if ftype == TType.LIST:
12905 
          self.serialNumber = []
6031 rajveer 12906 
          (_etype227, _size224) = iprot.readListBegin()
12907 
          for _i228 in xrange(_size224):
12908 
            _elem229 = iprot.readString();
12909 
            self.serialNumber.append(_elem229)
5411 rajveer 12910 
          iprot.readListEnd()
3064 chandransh 12911 
        else:
12912 
          iprot.skip(ftype)
12913 
      elif fid == 4:
5411 rajveer 12914 
        if ftype == TType.LIST:
12915 
          self.itemNumber = []
6031 rajveer 12916 
          (_etype233, _size230) = iprot.readListBegin()
12917 
          for _i234 in xrange(_size230):
12918 
            _elem235 = iprot.readString();
12919 
            self.itemNumber.append(_elem235)
5411 rajveer 12920 
          iprot.readListEnd()
3064 chandransh 12921 
        else:
12922 
          iprot.skip(ftype)
12923 
      elif fid == 5:
12924 
        if ftype == TType.STRING:
4283 anupam.sin 12925 
          self.billed_by = iprot.readString();
3064 chandransh 12926 
        else:
12927 
          iprot.skip(ftype)
12928 
      elif fid == 6:
12929 
        if ftype == TType.I64:
4283 anupam.sin 12930 
          self.jacketNumber = iprot.readI64();
12931 
        else:
12932 
          iprot.skip(ftype)
12933 
      elif fid == 7:
12934 
        if ftype == TType.I64:
3064 chandransh 12935 
          self.billingType = iprot.readI64();
12936 
        else:
12937 
          iprot.skip(ftype)
4283 anupam.sin 12938 
      elif fid == 8:
12939 
        if ftype == TType.I64:
5110 mandeep.dh 12940 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12941 
        else:
12942 
          iprot.skip(ftype)
4763 rajveer 12943 
      elif fid == 9:
12944 
        if ftype == TType.BOOL:
12945 
          self.authorize = iprot.readBool();
12946 
        else:
12947 
          iprot.skip(ftype)
1246 chandransh 12948 
      else:
12949 
        iprot.skip(ftype)
12950 
      iprot.readFieldEnd()
12951 
    iprot.readStructEnd()
12952 
 
12953 
  def write(self, oprot):
12954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12956 
      return
4283 anupam.sin 12957 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12958 
    if self.orderId is not None:
3064 chandransh 12959 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12960 
      oprot.writeI64(self.orderId)
1246 chandransh 12961 
      oprot.writeFieldEnd()
4283 anupam.sin 12962 
    if self.invoice_number is not None:
12963 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12964 
      oprot.writeString(self.invoice_number)
1246 chandransh 12965 
      oprot.writeFieldEnd()
4658 mandeep.dh 12966 
    if self.serialNumber is not None:
5411 rajveer 12967 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12968 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 12969 
      for iter236 in self.serialNumber:
12970 
        oprot.writeString(iter236)
5411 rajveer 12971 
      oprot.writeListEnd()
3064 chandransh 12972 
      oprot.writeFieldEnd()
3431 rajveer 12973 
    if self.itemNumber is not None:
5411 rajveer 12974 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12975 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 12976 
      for iter237 in self.itemNumber:
12977 
        oprot.writeString(iter237)
5411 rajveer 12978 
      oprot.writeListEnd()
3064 chandransh 12979 
      oprot.writeFieldEnd()
4283 anupam.sin 12980 
    if self.billed_by is not None:
12981 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12982 
      oprot.writeString(self.billed_by)
3064 chandransh 12983 
      oprot.writeFieldEnd()
4283 anupam.sin 12984 
    if self.jacketNumber is not None:
12985 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12986 
      oprot.writeI64(self.jacketNumber)
12987 
      oprot.writeFieldEnd()
3431 rajveer 12988 
    if self.billingType is not None:
4283 anupam.sin 12989 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12990 
      oprot.writeI64(self.billingType)
12991 
      oprot.writeFieldEnd()
5110 mandeep.dh 12992 
    if self.fulfilmentWarehouseId is not None:
12993 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12994 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12995 
      oprot.writeFieldEnd()
4763 rajveer 12996 
    if self.authorize is not None:
12997 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12998 
      oprot.writeBool(self.authorize)
12999 
      oprot.writeFieldEnd()
1246 chandransh 13000 
    oprot.writeFieldStop()
13001 
    oprot.writeStructEnd()
13002 
 
3431 rajveer 13003 
  def validate(self):
13004 
    return
13005 
 
13006 
 
1246 chandransh 13007 
  def __repr__(self):
13008 
    L = ['%s=%r' % (key, value)
13009 
      for key, value in self.__dict__.iteritems()]
13010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13011 
 
13012 
  def __eq__(self, other):
13013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13014 
 
13015 
  def __ne__(self, other):
13016 
    return not (self == other)
13017 
 
4283 anupam.sin 13018 
class addBillingDetails_result:
1246 chandransh 13019 
  """
13020 
  Attributes:
3064 chandransh 13021 
   - success
1246 chandransh 13022 
   - ex
13023 
  """
13024 
 
13025 
  thrift_spec = (
3064 chandransh 13026 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13028 
  )
13029 
 
3064 chandransh 13030 
  def __init__(self, success=None, ex=None,):
13031 
    self.success = success
1246 chandransh 13032 
    self.ex = ex
13033 
 
13034 
  def read(self, iprot):
13035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13037 
      return
13038 
    iprot.readStructBegin()
13039 
    while True:
13040 
      (fname, ftype, fid) = iprot.readFieldBegin()
13041 
      if ftype == TType.STOP:
13042 
        break
3064 chandransh 13043 
      if fid == 0:
13044 
        if ftype == TType.BOOL:
13045 
          self.success = iprot.readBool();
13046 
        else:
13047 
          iprot.skip(ftype)
13048 
      elif fid == 1:
1246 chandransh 13049 
        if ftype == TType.STRUCT:
13050 
          self.ex = TransactionServiceException()
13051 
          self.ex.read(iprot)
13052 
        else:
13053 
          iprot.skip(ftype)
13054 
      else:
13055 
        iprot.skip(ftype)
13056 
      iprot.readFieldEnd()
13057 
    iprot.readStructEnd()
13058 
 
13059 
  def write(self, oprot):
13060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13062 
      return
4283 anupam.sin 13063 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13064 
    if self.success is not None:
3064 chandransh 13065 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13066 
      oprot.writeBool(self.success)
13067 
      oprot.writeFieldEnd()
3431 rajveer 13068 
    if self.ex is not None:
1246 chandransh 13069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13070 
      self.ex.write(oprot)
13071 
      oprot.writeFieldEnd()
13072 
    oprot.writeFieldStop()
13073 
    oprot.writeStructEnd()
13074 
 
3431 rajveer 13075 
  def validate(self):
13076 
    return
13077 
 
13078 
 
1246 chandransh 13079 
  def __repr__(self):
13080 
    L = ['%s=%r' % (key, value)
13081 
      for key, value in self.__dict__.iteritems()]
13082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13083 
 
13084 
  def __eq__(self, other):
13085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13086 
 
13087 
  def __ne__(self, other):
13088 
    return not (self == other)
13089 
 
4579 rajveer 13090 
class addInvoiceNumber_args:
13091 
  """
13092 
  Attributes:
13093 
   - orderId
13094 
   - invoiceNumber
4763 rajveer 13095 
   - color
4579 rajveer 13096 
  """
13097 
 
13098 
  thrift_spec = (
13099 
    None, # 0
13100 
    (1, TType.I64, 'orderId', None, None, ), # 1
13101 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13102 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13103 
  )
13104 
 
4763 rajveer 13105 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13106 
    self.orderId = orderId
13107 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13108 
    self.color = color
4579 rajveer 13109 
 
13110 
  def read(self, iprot):
13111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13113 
      return
13114 
    iprot.readStructBegin()
13115 
    while True:
13116 
      (fname, ftype, fid) = iprot.readFieldBegin()
13117 
      if ftype == TType.STOP:
13118 
        break
13119 
      if fid == 1:
13120 
        if ftype == TType.I64:
13121 
          self.orderId = iprot.readI64();
13122 
        else:
13123 
          iprot.skip(ftype)
13124 
      elif fid == 2:
13125 
        if ftype == TType.STRING:
13126 
          self.invoiceNumber = iprot.readString();
13127 
        else:
13128 
          iprot.skip(ftype)
4763 rajveer 13129 
      elif fid == 3:
13130 
        if ftype == TType.STRING:
13131 
          self.color = iprot.readString();
13132 
        else:
13133 
          iprot.skip(ftype)
4579 rajveer 13134 
      else:
13135 
        iprot.skip(ftype)
13136 
      iprot.readFieldEnd()
13137 
    iprot.readStructEnd()
13138 
 
13139 
  def write(self, oprot):
13140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13142 
      return
13143 
    oprot.writeStructBegin('addInvoiceNumber_args')
13144 
    if self.orderId is not None:
13145 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13146 
      oprot.writeI64(self.orderId)
13147 
      oprot.writeFieldEnd()
13148 
    if self.invoiceNumber is not None:
13149 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13150 
      oprot.writeString(self.invoiceNumber)
13151 
      oprot.writeFieldEnd()
4763 rajveer 13152 
    if self.color is not None:
13153 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13154 
      oprot.writeString(self.color)
13155 
      oprot.writeFieldEnd()
4579 rajveer 13156 
    oprot.writeFieldStop()
13157 
    oprot.writeStructEnd()
13158 
 
13159 
  def validate(self):
13160 
    return
13161 
 
13162 
 
13163 
  def __repr__(self):
13164 
    L = ['%s=%r' % (key, value)
13165 
      for key, value in self.__dict__.iteritems()]
13166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13167 
 
13168 
  def __eq__(self, other):
13169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13170 
 
13171 
  def __ne__(self, other):
13172 
    return not (self == other)
13173 
 
13174 
class addInvoiceNumber_result:
13175 
  """
13176 
  Attributes:
13177 
   - ex
13178 
  """
13179 
 
13180 
  thrift_spec = (
13181 
    None, # 0
13182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13183 
  )
13184 
 
13185 
  def __init__(self, ex=None,):
13186 
    self.ex = ex
13187 
 
13188 
  def read(self, iprot):
13189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13191 
      return
13192 
    iprot.readStructBegin()
13193 
    while True:
13194 
      (fname, ftype, fid) = iprot.readFieldBegin()
13195 
      if ftype == TType.STOP:
13196 
        break
13197 
      if fid == 1:
13198 
        if ftype == TType.STRUCT:
13199 
          self.ex = TransactionServiceException()
13200 
          self.ex.read(iprot)
13201 
        else:
13202 
          iprot.skip(ftype)
13203 
      else:
13204 
        iprot.skip(ftype)
13205 
      iprot.readFieldEnd()
13206 
    iprot.readStructEnd()
13207 
 
13208 
  def write(self, oprot):
13209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13211 
      return
13212 
    oprot.writeStructBegin('addInvoiceNumber_result')
13213 
    if self.ex is not None:
13214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13215 
      self.ex.write(oprot)
13216 
      oprot.writeFieldEnd()
13217 
    oprot.writeFieldStop()
13218 
    oprot.writeStructEnd()
13219 
 
13220 
  def validate(self):
13221 
    return
13222 
 
13223 
 
13224 
  def __repr__(self):
13225 
    L = ['%s=%r' % (key, value)
13226 
      for key, value in self.__dict__.iteritems()]
13227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13228 
 
13229 
  def __eq__(self, other):
13230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13231 
 
13232 
  def __ne__(self, other):
13233 
    return not (self == other)
13234 
 
4910 phani.kuma 13235 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13236 
  """
13237 
  Attributes:
3064 chandransh 13238 
   - warehouseId
1408 ankur.sing 13239 
   - providerId
3064 chandransh 13240 
   - cod
4910 phani.kuma 13241 
   - orderIds
1408 ankur.sing 13242 
  """
13243 
 
13244 
  thrift_spec = (
13245 
    None, # 0
3064 chandransh 13246 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13247 
    (2, TType.I64, 'providerId', None, None, ), # 2
13248 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13249 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13250 
  )
13251 
 
4910 phani.kuma 13252 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13253 
    self.warehouseId = warehouseId
1408 ankur.sing 13254 
    self.providerId = providerId
3064 chandransh 13255 
    self.cod = cod
4910 phani.kuma 13256 
    self.orderIds = orderIds
1408 ankur.sing 13257 
 
13258 
  def read(self, iprot):
13259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13261 
      return
13262 
    iprot.readStructBegin()
13263 
    while True:
13264 
      (fname, ftype, fid) = iprot.readFieldBegin()
13265 
      if ftype == TType.STOP:
13266 
        break
13267 
      if fid == 1:
13268 
        if ftype == TType.I64:
3064 chandransh 13269 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13270 
        else:
13271 
          iprot.skip(ftype)
13272 
      elif fid == 2:
13273 
        if ftype == TType.I64:
3064 chandransh 13274 
          self.providerId = iprot.readI64();
1408 ankur.sing 13275 
        else:
13276 
          iprot.skip(ftype)
3064 chandransh 13277 
      elif fid == 3:
13278 
        if ftype == TType.BOOL:
13279 
          self.cod = iprot.readBool();
13280 
        else:
13281 
          iprot.skip(ftype)
4910 phani.kuma 13282 
      elif fid == 4:
13283 
        if ftype == TType.LIST:
13284 
          self.orderIds = []
6031 rajveer 13285 
          (_etype241, _size238) = iprot.readListBegin()
13286 
          for _i242 in xrange(_size238):
13287 
            _elem243 = iprot.readI64();
13288 
            self.orderIds.append(_elem243)
4910 phani.kuma 13289 
          iprot.readListEnd()
13290 
        else:
13291 
          iprot.skip(ftype)
1408 ankur.sing 13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
4910 phani.kuma 13301 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13302 
    if self.warehouseId is not None:
3064 chandransh 13303 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13304 
      oprot.writeI64(self.warehouseId)
13305 
      oprot.writeFieldEnd()
3431 rajveer 13306 
    if self.providerId is not None:
3064 chandransh 13307 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13308 
      oprot.writeI64(self.providerId)
13309 
      oprot.writeFieldEnd()
3431 rajveer 13310 
    if self.cod is not None:
3064 chandransh 13311 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13312 
      oprot.writeBool(self.cod)
1408 ankur.sing 13313 
      oprot.writeFieldEnd()
4910 phani.kuma 13314 
    if self.orderIds is not None:
13315 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13316 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13317 
      for iter244 in self.orderIds:
13318 
        oprot.writeI64(iter244)
4910 phani.kuma 13319 
      oprot.writeListEnd()
13320 
      oprot.writeFieldEnd()
1408 ankur.sing 13321 
    oprot.writeFieldStop()
13322 
    oprot.writeStructEnd()
13323 
 
3431 rajveer 13324 
  def validate(self):
13325 
    return
13326 
 
13327 
 
1408 ankur.sing 13328 
  def __repr__(self):
13329 
    L = ['%s=%r' % (key, value)
13330 
      for key, value in self.__dict__.iteritems()]
13331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13332 
 
13333 
  def __eq__(self, other):
13334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13335 
 
13336 
  def __ne__(self, other):
13337 
    return not (self == other)
13338 
 
4910 phani.kuma 13339 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13340 
  """
13341 
  Attributes:
13342 
   - success
3064 chandransh 13343 
   - ex
1408 ankur.sing 13344 
  """
13345 
 
13346 
  thrift_spec = (
3064 chandransh 13347 
    (0, TType.BOOL, 'success', None, None, ), # 0
13348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13349 
  )
13350 
 
3064 chandransh 13351 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13352 
    self.success = success
3064 chandransh 13353 
    self.ex = ex
1408 ankur.sing 13354 
 
13355 
  def read(self, iprot):
13356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13358 
      return
13359 
    iprot.readStructBegin()
13360 
    while True:
13361 
      (fname, ftype, fid) = iprot.readFieldBegin()
13362 
      if ftype == TType.STOP:
13363 
        break
13364 
      if fid == 0:
3064 chandransh 13365 
        if ftype == TType.BOOL:
13366 
          self.success = iprot.readBool();
1408 ankur.sing 13367 
        else:
13368 
          iprot.skip(ftype)
3064 chandransh 13369 
      elif fid == 1:
13370 
        if ftype == TType.STRUCT:
13371 
          self.ex = TransactionServiceException()
13372 
          self.ex.read(iprot)
13373 
        else:
13374 
          iprot.skip(ftype)
1408 ankur.sing 13375 
      else:
13376 
        iprot.skip(ftype)
13377 
      iprot.readFieldEnd()
13378 
    iprot.readStructEnd()
13379 
 
13380 
  def write(self, oprot):
13381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13383 
      return
4910 phani.kuma 13384 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13385 
    if self.success is not None:
3064 chandransh 13386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13387 
      oprot.writeBool(self.success)
1408 ankur.sing 13388 
      oprot.writeFieldEnd()
3431 rajveer 13389 
    if self.ex is not None:
3064 chandransh 13390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13391 
      self.ex.write(oprot)
13392 
      oprot.writeFieldEnd()
1408 ankur.sing 13393 
    oprot.writeFieldStop()
13394 
    oprot.writeStructEnd()
13395 
 
3431 rajveer 13396 
  def validate(self):
13397 
    return
13398 
 
13399 
 
1408 ankur.sing 13400 
  def __repr__(self):
13401 
    L = ['%s=%r' % (key, value)
13402 
      for key, value in self.__dict__.iteritems()]
13403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13404 
 
13405 
  def __eq__(self, other):
13406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13407 
 
13408 
  def __ne__(self, other):
13409 
    return not (self == other)
13410 
 
5676 rajveer 13411 
class markOrdersAsReturnedFromStore_args:
13412 
  """
13413 
  Attributes:
13414 
   - providerId
13415 
   - orderIds
5713 rajveer 13416 
   - awbs
5676 rajveer 13417 
  """
13418 
 
13419 
  thrift_spec = (
13420 
    None, # 0
13421 
    (1, TType.I64, 'providerId', None, None, ), # 1
13422 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13423 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13424 
  )
13425 
 
5713 rajveer 13426 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13427 
    self.providerId = providerId
13428 
    self.orderIds = orderIds
5713 rajveer 13429 
    self.awbs = awbs
5676 rajveer 13430 
 
13431 
  def read(self, iprot):
13432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13434 
      return
13435 
    iprot.readStructBegin()
13436 
    while True:
13437 
      (fname, ftype, fid) = iprot.readFieldBegin()
13438 
      if ftype == TType.STOP:
13439 
        break
13440 
      if fid == 1:
13441 
        if ftype == TType.I64:
13442 
          self.providerId = iprot.readI64();
13443 
        else:
13444 
          iprot.skip(ftype)
13445 
      elif fid == 2:
13446 
        if ftype == TType.LIST:
13447 
          self.orderIds = []
6031 rajveer 13448 
          (_etype248, _size245) = iprot.readListBegin()
13449 
          for _i249 in xrange(_size245):
13450 
            _elem250 = iprot.readI64();
13451 
            self.orderIds.append(_elem250)
5676 rajveer 13452 
          iprot.readListEnd()
13453 
        else:
13454 
          iprot.skip(ftype)
5713 rajveer 13455 
      elif fid == 3:
13456 
        if ftype == TType.LIST:
13457 
          self.awbs = []
6031 rajveer 13458 
          (_etype254, _size251) = iprot.readListBegin()
13459 
          for _i255 in xrange(_size251):
13460 
            _elem256 = iprot.readString();
13461 
            self.awbs.append(_elem256)
5713 rajveer 13462 
          iprot.readListEnd()
13463 
        else:
13464 
          iprot.skip(ftype)
5676 rajveer 13465 
      else:
13466 
        iprot.skip(ftype)
13467 
      iprot.readFieldEnd()
13468 
    iprot.readStructEnd()
13469 
 
13470 
  def write(self, oprot):
13471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13473 
      return
13474 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13475 
    if self.providerId is not None:
13476 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13477 
      oprot.writeI64(self.providerId)
13478 
      oprot.writeFieldEnd()
13479 
    if self.orderIds is not None:
13480 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13481 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13482 
      for iter257 in self.orderIds:
13483 
        oprot.writeI64(iter257)
5676 rajveer 13484 
      oprot.writeListEnd()
13485 
      oprot.writeFieldEnd()
5713 rajveer 13486 
    if self.awbs is not None:
13487 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13488 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13489 
      for iter258 in self.awbs:
13490 
        oprot.writeString(iter258)
5713 rajveer 13491 
      oprot.writeListEnd()
13492 
      oprot.writeFieldEnd()
5676 rajveer 13493 
    oprot.writeFieldStop()
13494 
    oprot.writeStructEnd()
13495 
 
13496 
  def validate(self):
13497 
    return
13498 
 
13499 
 
13500 
  def __repr__(self):
13501 
    L = ['%s=%r' % (key, value)
13502 
      for key, value in self.__dict__.iteritems()]
13503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13504 
 
13505 
  def __eq__(self, other):
13506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13507 
 
13508 
  def __ne__(self, other):
13509 
    return not (self == other)
13510 
 
13511 
class markOrdersAsReturnedFromStore_result:
13512 
  """
13513 
  Attributes:
13514 
   - success
13515 
   - ex
13516 
  """
13517 
 
13518 
  thrift_spec = (
13519 
    (0, TType.BOOL, 'success', None, None, ), # 0
13520 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13521 
  )
13522 
 
13523 
  def __init__(self, success=None, ex=None,):
13524 
    self.success = success
13525 
    self.ex = ex
13526 
 
13527 
  def read(self, iprot):
13528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13530 
      return
13531 
    iprot.readStructBegin()
13532 
    while True:
13533 
      (fname, ftype, fid) = iprot.readFieldBegin()
13534 
      if ftype == TType.STOP:
13535 
        break
13536 
      if fid == 0:
13537 
        if ftype == TType.BOOL:
13538 
          self.success = iprot.readBool();
13539 
        else:
13540 
          iprot.skip(ftype)
13541 
      elif fid == 1:
13542 
        if ftype == TType.STRUCT:
13543 
          self.ex = TransactionServiceException()
13544 
          self.ex.read(iprot)
13545 
        else:
13546 
          iprot.skip(ftype)
13547 
      else:
13548 
        iprot.skip(ftype)
13549 
      iprot.readFieldEnd()
13550 
    iprot.readStructEnd()
13551 
 
13552 
  def write(self, oprot):
13553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13555 
      return
13556 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13557 
    if self.success is not None:
13558 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13559 
      oprot.writeBool(self.success)
13560 
      oprot.writeFieldEnd()
13561 
    if self.ex is not None:
13562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13563 
      self.ex.write(oprot)
13564 
      oprot.writeFieldEnd()
13565 
    oprot.writeFieldStop()
13566 
    oprot.writeStructEnd()
13567 
 
13568 
  def validate(self):
13569 
    return
13570 
 
13571 
 
13572 
  def __repr__(self):
13573 
    L = ['%s=%r' % (key, value)
13574 
      for key, value in self.__dict__.iteritems()]
13575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13576 
 
13577 
  def __eq__(self, other):
13578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13579 
 
13580 
  def __ne__(self, other):
13581 
    return not (self == other)
13582 
 
4910 phani.kuma 13583 
class markOrdersAsPickedUp_args:
4410 rajveer 13584 
  """
13585 
  Attributes:
13586 
   - providerId
4910 phani.kuma 13587 
   - pickupDetails
4410 rajveer 13588 
  """
13589 
 
13590 
  thrift_spec = (
13591 
    None, # 0
4910 phani.kuma 13592 
    (1, TType.I64, 'providerId', None, None, ), # 1
13593 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13594 
  )
13595 
 
4910 phani.kuma 13596 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13597 
    self.providerId = providerId
4910 phani.kuma 13598 
    self.pickupDetails = pickupDetails
4410 rajveer 13599 
 
13600 
  def read(self, iprot):
13601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13603 
      return
13604 
    iprot.readStructBegin()
13605 
    while True:
13606 
      (fname, ftype, fid) = iprot.readFieldBegin()
13607 
      if ftype == TType.STOP:
13608 
        break
13609 
      if fid == 1:
13610 
        if ftype == TType.I64:
4910 phani.kuma 13611 
          self.providerId = iprot.readI64();
4410 rajveer 13612 
        else:
13613 
          iprot.skip(ftype)
13614 
      elif fid == 2:
4910 phani.kuma 13615 
        if ftype == TType.MAP:
13616 
          self.pickupDetails = {}
6031 rajveer 13617 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13618 
          for _i263 in xrange(_size259):
13619 
            _key264 = iprot.readString();
13620 
            _val265 = iprot.readString();
13621 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13622 
          iprot.readMapEnd()
4410 rajveer 13623 
        else:
13624 
          iprot.skip(ftype)
13625 
      else:
13626 
        iprot.skip(ftype)
13627 
      iprot.readFieldEnd()
13628 
    iprot.readStructEnd()
13629 
 
13630 
  def write(self, oprot):
13631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13633 
      return
4910 phani.kuma 13634 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13635 
    if self.providerId is not None:
4910 phani.kuma 13636 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13637 
      oprot.writeI64(self.providerId)
13638 
      oprot.writeFieldEnd()
4910 phani.kuma 13639 
    if self.pickupDetails is not None:
13640 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13641 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 13642 
      for kiter266,viter267 in self.pickupDetails.items():
13643 
        oprot.writeString(kiter266)
13644 
        oprot.writeString(viter267)
4910 phani.kuma 13645 
      oprot.writeMapEnd()
4410 rajveer 13646 
      oprot.writeFieldEnd()
13647 
    oprot.writeFieldStop()
13648 
    oprot.writeStructEnd()
13649 
 
13650 
  def validate(self):
13651 
    return
13652 
 
13653 
 
13654 
  def __repr__(self):
13655 
    L = ['%s=%r' % (key, value)
13656 
      for key, value in self.__dict__.iteritems()]
13657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13658 
 
13659 
  def __eq__(self, other):
13660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13661 
 
13662 
  def __ne__(self, other):
13663 
    return not (self == other)
13664 
 
4910 phani.kuma 13665 
class markOrdersAsPickedUp_result:
4410 rajveer 13666 
  """
13667 
  Attributes:
13668 
   - ex
13669 
  """
13670 
 
13671 
  thrift_spec = (
4910 phani.kuma 13672 
    None, # 0
4410 rajveer 13673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13674 
  )
13675 
 
4910 phani.kuma 13676 
  def __init__(self, ex=None,):
4410 rajveer 13677 
    self.ex = ex
13678 
 
13679 
  def read(self, iprot):
13680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13682 
      return
13683 
    iprot.readStructBegin()
13684 
    while True:
13685 
      (fname, ftype, fid) = iprot.readFieldBegin()
13686 
      if ftype == TType.STOP:
13687 
        break
4910 phani.kuma 13688 
      if fid == 1:
4410 rajveer 13689 
        if ftype == TType.STRUCT:
13690 
          self.ex = TransactionServiceException()
13691 
          self.ex.read(iprot)
13692 
        else:
13693 
          iprot.skip(ftype)
13694 
      else:
13695 
        iprot.skip(ftype)
13696 
      iprot.readFieldEnd()
13697 
    iprot.readStructEnd()
13698 
 
13699 
  def write(self, oprot):
13700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13702 
      return
4910 phani.kuma 13703 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13704 
    if self.ex is not None:
13705 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13706 
      self.ex.write(oprot)
13707 
      oprot.writeFieldEnd()
13708 
    oprot.writeFieldStop()
13709 
    oprot.writeStructEnd()
13710 
 
13711 
  def validate(self):
13712 
    return
13713 
 
13714 
 
13715 
  def __repr__(self):
13716 
    L = ['%s=%r' % (key, value)
13717 
      for key, value in self.__dict__.iteritems()]
13718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13719 
 
13720 
  def __eq__(self, other):
13721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13722 
 
13723 
  def __ne__(self, other):
13724 
    return not (self == other)
13725 
 
4910 phani.kuma 13726 
class getOrdersNotPickedUp_args:
304 ashish 13727 
  """
13728 
  Attributes:
3064 chandransh 13729 
   - providerId
304 ashish 13730 
  """
94 ashish 13731 
 
304 ashish 13732 
  thrift_spec = (
13733 
    None, # 0
3064 chandransh 13734 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13735 
  )
13736 
 
4910 phani.kuma 13737 
  def __init__(self, providerId=None,):
3064 chandransh 13738 
    self.providerId = providerId
304 ashish 13739 
 
13740 
  def read(self, iprot):
13741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13743 
      return
13744 
    iprot.readStructBegin()
13745 
    while True:
13746 
      (fname, ftype, fid) = iprot.readFieldBegin()
13747 
      if ftype == TType.STOP:
13748 
        break
13749 
      if fid == 1:
13750 
        if ftype == TType.I64:
3064 chandransh 13751 
          self.providerId = iprot.readI64();
304 ashish 13752 
        else:
13753 
          iprot.skip(ftype)
13754 
      else:
13755 
        iprot.skip(ftype)
13756 
      iprot.readFieldEnd()
13757 
    iprot.readStructEnd()
13758 
 
13759 
  def write(self, oprot):
13760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13762 
      return
4910 phani.kuma 13763 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13764 
    if self.providerId is not None:
3064 chandransh 13765 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13766 
      oprot.writeI64(self.providerId)
304 ashish 13767 
      oprot.writeFieldEnd()
13768 
    oprot.writeFieldStop()
13769 
    oprot.writeStructEnd()
13770 
 
3431 rajveer 13771 
  def validate(self):
13772 
    return
13773 
 
13774 
 
304 ashish 13775 
  def __repr__(self):
13776 
    L = ['%s=%r' % (key, value)
13777 
      for key, value in self.__dict__.iteritems()]
13778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13779 
 
13780 
  def __eq__(self, other):
13781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13782 
 
13783 
  def __ne__(self, other):
13784 
    return not (self == other)
13785 
 
4910 phani.kuma 13786 
class getOrdersNotPickedUp_result:
304 ashish 13787 
  """
13788 
  Attributes:
13789 
   - success
13790 
  """
13791 
 
13792 
  thrift_spec = (
3064 chandransh 13793 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13794 
  )
13795 
 
4910 phani.kuma 13796 
  def __init__(self, success=None,):
304 ashish 13797 
    self.success = success
13798 
 
13799 
  def read(self, iprot):
13800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13802 
      return
13803 
    iprot.readStructBegin()
13804 
    while True:
13805 
      (fname, ftype, fid) = iprot.readFieldBegin()
13806 
      if ftype == TType.STOP:
13807 
        break
13808 
      if fid == 0:
13809 
        if ftype == TType.LIST:
13810 
          self.success = []
6031 rajveer 13811 
          (_etype271, _size268) = iprot.readListBegin()
13812 
          for _i272 in xrange(_size268):
13813 
            _elem273 = Order()
13814 
            _elem273.read(iprot)
13815 
            self.success.append(_elem273)
304 ashish 13816 
          iprot.readListEnd()
13817 
        else:
13818 
          iprot.skip(ftype)
13819 
      else:
13820 
        iprot.skip(ftype)
13821 
      iprot.readFieldEnd()
13822 
    iprot.readStructEnd()
13823 
 
13824 
  def write(self, oprot):
13825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13827 
      return
4910 phani.kuma 13828 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13829 
    if self.success is not None:
304 ashish 13830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 13832 
      for iter274 in self.success:
13833 
        iter274.write(oprot)
304 ashish 13834 
      oprot.writeListEnd()
13835 
      oprot.writeFieldEnd()
13836 
    oprot.writeFieldStop()
13837 
    oprot.writeStructEnd()
13838 
 
3431 rajveer 13839 
  def validate(self):
13840 
    return
13841 
 
13842 
 
304 ashish 13843 
  def __repr__(self):
13844 
    L = ['%s=%r' % (key, value)
13845 
      for key, value in self.__dict__.iteritems()]
13846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13847 
 
13848 
  def __eq__(self, other):
13849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13850 
 
13851 
  def __ne__(self, other):
13852 
    return not (self == other)
13853 
 
3064 chandransh 13854 
class markOrdersAsDelivered_args:
304 ashish 13855 
  """
13856 
  Attributes:
3064 chandransh 13857 
   - providerId
13858 
   - deliveredOrders
304 ashish 13859 
  """
13860 
 
13861 
  thrift_spec = (
13862 
    None, # 0
3064 chandransh 13863 
    (1, TType.I64, 'providerId', None, None, ), # 1
13864 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13865 
  )
13866 
 
3064 chandransh 13867 
  def __init__(self, providerId=None, deliveredOrders=None,):
13868 
    self.providerId = providerId
13869 
    self.deliveredOrders = deliveredOrders
304 ashish 13870 
 
13871 
  def read(self, iprot):
13872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13874 
      return
13875 
    iprot.readStructBegin()
13876 
    while True:
13877 
      (fname, ftype, fid) = iprot.readFieldBegin()
13878 
      if ftype == TType.STOP:
13879 
        break
13880 
      if fid == 1:
13881 
        if ftype == TType.I64:
3064 chandransh 13882 
          self.providerId = iprot.readI64();
304 ashish 13883 
        else:
13884 
          iprot.skip(ftype)
13885 
      elif fid == 2:
3064 chandransh 13886 
        if ftype == TType.MAP:
13887 
          self.deliveredOrders = {}
6031 rajveer 13888 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13889 
          for _i279 in xrange(_size275):
13890 
            _key280 = iprot.readString();
13891 
            _val281 = iprot.readString();
13892 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13893 
          iprot.readMapEnd()
304 ashish 13894 
        else:
13895 
          iprot.skip(ftype)
13896 
      else:
13897 
        iprot.skip(ftype)
13898 
      iprot.readFieldEnd()
13899 
    iprot.readStructEnd()
13900 
 
13901 
  def write(self, oprot):
13902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13904 
      return
3064 chandransh 13905 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13906 
    if self.providerId is not None:
3064 chandransh 13907 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13908 
      oprot.writeI64(self.providerId)
304 ashish 13909 
      oprot.writeFieldEnd()
3431 rajveer 13910 
    if self.deliveredOrders is not None:
3064 chandransh 13911 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13912 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 13913 
      for kiter282,viter283 in self.deliveredOrders.items():
13914 
        oprot.writeString(kiter282)
13915 
        oprot.writeString(viter283)
3064 chandransh 13916 
      oprot.writeMapEnd()
304 ashish 13917 
      oprot.writeFieldEnd()
13918 
    oprot.writeFieldStop()
13919 
    oprot.writeStructEnd()
13920 
 
3431 rajveer 13921 
  def validate(self):
13922 
    return
13923 
 
13924 
 
304 ashish 13925 
  def __repr__(self):
13926 
    L = ['%s=%r' % (key, value)
13927 
      for key, value in self.__dict__.iteritems()]
13928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13929 
 
13930 
  def __eq__(self, other):
13931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13932 
 
13933 
  def __ne__(self, other):
13934 
    return not (self == other)
13935 
 
3064 chandransh 13936 
class markOrdersAsDelivered_result:
13937 
  """
13938 
  Attributes:
13939 
   - ex
13940 
  """
304 ashish 13941 
 
13942 
  thrift_spec = (
3064 chandransh 13943 
    None, # 0
13944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13945 
  )
13946 
 
3064 chandransh 13947 
  def __init__(self, ex=None,):
13948 
    self.ex = ex
304 ashish 13949 
 
1596 ankur.sing 13950 
  def read(self, iprot):
13951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13953 
      return
13954 
    iprot.readStructBegin()
13955 
    while True:
13956 
      (fname, ftype, fid) = iprot.readFieldBegin()
13957 
      if ftype == TType.STOP:
13958 
        break
3064 chandransh 13959 
      if fid == 1:
13960 
        if ftype == TType.STRUCT:
13961 
          self.ex = TransactionServiceException()
13962 
          self.ex.read(iprot)
13963 
        else:
13964 
          iprot.skip(ftype)
1596 ankur.sing 13965 
      else:
13966 
        iprot.skip(ftype)
13967 
      iprot.readFieldEnd()
13968 
    iprot.readStructEnd()
13969 
 
13970 
  def write(self, oprot):
13971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13973 
      return
3064 chandransh 13974 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13975 
    if self.ex is not None:
3064 chandransh 13976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13977 
      self.ex.write(oprot)
13978 
      oprot.writeFieldEnd()
1596 ankur.sing 13979 
    oprot.writeFieldStop()
13980 
    oprot.writeStructEnd()
13981 
 
3431 rajveer 13982 
  def validate(self):
13983 
    return
13984 
 
13985 
 
1596 ankur.sing 13986 
  def __repr__(self):
13987 
    L = ['%s=%r' % (key, value)
13988 
      for key, value in self.__dict__.iteritems()]
13989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13990 
 
13991 
  def __eq__(self, other):
13992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13993 
 
13994 
  def __ne__(self, other):
13995 
    return not (self == other)
13996 
 
4910 phani.kuma 13997 
class markAsRTOrders_args:
1596 ankur.sing 13998 
  """
13999 
  Attributes:
3064 chandransh 14000 
   - providerId
14001 
   - returnedOrders
1596 ankur.sing 14002 
  """
14003 
 
14004 
  thrift_spec = (
3064 chandransh 14005 
    None, # 0
14006 
    (1, TType.I64, 'providerId', None, None, ), # 1
14007 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14008 
  )
14009 
 
3064 chandransh 14010 
  def __init__(self, providerId=None, returnedOrders=None,):
14011 
    self.providerId = providerId
14012 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14013 
 
14014 
  def read(self, iprot):
14015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14017 
      return
14018 
    iprot.readStructBegin()
14019 
    while True:
14020 
      (fname, ftype, fid) = iprot.readFieldBegin()
14021 
      if ftype == TType.STOP:
14022 
        break
3064 chandransh 14023 
      if fid == 1:
1596 ankur.sing 14024 
        if ftype == TType.I64:
3064 chandransh 14025 
          self.providerId = iprot.readI64();
1596 ankur.sing 14026 
        else:
14027 
          iprot.skip(ftype)
3064 chandransh 14028 
      elif fid == 2:
14029 
        if ftype == TType.MAP:
14030 
          self.returnedOrders = {}
6031 rajveer 14031 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14032 
          for _i288 in xrange(_size284):
14033 
            _key289 = iprot.readString();
14034 
            _val290 = iprot.readString();
14035 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14036 
          iprot.readMapEnd()
14037 
        else:
14038 
          iprot.skip(ftype)
1596 ankur.sing 14039 
      else:
14040 
        iprot.skip(ftype)
14041 
      iprot.readFieldEnd()
14042 
    iprot.readStructEnd()
14043 
 
14044 
  def write(self, oprot):
14045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14047 
      return
4910 phani.kuma 14048 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14049 
    if self.providerId is not None:
3064 chandransh 14050 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14051 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14052 
      oprot.writeFieldEnd()
3431 rajveer 14053 
    if self.returnedOrders is not None:
3064 chandransh 14054 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14055 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14056 
      for kiter291,viter292 in self.returnedOrders.items():
14057 
        oprot.writeString(kiter291)
14058 
        oprot.writeString(viter292)
3064 chandransh 14059 
      oprot.writeMapEnd()
14060 
      oprot.writeFieldEnd()
1596 ankur.sing 14061 
    oprot.writeFieldStop()
14062 
    oprot.writeStructEnd()
14063 
 
3431 rajveer 14064 
  def validate(self):
14065 
    return
14066 
 
14067 
 
1596 ankur.sing 14068 
  def __repr__(self):
14069 
    L = ['%s=%r' % (key, value)
14070 
      for key, value in self.__dict__.iteritems()]
14071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14072 
 
14073 
  def __eq__(self, other):
14074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14075 
 
14076 
  def __ne__(self, other):
14077 
    return not (self == other)
14078 
 
4910 phani.kuma 14079 
class markAsRTOrders_result:
3064 chandransh 14080 
  """
14081 
  Attributes:
14082 
   - ex
14083 
  """
1596 ankur.sing 14084 
 
1627 ankur.sing 14085 
  thrift_spec = (
3064 chandransh 14086 
    None, # 0
14087 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14088 
  )
14089 
 
3064 chandransh 14090 
  def __init__(self, ex=None,):
14091 
    self.ex = ex
14092 
 
1627 ankur.sing 14093 
  def read(self, iprot):
14094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14096 
      return
14097 
    iprot.readStructBegin()
14098 
    while True:
14099 
      (fname, ftype, fid) = iprot.readFieldBegin()
14100 
      if ftype == TType.STOP:
14101 
        break
3064 chandransh 14102 
      if fid == 1:
14103 
        if ftype == TType.STRUCT:
14104 
          self.ex = TransactionServiceException()
14105 
          self.ex.read(iprot)
14106 
        else:
14107 
          iprot.skip(ftype)
1627 ankur.sing 14108 
      else:
14109 
        iprot.skip(ftype)
14110 
      iprot.readFieldEnd()
14111 
    iprot.readStructEnd()
14112 
 
14113 
  def write(self, oprot):
14114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14116 
      return
4910 phani.kuma 14117 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14118 
    if self.ex is not None:
3064 chandransh 14119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14120 
      self.ex.write(oprot)
14121 
      oprot.writeFieldEnd()
1627 ankur.sing 14122 
    oprot.writeFieldStop()
14123 
    oprot.writeStructEnd()
14124 
 
3431 rajveer 14125 
  def validate(self):
14126 
    return
14127 
 
14128 
 
1627 ankur.sing 14129 
  def __repr__(self):
14130 
    L = ['%s=%r' % (key, value)
14131 
      for key, value in self.__dict__.iteritems()]
14132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14133 
 
14134 
  def __eq__(self, other):
14135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14136 
 
14137 
  def __ne__(self, other):
14138 
    return not (self == other)
14139 
 
4910 phani.kuma 14140 
class getRTOrders_args:
14141 
  """
14142 
  Attributes:
14143 
   - providerId
14144 
  """
14145 
 
14146 
  thrift_spec = (
14147 
    None, # 0
14148 
    (1, TType.I64, 'providerId', None, None, ), # 1
14149 
  )
14150 
 
14151 
  def __init__(self, providerId=None,):
14152 
    self.providerId = providerId
14153 
 
14154 
  def read(self, iprot):
14155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14157 
      return
14158 
    iprot.readStructBegin()
14159 
    while True:
14160 
      (fname, ftype, fid) = iprot.readFieldBegin()
14161 
      if ftype == TType.STOP:
14162 
        break
14163 
      if fid == 1:
14164 
        if ftype == TType.I64:
14165 
          self.providerId = iprot.readI64();
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('getRTOrders_args')
14178 
    if self.providerId is not None:
14179 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14180 
      oprot.writeI64(self.providerId)
14181 
      oprot.writeFieldEnd()
14182 
    oprot.writeFieldStop()
14183 
    oprot.writeStructEnd()
14184 
 
14185 
  def validate(self):
14186 
    return
14187 
 
14188 
 
14189 
  def __repr__(self):
14190 
    L = ['%s=%r' % (key, value)
14191 
      for key, value in self.__dict__.iteritems()]
14192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14193 
 
14194 
  def __eq__(self, other):
14195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14196 
 
14197 
  def __ne__(self, other):
14198 
    return not (self == other)
14199 
 
14200 
class getRTOrders_result:
14201 
  """
14202 
  Attributes:
14203 
   - success
14204 
  """
14205 
 
14206 
  thrift_spec = (
14207 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14208 
  )
14209 
 
14210 
  def __init__(self, success=None,):
14211 
    self.success = success
14212 
 
14213 
  def read(self, iprot):
14214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14216 
      return
14217 
    iprot.readStructBegin()
14218 
    while True:
14219 
      (fname, ftype, fid) = iprot.readFieldBegin()
14220 
      if ftype == TType.STOP:
14221 
        break
14222 
      if fid == 0:
14223 
        if ftype == TType.LIST:
14224 
          self.success = []
6031 rajveer 14225 
          (_etype296, _size293) = iprot.readListBegin()
14226 
          for _i297 in xrange(_size293):
14227 
            _elem298 = Order()
14228 
            _elem298.read(iprot)
14229 
            self.success.append(_elem298)
4910 phani.kuma 14230 
          iprot.readListEnd()
14231 
        else:
14232 
          iprot.skip(ftype)
14233 
      else:
14234 
        iprot.skip(ftype)
14235 
      iprot.readFieldEnd()
14236 
    iprot.readStructEnd()
14237 
 
14238 
  def write(self, oprot):
14239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14241 
      return
14242 
    oprot.writeStructBegin('getRTOrders_result')
14243 
    if self.success is not None:
14244 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14245 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14246 
      for iter299 in self.success:
14247 
        iter299.write(oprot)
4910 phani.kuma 14248 
      oprot.writeListEnd()
14249 
      oprot.writeFieldEnd()
14250 
    oprot.writeFieldStop()
14251 
    oprot.writeStructEnd()
14252 
 
14253 
  def validate(self):
14254 
    return
14255 
 
14256 
 
14257 
  def __repr__(self):
14258 
    L = ['%s=%r' % (key, value)
14259 
      for key, value in self.__dict__.iteritems()]
14260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14261 
 
14262 
  def __eq__(self, other):
14263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14264 
 
14265 
  def __ne__(self, other):
14266 
    return not (self == other)
14267 
 
3064 chandransh 14268 
class updateNonDeliveryReason_args:
1627 ankur.sing 14269 
  """
14270 
  Attributes:
3064 chandransh 14271 
   - providerId
14272 
   - undeliveredOrders
1627 ankur.sing 14273 
  """
14274 
 
14275 
  thrift_spec = (
3064 chandransh 14276 
    None, # 0
14277 
    (1, TType.I64, 'providerId', None, None, ), # 1
14278 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14279 
  )
14280 
 
3064 chandransh 14281 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14282 
    self.providerId = providerId
14283 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14284 
 
14285 
  def read(self, iprot):
14286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14288 
      return
14289 
    iprot.readStructBegin()
14290 
    while True:
14291 
      (fname, ftype, fid) = iprot.readFieldBegin()
14292 
      if ftype == TType.STOP:
14293 
        break
3064 chandransh 14294 
      if fid == 1:
1627 ankur.sing 14295 
        if ftype == TType.I64:
3064 chandransh 14296 
          self.providerId = iprot.readI64();
1627 ankur.sing 14297 
        else:
14298 
          iprot.skip(ftype)
3064 chandransh 14299 
      elif fid == 2:
14300 
        if ftype == TType.MAP:
14301 
          self.undeliveredOrders = {}
6031 rajveer 14302 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14303 
          for _i304 in xrange(_size300):
14304 
            _key305 = iprot.readString();
14305 
            _val306 = iprot.readString();
14306 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14307 
          iprot.readMapEnd()
14308 
        else:
14309 
          iprot.skip(ftype)
1627 ankur.sing 14310 
      else:
14311 
        iprot.skip(ftype)
14312 
      iprot.readFieldEnd()
14313 
    iprot.readStructEnd()
14314 
 
14315 
  def write(self, oprot):
14316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14318 
      return
3064 chandransh 14319 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14320 
    if self.providerId is not None:
3064 chandransh 14321 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14322 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14323 
      oprot.writeFieldEnd()
3431 rajveer 14324 
    if self.undeliveredOrders is not None:
3064 chandransh 14325 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14326 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14327 
      for kiter307,viter308 in self.undeliveredOrders.items():
14328 
        oprot.writeString(kiter307)
14329 
        oprot.writeString(viter308)
3064 chandransh 14330 
      oprot.writeMapEnd()
14331 
      oprot.writeFieldEnd()
1627 ankur.sing 14332 
    oprot.writeFieldStop()
14333 
    oprot.writeStructEnd()
14334 
 
3431 rajveer 14335 
  def validate(self):
14336 
    return
14337 
 
14338 
 
1627 ankur.sing 14339 
  def __repr__(self):
14340 
    L = ['%s=%r' % (key, value)
14341 
      for key, value in self.__dict__.iteritems()]
14342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14343 
 
14344 
  def __eq__(self, other):
14345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14346 
 
14347 
  def __ne__(self, other):
14348 
    return not (self == other)
14349 
 
3064 chandransh 14350 
class updateNonDeliveryReason_result:
1627 ankur.sing 14351 
  """
14352 
  Attributes:
3064 chandransh 14353 
   - ex
1627 ankur.sing 14354 
  """
14355 
 
14356 
  thrift_spec = (
4910 phani.kuma 14357 
    None, # 0
3064 chandransh 14358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14359 
  )
14360 
 
4910 phani.kuma 14361 
  def __init__(self, ex=None,):
3064 chandransh 14362 
    self.ex = ex
1627 ankur.sing 14363 
 
14364 
  def read(self, iprot):
14365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14367 
      return
14368 
    iprot.readStructBegin()
14369 
    while True:
14370 
      (fname, ftype, fid) = iprot.readFieldBegin()
14371 
      if ftype == TType.STOP:
14372 
        break
4910 phani.kuma 14373 
      if fid == 1:
14374 
        if ftype == TType.STRUCT:
14375 
          self.ex = TransactionServiceException()
14376 
          self.ex.read(iprot)
14377 
        else:
14378 
          iprot.skip(ftype)
14379 
      else:
14380 
        iprot.skip(ftype)
14381 
      iprot.readFieldEnd()
14382 
    iprot.readStructEnd()
14383 
 
14384 
  def write(self, oprot):
14385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14387 
      return
14388 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14389 
    if self.ex is not None:
14390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14391 
      self.ex.write(oprot)
14392 
      oprot.writeFieldEnd()
14393 
    oprot.writeFieldStop()
14394 
    oprot.writeStructEnd()
14395 
 
14396 
  def validate(self):
14397 
    return
14398 
 
14399 
 
14400 
  def __repr__(self):
14401 
    L = ['%s=%r' % (key, value)
14402 
      for key, value in self.__dict__.iteritems()]
14403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14404 
 
14405 
  def __eq__(self, other):
14406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14407 
 
14408 
  def __ne__(self, other):
14409 
    return not (self == other)
14410 
 
14411 
class getNonDeliveredOrdersbyCourier_args:
14412 
  """
14413 
  Attributes:
14414 
   - providerId
14415 
  """
14416 
 
14417 
  thrift_spec = (
14418 
    None, # 0
14419 
    (1, TType.I64, 'providerId', None, None, ), # 1
14420 
  )
14421 
 
14422 
  def __init__(self, providerId=None,):
14423 
    self.providerId = providerId
14424 
 
14425 
  def read(self, iprot):
14426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14428 
      return
14429 
    iprot.readStructBegin()
14430 
    while True:
14431 
      (fname, ftype, fid) = iprot.readFieldBegin()
14432 
      if ftype == TType.STOP:
14433 
        break
14434 
      if fid == 1:
14435 
        if ftype == TType.I64:
14436 
          self.providerId = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      else:
14440 
        iprot.skip(ftype)
14441 
      iprot.readFieldEnd()
14442 
    iprot.readStructEnd()
14443 
 
14444 
  def write(self, oprot):
14445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14447 
      return
14448 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14449 
    if self.providerId is not None:
14450 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14451 
      oprot.writeI64(self.providerId)
14452 
      oprot.writeFieldEnd()
14453 
    oprot.writeFieldStop()
14454 
    oprot.writeStructEnd()
14455 
 
14456 
  def validate(self):
14457 
    return
14458 
 
14459 
 
14460 
  def __repr__(self):
14461 
    L = ['%s=%r' % (key, value)
14462 
      for key, value in self.__dict__.iteritems()]
14463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14464 
 
14465 
  def __eq__(self, other):
14466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14467 
 
14468 
  def __ne__(self, other):
14469 
    return not (self == other)
14470 
 
14471 
class getNonDeliveredOrdersbyCourier_result:
14472 
  """
14473 
  Attributes:
14474 
   - success
14475 
  """
14476 
 
14477 
  thrift_spec = (
14478 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14479 
  )
14480 
 
14481 
  def __init__(self, success=None,):
14482 
    self.success = success
14483 
 
14484 
  def read(self, iprot):
14485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14487 
      return
14488 
    iprot.readStructBegin()
14489 
    while True:
14490 
      (fname, ftype, fid) = iprot.readFieldBegin()
14491 
      if ftype == TType.STOP:
14492 
        break
4581 phani.kuma 14493 
      if fid == 0:
14494 
        if ftype == TType.LIST:
14495 
          self.success = []
6031 rajveer 14496 
          (_etype312, _size309) = iprot.readListBegin()
14497 
          for _i313 in xrange(_size309):
14498 
            _elem314 = Order()
14499 
            _elem314.read(iprot)
14500 
            self.success.append(_elem314)
4581 phani.kuma 14501 
          iprot.readListEnd()
14502 
        else:
14503 
          iprot.skip(ftype)
4910 phani.kuma 14504 
      else:
14505 
        iprot.skip(ftype)
14506 
      iprot.readFieldEnd()
14507 
    iprot.readStructEnd()
14508 
 
14509 
  def write(self, oprot):
14510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14512 
      return
14513 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14514 
    if self.success is not None:
14515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14517 
      for iter315 in self.success:
14518 
        iter315.write(oprot)
4910 phani.kuma 14519 
      oprot.writeListEnd()
14520 
      oprot.writeFieldEnd()
14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
14539 
class markOrdersAsLocalConnected_args:
14540 
  """
14541 
  Attributes:
14542 
   - providerId
14543 
   - local_connected_orders
14544 
  """
14545 
 
14546 
  thrift_spec = (
14547 
    None, # 0
14548 
    (1, TType.I64, 'providerId', None, None, ), # 1
14549 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14550 
  )
14551 
 
14552 
  def __init__(self, providerId=None, local_connected_orders=None,):
14553 
    self.providerId = providerId
14554 
    self.local_connected_orders = local_connected_orders
14555 
 
14556 
  def read(self, iprot):
14557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14559 
      return
14560 
    iprot.readStructBegin()
14561 
    while True:
14562 
      (fname, ftype, fid) = iprot.readFieldBegin()
14563 
      if ftype == TType.STOP:
14564 
        break
14565 
      if fid == 1:
14566 
        if ftype == TType.I64:
14567 
          self.providerId = iprot.readI64();
14568 
        else:
14569 
          iprot.skip(ftype)
14570 
      elif fid == 2:
14571 
        if ftype == TType.MAP:
14572 
          self.local_connected_orders = {}
6031 rajveer 14573 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14574 
          for _i320 in xrange(_size316):
14575 
            _key321 = iprot.readString();
14576 
            _val322 = iprot.readString();
14577 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14578 
          iprot.readMapEnd()
14579 
        else:
14580 
          iprot.skip(ftype)
14581 
      else:
14582 
        iprot.skip(ftype)
14583 
      iprot.readFieldEnd()
14584 
    iprot.readStructEnd()
14585 
 
14586 
  def write(self, oprot):
14587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14589 
      return
14590 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14591 
    if self.providerId is not None:
14592 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14593 
      oprot.writeI64(self.providerId)
14594 
      oprot.writeFieldEnd()
14595 
    if self.local_connected_orders is not None:
14596 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14597 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14598 
      for kiter323,viter324 in self.local_connected_orders.items():
14599 
        oprot.writeString(kiter323)
14600 
        oprot.writeString(viter324)
4910 phani.kuma 14601 
      oprot.writeMapEnd()
14602 
      oprot.writeFieldEnd()
14603 
    oprot.writeFieldStop()
14604 
    oprot.writeStructEnd()
14605 
 
14606 
  def validate(self):
14607 
    return
14608 
 
14609 
 
14610 
  def __repr__(self):
14611 
    L = ['%s=%r' % (key, value)
14612 
      for key, value in self.__dict__.iteritems()]
14613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14614 
 
14615 
  def __eq__(self, other):
14616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14617 
 
14618 
  def __ne__(self, other):
14619 
    return not (self == other)
14620 
 
14621 
class markOrdersAsLocalConnected_result:
14622 
  """
14623 
  Attributes:
14624 
   - ex
14625 
  """
14626 
 
14627 
  thrift_spec = (
14628 
    None, # 0
14629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14630 
  )
14631 
 
14632 
  def __init__(self, ex=None,):
14633 
    self.ex = ex
14634 
 
14635 
  def read(self, iprot):
14636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14638 
      return
14639 
    iprot.readStructBegin()
14640 
    while True:
14641 
      (fname, ftype, fid) = iprot.readFieldBegin()
14642 
      if ftype == TType.STOP:
14643 
        break
14644 
      if fid == 1:
3064 chandransh 14645 
        if ftype == TType.STRUCT:
14646 
          self.ex = TransactionServiceException()
14647 
          self.ex.read(iprot)
1627 ankur.sing 14648 
        else:
14649 
          iprot.skip(ftype)
14650 
      else:
14651 
        iprot.skip(ftype)
14652 
      iprot.readFieldEnd()
14653 
    iprot.readStructEnd()
14654 
 
14655 
  def write(self, oprot):
14656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14658 
      return
4910 phani.kuma 14659 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14660 
    if self.ex is not None:
14661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14662 
      self.ex.write(oprot)
14663 
      oprot.writeFieldEnd()
14664 
    oprot.writeFieldStop()
14665 
    oprot.writeStructEnd()
14666 
 
14667 
  def validate(self):
14668 
    return
14669 
 
14670 
 
14671 
  def __repr__(self):
14672 
    L = ['%s=%r' % (key, value)
14673 
      for key, value in self.__dict__.iteritems()]
14674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14675 
 
14676 
  def __eq__(self, other):
14677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14678 
 
14679 
  def __ne__(self, other):
14680 
    return not (self == other)
14681 
 
14682 
class getOrdersNotLocalConnected_args:
14683 
  """
14684 
  Attributes:
14685 
   - providerId
14686 
  """
14687 
 
14688 
  thrift_spec = (
14689 
    None, # 0
14690 
    (1, TType.I64, 'providerId', None, None, ), # 1
14691 
  )
14692 
 
14693 
  def __init__(self, providerId=None,):
14694 
    self.providerId = providerId
14695 
 
14696 
  def read(self, iprot):
14697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14699 
      return
14700 
    iprot.readStructBegin()
14701 
    while True:
14702 
      (fname, ftype, fid) = iprot.readFieldBegin()
14703 
      if ftype == TType.STOP:
14704 
        break
14705 
      if fid == 1:
14706 
        if ftype == TType.I64:
14707 
          self.providerId = iprot.readI64();
14708 
        else:
14709 
          iprot.skip(ftype)
14710 
      else:
14711 
        iprot.skip(ftype)
14712 
      iprot.readFieldEnd()
14713 
    iprot.readStructEnd()
14714 
 
14715 
  def write(self, oprot):
14716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14718 
      return
14719 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14720 
    if self.providerId is not None:
14721 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14722 
      oprot.writeI64(self.providerId)
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
14742 
class getOrdersNotLocalConnected_result:
14743 
  """
14744 
  Attributes:
14745 
   - success
14746 
  """
14747 
 
14748 
  thrift_spec = (
14749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14750 
  )
14751 
 
14752 
  def __init__(self, success=None,):
14753 
    self.success = success
14754 
 
14755 
  def read(self, iprot):
14756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14758 
      return
14759 
    iprot.readStructBegin()
14760 
    while True:
14761 
      (fname, ftype, fid) = iprot.readFieldBegin()
14762 
      if ftype == TType.STOP:
14763 
        break
14764 
      if fid == 0:
14765 
        if ftype == TType.LIST:
14766 
          self.success = []
6031 rajveer 14767 
          (_etype328, _size325) = iprot.readListBegin()
14768 
          for _i329 in xrange(_size325):
14769 
            _elem330 = Order()
14770 
            _elem330.read(iprot)
14771 
            self.success.append(_elem330)
4910 phani.kuma 14772 
          iprot.readListEnd()
14773 
        else:
14774 
          iprot.skip(ftype)
14775 
      else:
14776 
        iprot.skip(ftype)
14777 
      iprot.readFieldEnd()
14778 
    iprot.readStructEnd()
14779 
 
14780 
  def write(self, oprot):
14781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14783 
      return
14784 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14785 
    if self.success is not None:
14786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14788 
      for iter331 in self.success:
14789 
        iter331.write(oprot)
4581 phani.kuma 14790 
      oprot.writeListEnd()
14791 
      oprot.writeFieldEnd()
4910 phani.kuma 14792 
    oprot.writeFieldStop()
14793 
    oprot.writeStructEnd()
14794 
 
14795 
  def validate(self):
14796 
    return
14797 
 
14798 
 
14799 
  def __repr__(self):
14800 
    L = ['%s=%r' % (key, value)
14801 
      for key, value in self.__dict__.iteritems()]
14802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14803 
 
14804 
  def __eq__(self, other):
14805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14806 
 
14807 
  def __ne__(self, other):
14808 
    return not (self == other)
14809 
 
14810 
class markOrdersAsDestinationCityReached_args:
14811 
  """
14812 
  Attributes:
14813 
   - providerId
14814 
   - destination_city_reached_orders
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    None, # 0
14819 
    (1, TType.I64, 'providerId', None, None, ), # 1
14820 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14821 
  )
14822 
 
14823 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14824 
    self.providerId = providerId
14825 
    self.destination_city_reached_orders = destination_city_reached_orders
14826 
 
14827 
  def read(self, iprot):
14828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14830 
      return
14831 
    iprot.readStructBegin()
14832 
    while True:
14833 
      (fname, ftype, fid) = iprot.readFieldBegin()
14834 
      if ftype == TType.STOP:
14835 
        break
14836 
      if fid == 1:
14837 
        if ftype == TType.I64:
14838 
          self.providerId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      elif fid == 2:
14842 
        if ftype == TType.MAP:
14843 
          self.destination_city_reached_orders = {}
6031 rajveer 14844 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14845 
          for _i336 in xrange(_size332):
14846 
            _key337 = iprot.readString();
14847 
            _val338 = iprot.readString();
14848 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14849 
          iprot.readMapEnd()
14850 
        else:
14851 
          iprot.skip(ftype)
14852 
      else:
14853 
        iprot.skip(ftype)
14854 
      iprot.readFieldEnd()
14855 
    iprot.readStructEnd()
14856 
 
14857 
  def write(self, oprot):
14858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14860 
      return
14861 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14862 
    if self.providerId is not None:
14863 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14864 
      oprot.writeI64(self.providerId)
14865 
      oprot.writeFieldEnd()
14866 
    if self.destination_city_reached_orders is not None:
14867 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14868 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 14869 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14870 
        oprot.writeString(kiter339)
14871 
        oprot.writeString(viter340)
4910 phani.kuma 14872 
      oprot.writeMapEnd()
14873 
      oprot.writeFieldEnd()
14874 
    oprot.writeFieldStop()
14875 
    oprot.writeStructEnd()
14876 
 
14877 
  def validate(self):
14878 
    return
14879 
 
14880 
 
14881 
  def __repr__(self):
14882 
    L = ['%s=%r' % (key, value)
14883 
      for key, value in self.__dict__.iteritems()]
14884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14885 
 
14886 
  def __eq__(self, other):
14887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14888 
 
14889 
  def __ne__(self, other):
14890 
    return not (self == other)
14891 
 
14892 
class markOrdersAsDestinationCityReached_result:
14893 
  """
14894 
  Attributes:
14895 
   - ex
14896 
  """
14897 
 
14898 
  thrift_spec = (
14899 
    None, # 0
14900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14901 
  )
14902 
 
14903 
  def __init__(self, ex=None,):
14904 
    self.ex = ex
14905 
 
14906 
  def read(self, iprot):
14907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14909 
      return
14910 
    iprot.readStructBegin()
14911 
    while True:
14912 
      (fname, ftype, fid) = iprot.readFieldBegin()
14913 
      if ftype == TType.STOP:
14914 
        break
14915 
      if fid == 1:
14916 
        if ftype == TType.STRUCT:
14917 
          self.ex = TransactionServiceException()
14918 
          self.ex.read(iprot)
14919 
        else:
14920 
          iprot.skip(ftype)
14921 
      else:
14922 
        iprot.skip(ftype)
14923 
      iprot.readFieldEnd()
14924 
    iprot.readStructEnd()
14925 
 
14926 
  def write(self, oprot):
14927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14929 
      return
14930 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14931 
    if self.ex is not None:
3064 chandransh 14932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14933 
      self.ex.write(oprot)
1627 ankur.sing 14934 
      oprot.writeFieldEnd()
14935 
    oprot.writeFieldStop()
14936 
    oprot.writeStructEnd()
14937 
 
3431 rajveer 14938 
  def validate(self):
14939 
    return
14940 
 
14941 
 
1627 ankur.sing 14942 
  def __repr__(self):
14943 
    L = ['%s=%r' % (key, value)
14944 
      for key, value in self.__dict__.iteritems()]
14945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14946 
 
14947 
  def __eq__(self, other):
14948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14949 
 
14950 
  def __ne__(self, other):
14951 
    return not (self == other)
14952 
 
4910 phani.kuma 14953 
class markOrdersAsFirstDeliveryAttempted_args:
14954 
  """
14955 
  Attributes:
14956 
   - providerId
14957 
   - first_atdl_orders
14958 
  """
14959 
 
14960 
  thrift_spec = (
14961 
    None, # 0
14962 
    (1, TType.I64, 'providerId', None, None, ), # 1
14963 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14964 
  )
14965 
 
14966 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14967 
    self.providerId = providerId
14968 
    self.first_atdl_orders = first_atdl_orders
14969 
 
14970 
  def read(self, iprot):
14971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14973 
      return
14974 
    iprot.readStructBegin()
14975 
    while True:
14976 
      (fname, ftype, fid) = iprot.readFieldBegin()
14977 
      if ftype == TType.STOP:
14978 
        break
14979 
      if fid == 1:
14980 
        if ftype == TType.I64:
14981 
          self.providerId = iprot.readI64();
14982 
        else:
14983 
          iprot.skip(ftype)
14984 
      elif fid == 2:
14985 
        if ftype == TType.MAP:
14986 
          self.first_atdl_orders = {}
6031 rajveer 14987 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
14988 
          for _i345 in xrange(_size341):
14989 
            _key346 = iprot.readString();
14990 
            _val347 = iprot.readString();
14991 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 14992 
          iprot.readMapEnd()
14993 
        else:
14994 
          iprot.skip(ftype)
14995 
      else:
14996 
        iprot.skip(ftype)
14997 
      iprot.readFieldEnd()
14998 
    iprot.readStructEnd()
14999 
 
15000 
  def write(self, oprot):
15001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15003 
      return
15004 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15005 
    if self.providerId is not None:
15006 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15007 
      oprot.writeI64(self.providerId)
15008 
      oprot.writeFieldEnd()
15009 
    if self.first_atdl_orders is not None:
15010 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15011 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15012 
      for kiter348,viter349 in self.first_atdl_orders.items():
15013 
        oprot.writeString(kiter348)
15014 
        oprot.writeString(viter349)
4910 phani.kuma 15015 
      oprot.writeMapEnd()
15016 
      oprot.writeFieldEnd()
15017 
    oprot.writeFieldStop()
15018 
    oprot.writeStructEnd()
15019 
 
15020 
  def validate(self):
15021 
    return
15022 
 
15023 
 
15024 
  def __repr__(self):
15025 
    L = ['%s=%r' % (key, value)
15026 
      for key, value in self.__dict__.iteritems()]
15027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15028 
 
15029 
  def __eq__(self, other):
15030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15031 
 
15032 
  def __ne__(self, other):
15033 
    return not (self == other)
15034 
 
15035 
class markOrdersAsFirstDeliveryAttempted_result:
15036 
  """
15037 
  Attributes:
15038 
   - ex
15039 
  """
15040 
 
15041 
  thrift_spec = (
15042 
    None, # 0
15043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15044 
  )
15045 
 
15046 
  def __init__(self, ex=None,):
15047 
    self.ex = ex
15048 
 
15049 
  def read(self, iprot):
15050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15052 
      return
15053 
    iprot.readStructBegin()
15054 
    while True:
15055 
      (fname, ftype, fid) = iprot.readFieldBegin()
15056 
      if ftype == TType.STOP:
15057 
        break
15058 
      if fid == 1:
15059 
        if ftype == TType.STRUCT:
15060 
          self.ex = TransactionServiceException()
15061 
          self.ex.read(iprot)
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
15073 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15074 
    if self.ex is not None:
15075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15076 
      self.ex.write(oprot)
15077 
      oprot.writeFieldEnd()
15078 
    oprot.writeFieldStop()
15079 
    oprot.writeStructEnd()
15080 
 
15081 
  def validate(self):
15082 
    return
15083 
 
15084 
 
15085 
  def __repr__(self):
15086 
    L = ['%s=%r' % (key, value)
15087 
      for key, value in self.__dict__.iteritems()]
15088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15089 
 
15090 
  def __eq__(self, other):
15091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15092 
 
15093 
  def __ne__(self, other):
15094 
    return not (self == other)
15095 
 
3064 chandransh 15096 
class getUndeliveredOrders_args:
1886 ankur.sing 15097 
  """
15098 
  Attributes:
3064 chandransh 15099 
   - providerId
15100 
   - warehouseId
1886 ankur.sing 15101 
  """
1627 ankur.sing 15102 
 
1886 ankur.sing 15103 
  thrift_spec = (
15104 
    None, # 0
3064 chandransh 15105 
    (1, TType.I64, 'providerId', None, None, ), # 1
15106 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15107 
  )
15108 
 
3064 chandransh 15109 
  def __init__(self, providerId=None, warehouseId=None,):
15110 
    self.providerId = providerId
15111 
    self.warehouseId = warehouseId
1886 ankur.sing 15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
15122 
      if fid == 1:
15123 
        if ftype == TType.I64:
3064 chandransh 15124 
          self.providerId = iprot.readI64();
1886 ankur.sing 15125 
        else:
15126 
          iprot.skip(ftype)
3064 chandransh 15127 
      elif fid == 2:
15128 
        if ftype == TType.I64:
15129 
          self.warehouseId = iprot.readI64();
15130 
        else:
15131 
          iprot.skip(ftype)
1886 ankur.sing 15132 
      else:
15133 
        iprot.skip(ftype)
15134 
      iprot.readFieldEnd()
15135 
    iprot.readStructEnd()
15136 
 
15137 
  def write(self, oprot):
15138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15140 
      return
3064 chandransh 15141 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15142 
    if self.providerId is not None:
3064 chandransh 15143 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15144 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15145 
      oprot.writeFieldEnd()
3431 rajveer 15146 
    if self.warehouseId is not None:
3064 chandransh 15147 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15148 
      oprot.writeI64(self.warehouseId)
15149 
      oprot.writeFieldEnd()
1886 ankur.sing 15150 
    oprot.writeFieldStop()
15151 
    oprot.writeStructEnd()
15152 
 
3431 rajveer 15153 
  def validate(self):
15154 
    return
15155 
 
15156 
 
1886 ankur.sing 15157 
  def __repr__(self):
15158 
    L = ['%s=%r' % (key, value)
15159 
      for key, value in self.__dict__.iteritems()]
15160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15161 
 
15162 
  def __eq__(self, other):
15163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15164 
 
15165 
  def __ne__(self, other):
15166 
    return not (self == other)
15167 
 
3064 chandransh 15168 
class getUndeliveredOrders_result:
1886 ankur.sing 15169 
  """
15170 
  Attributes:
15171 
   - success
15172 
  """
15173 
 
15174 
  thrift_spec = (
15175 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15176 
  )
15177 
 
15178 
  def __init__(self, success=None,):
15179 
    self.success = success
15180 
 
15181 
  def read(self, iprot):
15182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15184 
      return
15185 
    iprot.readStructBegin()
15186 
    while True:
15187 
      (fname, ftype, fid) = iprot.readFieldBegin()
15188 
      if ftype == TType.STOP:
15189 
        break
15190 
      if fid == 0:
15191 
        if ftype == TType.LIST:
15192 
          self.success = []
6031 rajveer 15193 
          (_etype353, _size350) = iprot.readListBegin()
15194 
          for _i354 in xrange(_size350):
15195 
            _elem355 = Order()
15196 
            _elem355.read(iprot)
15197 
            self.success.append(_elem355)
1886 ankur.sing 15198 
          iprot.readListEnd()
15199 
        else:
15200 
          iprot.skip(ftype)
15201 
      else:
15202 
        iprot.skip(ftype)
15203 
      iprot.readFieldEnd()
15204 
    iprot.readStructEnd()
15205 
 
15206 
  def write(self, oprot):
15207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15209 
      return
3064 chandransh 15210 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15211 
    if self.success is not None:
1886 ankur.sing 15212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15213 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15214 
      for iter356 in self.success:
15215 
        iter356.write(oprot)
1886 ankur.sing 15216 
      oprot.writeListEnd()
15217 
      oprot.writeFieldEnd()
15218 
    oprot.writeFieldStop()
15219 
    oprot.writeStructEnd()
15220 
 
3431 rajveer 15221 
  def validate(self):
15222 
    return
15223 
 
15224 
 
1886 ankur.sing 15225 
  def __repr__(self):
15226 
    L = ['%s=%r' % (key, value)
15227 
      for key, value in self.__dict__.iteritems()]
15228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15229 
 
15230 
  def __eq__(self, other):
15231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15232 
 
15233 
  def __ne__(self, other):
15234 
    return not (self == other)
15235 
 
4783 phani.kuma 15236 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15237 
 
15238 
  thrift_spec = (
15239 
  )
15240 
 
15241 
  def read(self, iprot):
15242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15244 
      return
15245 
    iprot.readStructBegin()
15246 
    while True:
15247 
      (fname, ftype, fid) = iprot.readFieldBegin()
15248 
      if ftype == TType.STOP:
15249 
        break
15250 
      else:
15251 
        iprot.skip(ftype)
15252 
      iprot.readFieldEnd()
15253 
    iprot.readStructEnd()
15254 
 
15255 
  def write(self, oprot):
15256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15258 
      return
15259 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15260 
    oprot.writeFieldStop()
15261 
    oprot.writeStructEnd()
15262 
 
15263 
  def validate(self):
15264 
    return
15265 
 
15266 
 
15267 
  def __repr__(self):
15268 
    L = ['%s=%r' % (key, value)
15269 
      for key, value in self.__dict__.iteritems()]
15270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15271 
 
15272 
  def __eq__(self, other):
15273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15274 
 
15275 
  def __ne__(self, other):
15276 
    return not (self == other)
15277 
 
15278 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15279 
  """
15280 
  Attributes:
15281 
   - success
15282 
  """
15283 
 
15284 
  thrift_spec = (
15285 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15286 
  )
15287 
 
15288 
  def __init__(self, success=None,):
15289 
    self.success = success
15290 
 
15291 
  def read(self, iprot):
15292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15294 
      return
15295 
    iprot.readStructBegin()
15296 
    while True:
15297 
      (fname, ftype, fid) = iprot.readFieldBegin()
15298 
      if ftype == TType.STOP:
15299 
        break
15300 
      if fid == 0:
15301 
        if ftype == TType.LIST:
15302 
          self.success = []
6031 rajveer 15303 
          (_etype360, _size357) = iprot.readListBegin()
15304 
          for _i361 in xrange(_size357):
15305 
            _elem362 = Order()
15306 
            _elem362.read(iprot)
15307 
            self.success.append(_elem362)
4783 phani.kuma 15308 
          iprot.readListEnd()
15309 
        else:
15310 
          iprot.skip(ftype)
15311 
      else:
15312 
        iprot.skip(ftype)
15313 
      iprot.readFieldEnd()
15314 
    iprot.readStructEnd()
15315 
 
15316 
  def write(self, oprot):
15317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15319 
      return
15320 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15321 
    if self.success is not None:
15322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15324 
      for iter363 in self.success:
15325 
        iter363.write(oprot)
4783 phani.kuma 15326 
      oprot.writeListEnd()
15327 
      oprot.writeFieldEnd()
15328 
    oprot.writeFieldStop()
15329 
    oprot.writeStructEnd()
15330 
 
15331 
  def validate(self):
15332 
    return
15333 
 
15334 
 
15335 
  def __repr__(self):
15336 
    L = ['%s=%r' % (key, value)
15337 
      for key, value in self.__dict__.iteritems()]
15338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15339 
 
15340 
  def __eq__(self, other):
15341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15342 
 
15343 
  def __ne__(self, other):
15344 
    return not (self == other)
15345 
 
2536 chandransh 15346 
class toggleDOAFlag_args:
15347 
  """
15348 
  Attributes:
15349 
   - orderId
15350 
  """
1886 ankur.sing 15351 
 
2536 chandransh 15352 
  thrift_spec = (
15353 
    None, # 0
15354 
    (1, TType.I64, 'orderId', None, None, ), # 1
15355 
  )
15356 
 
15357 
  def __init__(self, orderId=None,):
15358 
    self.orderId = orderId
15359 
 
15360 
  def read(self, iprot):
15361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15363 
      return
15364 
    iprot.readStructBegin()
15365 
    while True:
15366 
      (fname, ftype, fid) = iprot.readFieldBegin()
15367 
      if ftype == TType.STOP:
15368 
        break
15369 
      if fid == 1:
15370 
        if ftype == TType.I64:
15371 
          self.orderId = iprot.readI64();
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      else:
15375 
        iprot.skip(ftype)
15376 
      iprot.readFieldEnd()
15377 
    iprot.readStructEnd()
15378 
 
15379 
  def write(self, oprot):
15380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15382 
      return
15383 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15384 
    if self.orderId is not None:
2536 chandransh 15385 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15386 
      oprot.writeI64(self.orderId)
15387 
      oprot.writeFieldEnd()
15388 
    oprot.writeFieldStop()
15389 
    oprot.writeStructEnd()
15390 
 
3431 rajveer 15391 
  def validate(self):
15392 
    return
15393 
 
15394 
 
2536 chandransh 15395 
  def __repr__(self):
15396 
    L = ['%s=%r' % (key, value)
15397 
      for key, value in self.__dict__.iteritems()]
15398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15399 
 
15400 
  def __eq__(self, other):
15401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15402 
 
15403 
  def __ne__(self, other):
15404 
    return not (self == other)
15405 
 
15406 
class toggleDOAFlag_result:
15407 
  """
15408 
  Attributes:
15409 
   - success
15410 
   - ex
15411 
  """
15412 
 
15413 
  thrift_spec = (
15414 
    (0, TType.BOOL, 'success', None, None, ), # 0
15415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15416 
  )
15417 
 
15418 
  def __init__(self, success=None, ex=None,):
15419 
    self.success = success
15420 
    self.ex = ex
15421 
 
15422 
  def read(self, iprot):
15423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15425 
      return
15426 
    iprot.readStructBegin()
15427 
    while True:
15428 
      (fname, ftype, fid) = iprot.readFieldBegin()
15429 
      if ftype == TType.STOP:
15430 
        break
15431 
      if fid == 0:
15432 
        if ftype == TType.BOOL:
15433 
          self.success = iprot.readBool();
15434 
        else:
15435 
          iprot.skip(ftype)
15436 
      elif fid == 1:
15437 
        if ftype == TType.STRUCT:
15438 
          self.ex = TransactionServiceException()
15439 
          self.ex.read(iprot)
15440 
        else:
15441 
          iprot.skip(ftype)
15442 
      else:
15443 
        iprot.skip(ftype)
15444 
      iprot.readFieldEnd()
15445 
    iprot.readStructEnd()
15446 
 
15447 
  def write(self, oprot):
15448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15450 
      return
15451 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15452 
    if self.success is not None:
2536 chandransh 15453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15454 
      oprot.writeBool(self.success)
15455 
      oprot.writeFieldEnd()
3431 rajveer 15456 
    if self.ex is not None:
2536 chandransh 15457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15458 
      self.ex.write(oprot)
15459 
      oprot.writeFieldEnd()
15460 
    oprot.writeFieldStop()
15461 
    oprot.writeStructEnd()
15462 
 
3431 rajveer 15463 
  def validate(self):
15464 
    return
15465 
 
15466 
 
2536 chandransh 15467 
  def __repr__(self):
15468 
    L = ['%s=%r' % (key, value)
15469 
      for key, value in self.__dict__.iteritems()]
15470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15471 
 
15472 
  def __eq__(self, other):
15473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15474 
 
15475 
  def __ne__(self, other):
15476 
    return not (self == other)
15477 
 
4712 rajveer 15478 
class markOrderAsDelivered_args:
15479 
  """
15480 
  Attributes:
15481 
   - orderId
15482 
   - deliveryTimestamp
15483 
   - receiver
15484 
  """
15485 
 
15486 
  thrift_spec = None
15487 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15488 
    self.orderId = orderId
15489 
    self.deliveryTimestamp = deliveryTimestamp
15490 
    self.receiver = receiver
15491 
 
15492 
  def read(self, iprot):
15493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15495 
      return
15496 
    iprot.readStructBegin()
15497 
    while True:
15498 
      (fname, ftype, fid) = iprot.readFieldBegin()
15499 
      if ftype == TType.STOP:
15500 
        break
15501 
      if fid == 1:
15502 
        if ftype == TType.I64:
15503 
          self.orderId = iprot.readI64();
15504 
        else:
15505 
          iprot.skip(ftype)
15506 
      elif fid == 2:
15507 
        if ftype == TType.I64:
15508 
          self.deliveryTimestamp = iprot.readI64();
15509 
        else:
15510 
          iprot.skip(ftype)
15511 
      elif fid == -1:
15512 
        if ftype == TType.STRING:
15513 
          self.receiver = iprot.readString();
15514 
        else:
15515 
          iprot.skip(ftype)
15516 
      else:
15517 
        iprot.skip(ftype)
15518 
      iprot.readFieldEnd()
15519 
    iprot.readStructEnd()
15520 
 
15521 
  def write(self, oprot):
15522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15524 
      return
15525 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15526 
    if self.receiver is not None:
15527 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15528 
      oprot.writeString(self.receiver)
15529 
      oprot.writeFieldEnd()
15530 
    if self.orderId is not None:
15531 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15532 
      oprot.writeI64(self.orderId)
15533 
      oprot.writeFieldEnd()
15534 
    if self.deliveryTimestamp is not None:
15535 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15536 
      oprot.writeI64(self.deliveryTimestamp)
15537 
      oprot.writeFieldEnd()
15538 
    oprot.writeFieldStop()
15539 
    oprot.writeStructEnd()
15540 
 
15541 
  def validate(self):
15542 
    return
15543 
 
15544 
 
15545 
  def __repr__(self):
15546 
    L = ['%s=%r' % (key, value)
15547 
      for key, value in self.__dict__.iteritems()]
15548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15549 
 
15550 
  def __eq__(self, other):
15551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15552 
 
15553 
  def __ne__(self, other):
15554 
    return not (self == other)
15555 
 
15556 
class markOrderAsDelivered_result:
15557 
  """
15558 
  Attributes:
15559 
   - ex
15560 
  """
15561 
 
15562 
  thrift_spec = (
15563 
    None, # 0
15564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15565 
  )
15566 
 
15567 
  def __init__(self, ex=None,):
15568 
    self.ex = ex
15569 
 
15570 
  def read(self, iprot):
15571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15573 
      return
15574 
    iprot.readStructBegin()
15575 
    while True:
15576 
      (fname, ftype, fid) = iprot.readFieldBegin()
15577 
      if ftype == TType.STOP:
15578 
        break
15579 
      if fid == 1:
15580 
        if ftype == TType.STRUCT:
15581 
          self.ex = TransactionServiceException()
15582 
          self.ex.read(iprot)
15583 
        else:
15584 
          iprot.skip(ftype)
15585 
      else:
15586 
        iprot.skip(ftype)
15587 
      iprot.readFieldEnd()
15588 
    iprot.readStructEnd()
15589 
 
15590 
  def write(self, oprot):
15591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15593 
      return
15594 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15595 
    if self.ex is not None:
15596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15597 
      self.ex.write(oprot)
15598 
      oprot.writeFieldEnd()
15599 
    oprot.writeFieldStop()
15600 
    oprot.writeStructEnd()
15601 
 
15602 
  def validate(self):
15603 
    return
15604 
 
15605 
 
15606 
  def __repr__(self):
15607 
    L = ['%s=%r' % (key, value)
15608 
      for key, value in self.__dict__.iteritems()]
15609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15610 
 
15611 
  def __eq__(self, other):
15612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15613 
 
15614 
  def __ne__(self, other):
15615 
    return not (self == other)
15616 
 
5553 rajveer 15617 
class markOrderAsReceivedAtStore_args:
15618 
  """
15619 
  Attributes:
15620 
   - orderId
15621 
   - deliveryTimestamp
15622 
  """
15623 
 
15624 
  thrift_spec = (
15625 
    None, # 0
15626 
    (1, TType.I64, 'orderId', None, None, ), # 1
15627 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15628 
  )
15629 
 
15630 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15631 
    self.orderId = orderId
15632 
    self.deliveryTimestamp = deliveryTimestamp
15633 
 
15634 
  def read(self, iprot):
15635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15637 
      return
15638 
    iprot.readStructBegin()
15639 
    while True:
15640 
      (fname, ftype, fid) = iprot.readFieldBegin()
15641 
      if ftype == TType.STOP:
15642 
        break
15643 
      if fid == 1:
15644 
        if ftype == TType.I64:
15645 
          self.orderId = iprot.readI64();
15646 
        else:
15647 
          iprot.skip(ftype)
15648 
      elif fid == 2:
15649 
        if ftype == TType.I64:
15650 
          self.deliveryTimestamp = iprot.readI64();
15651 
        else:
15652 
          iprot.skip(ftype)
15653 
      else:
15654 
        iprot.skip(ftype)
15655 
      iprot.readFieldEnd()
15656 
    iprot.readStructEnd()
15657 
 
15658 
  def write(self, oprot):
15659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15661 
      return
15662 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15663 
    if self.orderId is not None:
15664 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15665 
      oprot.writeI64(self.orderId)
15666 
      oprot.writeFieldEnd()
15667 
    if self.deliveryTimestamp is not None:
15668 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15669 
      oprot.writeI64(self.deliveryTimestamp)
15670 
      oprot.writeFieldEnd()
15671 
    oprot.writeFieldStop()
15672 
    oprot.writeStructEnd()
15673 
 
15674 
  def validate(self):
15675 
    return
15676 
 
15677 
 
15678 
  def __repr__(self):
15679 
    L = ['%s=%r' % (key, value)
15680 
      for key, value in self.__dict__.iteritems()]
15681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15682 
 
15683 
  def __eq__(self, other):
15684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15685 
 
15686 
  def __ne__(self, other):
15687 
    return not (self == other)
15688 
 
15689 
class markOrderAsReceivedAtStore_result:
15690 
  """
15691 
  Attributes:
15692 
   - ex
15693 
  """
15694 
 
15695 
  thrift_spec = (
15696 
    None, # 0
15697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15698 
  )
15699 
 
15700 
  def __init__(self, ex=None,):
15701 
    self.ex = ex
15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 1:
15713 
        if ftype == TType.STRUCT:
15714 
          self.ex = TransactionServiceException()
15715 
          self.ex.read(iprot)
15716 
        else:
15717 
          iprot.skip(ftype)
15718 
      else:
15719 
        iprot.skip(ftype)
15720 
      iprot.readFieldEnd()
15721 
    iprot.readStructEnd()
15722 
 
15723 
  def write(self, oprot):
15724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15726 
      return
15727 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15728 
    if self.ex is not None:
15729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15730 
      self.ex.write(oprot)
15731 
      oprot.writeFieldEnd()
15732 
    oprot.writeFieldStop()
15733 
    oprot.writeStructEnd()
15734 
 
15735 
  def validate(self):
15736 
    return
15737 
 
15738 
 
15739 
  def __repr__(self):
15740 
    L = ['%s=%r' % (key, value)
15741 
      for key, value in self.__dict__.iteritems()]
15742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15743 
 
15744 
  def __eq__(self, other):
15745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15746 
 
15747 
  def __ne__(self, other):
15748 
    return not (self == other)
15749 
 
4454 rajveer 15750 
class markOrderDoaRequestReceived_args:
15751 
  """
15752 
  Attributes:
15753 
   - orderId
15754 
  """
15755 
 
15756 
  thrift_spec = (
15757 
    None, # 0
15758 
    (1, TType.I64, 'orderId', None, None, ), # 1
15759 
  )
15760 
 
15761 
  def __init__(self, orderId=None,):
15762 
    self.orderId = orderId
15763 
 
15764 
  def read(self, iprot):
15765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15767 
      return
15768 
    iprot.readStructBegin()
15769 
    while True:
15770 
      (fname, ftype, fid) = iprot.readFieldBegin()
15771 
      if ftype == TType.STOP:
15772 
        break
15773 
      if fid == 1:
15774 
        if ftype == TType.I64:
15775 
          self.orderId = iprot.readI64();
15776 
        else:
15777 
          iprot.skip(ftype)
15778 
      else:
15779 
        iprot.skip(ftype)
15780 
      iprot.readFieldEnd()
15781 
    iprot.readStructEnd()
15782 
 
15783 
  def write(self, oprot):
15784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15786 
      return
15787 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15788 
    if self.orderId is not None:
15789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15790 
      oprot.writeI64(self.orderId)
15791 
      oprot.writeFieldEnd()
15792 
    oprot.writeFieldStop()
15793 
    oprot.writeStructEnd()
15794 
 
15795 
  def validate(self):
15796 
    return
15797 
 
15798 
 
15799 
  def __repr__(self):
15800 
    L = ['%s=%r' % (key, value)
15801 
      for key, value in self.__dict__.iteritems()]
15802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15803 
 
15804 
  def __eq__(self, other):
15805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15806 
 
15807 
  def __ne__(self, other):
15808 
    return not (self == other)
15809 
 
15810 
class markOrderDoaRequestReceived_result:
15811 
  """
15812 
  Attributes:
15813 
   - success
15814 
   - ex
15815 
  """
15816 
 
15817 
  thrift_spec = (
15818 
    (0, TType.BOOL, 'success', None, None, ), # 0
15819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15820 
  )
15821 
 
15822 
  def __init__(self, success=None, ex=None,):
15823 
    self.success = success
15824 
    self.ex = ex
15825 
 
15826 
  def read(self, iprot):
15827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15829 
      return
15830 
    iprot.readStructBegin()
15831 
    while True:
15832 
      (fname, ftype, fid) = iprot.readFieldBegin()
15833 
      if ftype == TType.STOP:
15834 
        break
15835 
      if fid == 0:
15836 
        if ftype == TType.BOOL:
15837 
          self.success = iprot.readBool();
15838 
        else:
15839 
          iprot.skip(ftype)
15840 
      elif fid == 1:
15841 
        if ftype == TType.STRUCT:
15842 
          self.ex = TransactionServiceException()
15843 
          self.ex.read(iprot)
15844 
        else:
15845 
          iprot.skip(ftype)
15846 
      else:
15847 
        iprot.skip(ftype)
15848 
      iprot.readFieldEnd()
15849 
    iprot.readStructEnd()
15850 
 
15851 
  def write(self, oprot):
15852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15854 
      return
15855 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15856 
    if self.success is not None:
15857 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15858 
      oprot.writeBool(self.success)
15859 
      oprot.writeFieldEnd()
15860 
    if self.ex is not None:
15861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15862 
      self.ex.write(oprot)
15863 
      oprot.writeFieldEnd()
15864 
    oprot.writeFieldStop()
15865 
    oprot.writeStructEnd()
15866 
 
15867 
  def validate(self):
15868 
    return
15869 
 
15870 
 
15871 
  def __repr__(self):
15872 
    L = ['%s=%r' % (key, value)
15873 
      for key, value in self.__dict__.iteritems()]
15874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15875 
 
15876 
  def __eq__(self, other):
15877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15878 
 
15879 
  def __ne__(self, other):
15880 
    return not (self == other)
15881 
 
15882 
class markOrderDoaRequestAuthorized_args:
15883 
  """
15884 
  Attributes:
15885 
   - orderId
15886 
   - isAuthorized
15887 
  """
15888 
 
15889 
  thrift_spec = (
15890 
    None, # 0
15891 
    (1, TType.I64, 'orderId', None, None, ), # 1
15892 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15893 
  )
15894 
 
15895 
  def __init__(self, orderId=None, isAuthorized=None,):
15896 
    self.orderId = orderId
15897 
    self.isAuthorized = isAuthorized
15898 
 
15899 
  def read(self, iprot):
15900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15902 
      return
15903 
    iprot.readStructBegin()
15904 
    while True:
15905 
      (fname, ftype, fid) = iprot.readFieldBegin()
15906 
      if ftype == TType.STOP:
15907 
        break
15908 
      if fid == 1:
15909 
        if ftype == TType.I64:
15910 
          self.orderId = iprot.readI64();
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      elif fid == 2:
15914 
        if ftype == TType.BOOL:
15915 
          self.isAuthorized = iprot.readBool();
15916 
        else:
15917 
          iprot.skip(ftype)
15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
15927 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15928 
    if self.orderId is not None:
15929 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15930 
      oprot.writeI64(self.orderId)
15931 
      oprot.writeFieldEnd()
15932 
    if self.isAuthorized is not None:
15933 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15934 
      oprot.writeBool(self.isAuthorized)
15935 
      oprot.writeFieldEnd()
15936 
    oprot.writeFieldStop()
15937 
    oprot.writeStructEnd()
15938 
 
15939 
  def validate(self):
15940 
    return
15941 
 
15942 
 
15943 
  def __repr__(self):
15944 
    L = ['%s=%r' % (key, value)
15945 
      for key, value in self.__dict__.iteritems()]
15946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15947 
 
15948 
  def __eq__(self, other):
15949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15950 
 
15951 
  def __ne__(self, other):
15952 
    return not (self == other)
15953 
 
15954 
class markOrderDoaRequestAuthorized_result:
15955 
  """
15956 
  Attributes:
15957 
   - success
15958 
   - ex
15959 
  """
15960 
 
15961 
  thrift_spec = (
15962 
    (0, TType.BOOL, 'success', None, None, ), # 0
15963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15964 
  )
15965 
 
15966 
  def __init__(self, success=None, ex=None,):
15967 
    self.success = success
15968 
    self.ex = ex
15969 
 
15970 
  def read(self, iprot):
15971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15973 
      return
15974 
    iprot.readStructBegin()
15975 
    while True:
15976 
      (fname, ftype, fid) = iprot.readFieldBegin()
15977 
      if ftype == TType.STOP:
15978 
        break
15979 
      if fid == 0:
15980 
        if ftype == TType.BOOL:
15981 
          self.success = iprot.readBool();
15982 
        else:
15983 
          iprot.skip(ftype)
15984 
      elif fid == 1:
15985 
        if ftype == TType.STRUCT:
15986 
          self.ex = TransactionServiceException()
15987 
          self.ex.read(iprot)
15988 
        else:
15989 
          iprot.skip(ftype)
15990 
      else:
15991 
        iprot.skip(ftype)
15992 
      iprot.readFieldEnd()
15993 
    iprot.readStructEnd()
15994 
 
15995 
  def write(self, oprot):
15996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15998 
      return
15999 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16000 
    if self.success is not None:
16001 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16002 
      oprot.writeBool(self.success)
16003 
      oprot.writeFieldEnd()
16004 
    if self.ex is not None:
16005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16006 
      self.ex.write(oprot)
16007 
      oprot.writeFieldEnd()
16008 
    oprot.writeFieldStop()
16009 
    oprot.writeStructEnd()
16010 
 
16011 
  def validate(self):
16012 
    return
16013 
 
16014 
 
16015 
  def __repr__(self):
16016 
    L = ['%s=%r' % (key, value)
16017 
      for key, value in self.__dict__.iteritems()]
16018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16019 
 
16020 
  def __eq__(self, other):
16021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16022 
 
16023 
  def __ne__(self, other):
16024 
    return not (self == other)
16025 
 
4488 rajveer 16026 
class markOrderReturnRequestReceived_args:
16027 
  """
16028 
  Attributes:
16029 
   - orderId
16030 
  """
16031 
 
16032 
  thrift_spec = (
16033 
    None, # 0
16034 
    (1, TType.I64, 'orderId', None, None, ), # 1
16035 
  )
16036 
 
16037 
  def __init__(self, orderId=None,):
16038 
    self.orderId = orderId
16039 
 
16040 
  def read(self, iprot):
16041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16043 
      return
16044 
    iprot.readStructBegin()
16045 
    while True:
16046 
      (fname, ftype, fid) = iprot.readFieldBegin()
16047 
      if ftype == TType.STOP:
16048 
        break
16049 
      if fid == 1:
16050 
        if ftype == TType.I64:
16051 
          self.orderId = iprot.readI64();
16052 
        else:
16053 
          iprot.skip(ftype)
16054 
      else:
16055 
        iprot.skip(ftype)
16056 
      iprot.readFieldEnd()
16057 
    iprot.readStructEnd()
16058 
 
16059 
  def write(self, oprot):
16060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16062 
      return
16063 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16064 
    if self.orderId is not None:
16065 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16066 
      oprot.writeI64(self.orderId)
16067 
      oprot.writeFieldEnd()
16068 
    oprot.writeFieldStop()
16069 
    oprot.writeStructEnd()
16070 
 
16071 
  def validate(self):
16072 
    return
16073 
 
16074 
 
16075 
  def __repr__(self):
16076 
    L = ['%s=%r' % (key, value)
16077 
      for key, value in self.__dict__.iteritems()]
16078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16079 
 
16080 
  def __eq__(self, other):
16081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16082 
 
16083 
  def __ne__(self, other):
16084 
    return not (self == other)
16085 
 
16086 
class markOrderReturnRequestReceived_result:
16087 
  """
16088 
  Attributes:
16089 
   - success
16090 
   - ex
16091 
  """
16092 
 
16093 
  thrift_spec = (
16094 
    (0, TType.BOOL, 'success', None, None, ), # 0
16095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16096 
  )
16097 
 
16098 
  def __init__(self, success=None, ex=None,):
16099 
    self.success = success
16100 
    self.ex = ex
16101 
 
16102 
  def read(self, iprot):
16103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16105 
      return
16106 
    iprot.readStructBegin()
16107 
    while True:
16108 
      (fname, ftype, fid) = iprot.readFieldBegin()
16109 
      if ftype == TType.STOP:
16110 
        break
16111 
      if fid == 0:
16112 
        if ftype == TType.BOOL:
16113 
          self.success = iprot.readBool();
16114 
        else:
16115 
          iprot.skip(ftype)
16116 
      elif fid == 1:
16117 
        if ftype == TType.STRUCT:
16118 
          self.ex = TransactionServiceException()
16119 
          self.ex.read(iprot)
16120 
        else:
16121 
          iprot.skip(ftype)
16122 
      else:
16123 
        iprot.skip(ftype)
16124 
      iprot.readFieldEnd()
16125 
    iprot.readStructEnd()
16126 
 
16127 
  def write(self, oprot):
16128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16130 
      return
16131 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16132 
    if self.success is not None:
16133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16134 
      oprot.writeBool(self.success)
16135 
      oprot.writeFieldEnd()
16136 
    if self.ex is not None:
16137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16138 
      self.ex.write(oprot)
16139 
      oprot.writeFieldEnd()
16140 
    oprot.writeFieldStop()
16141 
    oprot.writeStructEnd()
16142 
 
16143 
  def validate(self):
16144 
    return
16145 
 
16146 
 
16147 
  def __repr__(self):
16148 
    L = ['%s=%r' % (key, value)
16149 
      for key, value in self.__dict__.iteritems()]
16150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16151 
 
16152 
  def __eq__(self, other):
16153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16154 
 
16155 
  def __ne__(self, other):
16156 
    return not (self == other)
16157 
 
16158 
class markOrderReturnRequestAuthorized_args:
16159 
  """
16160 
  Attributes:
16161 
   - orderId
16162 
   - isAuthorized
16163 
  """
16164 
 
16165 
  thrift_spec = (
16166 
    None, # 0
16167 
    (1, TType.I64, 'orderId', None, None, ), # 1
16168 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16169 
  )
16170 
 
16171 
  def __init__(self, orderId=None, isAuthorized=None,):
16172 
    self.orderId = orderId
16173 
    self.isAuthorized = isAuthorized
16174 
 
16175 
  def read(self, iprot):
16176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16178 
      return
16179 
    iprot.readStructBegin()
16180 
    while True:
16181 
      (fname, ftype, fid) = iprot.readFieldBegin()
16182 
      if ftype == TType.STOP:
16183 
        break
16184 
      if fid == 1:
16185 
        if ftype == TType.I64:
16186 
          self.orderId = iprot.readI64();
16187 
        else:
16188 
          iprot.skip(ftype)
16189 
      elif fid == 2:
16190 
        if ftype == TType.BOOL:
16191 
          self.isAuthorized = iprot.readBool();
16192 
        else:
16193 
          iprot.skip(ftype)
16194 
      else:
16195 
        iprot.skip(ftype)
16196 
      iprot.readFieldEnd()
16197 
    iprot.readStructEnd()
16198 
 
16199 
  def write(self, oprot):
16200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16202 
      return
16203 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16204 
    if self.orderId is not None:
16205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16206 
      oprot.writeI64(self.orderId)
16207 
      oprot.writeFieldEnd()
16208 
    if self.isAuthorized is not None:
16209 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16210 
      oprot.writeBool(self.isAuthorized)
16211 
      oprot.writeFieldEnd()
16212 
    oprot.writeFieldStop()
16213 
    oprot.writeStructEnd()
16214 
 
16215 
  def validate(self):
16216 
    return
16217 
 
16218 
 
16219 
  def __repr__(self):
16220 
    L = ['%s=%r' % (key, value)
16221 
      for key, value in self.__dict__.iteritems()]
16222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16223 
 
16224 
  def __eq__(self, other):
16225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16226 
 
16227 
  def __ne__(self, other):
16228 
    return not (self == other)
16229 
 
16230 
class markOrderReturnRequestAuthorized_result:
16231 
  """
16232 
  Attributes:
16233 
   - success
16234 
   - ex
16235 
  """
16236 
 
16237 
  thrift_spec = (
16238 
    (0, TType.BOOL, 'success', None, None, ), # 0
16239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16240 
  )
16241 
 
16242 
  def __init__(self, success=None, ex=None,):
16243 
    self.success = success
16244 
    self.ex = ex
16245 
 
16246 
  def read(self, iprot):
16247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16249 
      return
16250 
    iprot.readStructBegin()
16251 
    while True:
16252 
      (fname, ftype, fid) = iprot.readFieldBegin()
16253 
      if ftype == TType.STOP:
16254 
        break
16255 
      if fid == 0:
16256 
        if ftype == TType.BOOL:
16257 
          self.success = iprot.readBool();
16258 
        else:
16259 
          iprot.skip(ftype)
16260 
      elif fid == 1:
16261 
        if ftype == TType.STRUCT:
16262 
          self.ex = TransactionServiceException()
16263 
          self.ex.read(iprot)
16264 
        else:
16265 
          iprot.skip(ftype)
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16276 
    if self.success is not None:
16277 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16278 
      oprot.writeBool(self.success)
16279 
      oprot.writeFieldEnd()
16280 
    if self.ex is not None:
16281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16282 
      self.ex.write(oprot)
16283 
      oprot.writeFieldEnd()
16284 
    oprot.writeFieldStop()
16285 
    oprot.writeStructEnd()
16286 
 
16287 
  def validate(self):
16288 
    return
16289 
 
16290 
 
16291 
  def __repr__(self):
16292 
    L = ['%s=%r' % (key, value)
16293 
      for key, value in self.__dict__.iteritems()]
16294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16295 
 
16296 
  def __eq__(self, other):
16297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16298 
 
16299 
  def __ne__(self, other):
16300 
    return not (self == other)
16301 
 
2536 chandransh 16302 
class requestPickupNumber_args:
16303 
  """
16304 
  Attributes:
16305 
   - orderId
4579 rajveer 16306 
   - providerId
2536 chandransh 16307 
  """
16308 
 
16309 
  thrift_spec = (
16310 
    None, # 0
16311 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16312 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16313 
  )
16314 
 
4579 rajveer 16315 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16316 
    self.orderId = orderId
4579 rajveer 16317 
    self.providerId = providerId
2536 chandransh 16318 
 
16319 
  def read(self, iprot):
16320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16322 
      return
16323 
    iprot.readStructBegin()
16324 
    while True:
16325 
      (fname, ftype, fid) = iprot.readFieldBegin()
16326 
      if ftype == TType.STOP:
16327 
        break
16328 
      if fid == 1:
16329 
        if ftype == TType.I64:
16330 
          self.orderId = iprot.readI64();
16331 
        else:
16332 
          iprot.skip(ftype)
4579 rajveer 16333 
      elif fid == 2:
16334 
        if ftype == TType.I64:
16335 
          self.providerId = iprot.readI64();
16336 
        else:
16337 
          iprot.skip(ftype)
2536 chandransh 16338 
      else:
16339 
        iprot.skip(ftype)
16340 
      iprot.readFieldEnd()
16341 
    iprot.readStructEnd()
16342 
 
16343 
  def write(self, oprot):
16344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16346 
      return
16347 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16348 
    if self.orderId is not None:
2536 chandransh 16349 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16350 
      oprot.writeI64(self.orderId)
16351 
      oprot.writeFieldEnd()
4579 rajveer 16352 
    if self.providerId is not None:
16353 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16354 
      oprot.writeI64(self.providerId)
16355 
      oprot.writeFieldEnd()
2536 chandransh 16356 
    oprot.writeFieldStop()
16357 
    oprot.writeStructEnd()
16358 
 
3431 rajveer 16359 
  def validate(self):
16360 
    return
16361 
 
16362 
 
2536 chandransh 16363 
  def __repr__(self):
16364 
    L = ['%s=%r' % (key, value)
16365 
      for key, value in self.__dict__.iteritems()]
16366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16367 
 
16368 
  def __eq__(self, other):
16369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16370 
 
16371 
  def __ne__(self, other):
16372 
    return not (self == other)
16373 
 
16374 
class requestPickupNumber_result:
16375 
  """
16376 
  Attributes:
16377 
   - success
16378 
   - ex
16379 
  """
16380 
 
16381 
  thrift_spec = (
16382 
    (0, TType.BOOL, 'success', None, None, ), # 0
16383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16384 
  )
16385 
 
16386 
  def __init__(self, success=None, ex=None,):
16387 
    self.success = success
16388 
    self.ex = ex
16389 
 
16390 
  def read(self, iprot):
16391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16393 
      return
16394 
    iprot.readStructBegin()
16395 
    while True:
16396 
      (fname, ftype, fid) = iprot.readFieldBegin()
16397 
      if ftype == TType.STOP:
16398 
        break
16399 
      if fid == 0:
16400 
        if ftype == TType.BOOL:
16401 
          self.success = iprot.readBool();
16402 
        else:
16403 
          iprot.skip(ftype)
16404 
      elif fid == 1:
16405 
        if ftype == TType.STRUCT:
16406 
          self.ex = TransactionServiceException()
16407 
          self.ex.read(iprot)
16408 
        else:
16409 
          iprot.skip(ftype)
16410 
      else:
16411 
        iprot.skip(ftype)
16412 
      iprot.readFieldEnd()
16413 
    iprot.readStructEnd()
16414 
 
16415 
  def write(self, oprot):
16416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16418 
      return
16419 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16420 
    if self.success is not None:
2536 chandransh 16421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16422 
      oprot.writeBool(self.success)
16423 
      oprot.writeFieldEnd()
3431 rajveer 16424 
    if self.ex is not None:
2536 chandransh 16425 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16426 
      self.ex.write(oprot)
16427 
      oprot.writeFieldEnd()
16428 
    oprot.writeFieldStop()
16429 
    oprot.writeStructEnd()
16430 
 
3431 rajveer 16431 
  def validate(self):
16432 
    return
16433 
 
16434 
 
2536 chandransh 16435 
  def __repr__(self):
16436 
    L = ['%s=%r' % (key, value)
16437 
      for key, value in self.__dict__.iteritems()]
16438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16439 
 
16440 
  def __eq__(self, other):
16441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16442 
 
16443 
  def __ne__(self, other):
16444 
    return not (self == other)
16445 
 
16446 
class authorizePickup_args:
16447 
  """
16448 
  Attributes:
16449 
   - orderId
16450 
   - pickupNumber
4602 rajveer 16451 
   - providerId
2536 chandransh 16452 
  """
16453 
 
16454 
  thrift_spec = (
16455 
    None, # 0
16456 
    (1, TType.I64, 'orderId', None, None, ), # 1
16457 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16458 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16459 
  )
16460 
 
4602 rajveer 16461 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16462 
    self.orderId = orderId
16463 
    self.pickupNumber = pickupNumber
4602 rajveer 16464 
    self.providerId = providerId
2536 chandransh 16465 
 
16466 
  def read(self, iprot):
16467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16469 
      return
16470 
    iprot.readStructBegin()
16471 
    while True:
16472 
      (fname, ftype, fid) = iprot.readFieldBegin()
16473 
      if ftype == TType.STOP:
16474 
        break
16475 
      if fid == 1:
16476 
        if ftype == TType.I64:
16477 
          self.orderId = iprot.readI64();
16478 
        else:
16479 
          iprot.skip(ftype)
16480 
      elif fid == 2:
16481 
        if ftype == TType.STRING:
16482 
          self.pickupNumber = iprot.readString();
16483 
        else:
16484 
          iprot.skip(ftype)
4602 rajveer 16485 
      elif fid == 3:
16486 
        if ftype == TType.I64:
16487 
          self.providerId = iprot.readI64();
16488 
        else:
16489 
          iprot.skip(ftype)
2536 chandransh 16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16500 
    if self.orderId is not None:
2536 chandransh 16501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16502 
      oprot.writeI64(self.orderId)
16503 
      oprot.writeFieldEnd()
3431 rajveer 16504 
    if self.pickupNumber is not None:
2536 chandransh 16505 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16506 
      oprot.writeString(self.pickupNumber)
16507 
      oprot.writeFieldEnd()
4602 rajveer 16508 
    if self.providerId is not None:
16509 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16510 
      oprot.writeI64(self.providerId)
16511 
      oprot.writeFieldEnd()
2536 chandransh 16512 
    oprot.writeFieldStop()
16513 
    oprot.writeStructEnd()
16514 
 
3431 rajveer 16515 
  def validate(self):
16516 
    return
16517 
 
16518 
 
2536 chandransh 16519 
  def __repr__(self):
16520 
    L = ['%s=%r' % (key, value)
16521 
      for key, value in self.__dict__.iteritems()]
16522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16523 
 
16524 
  def __eq__(self, other):
16525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16526 
 
16527 
  def __ne__(self, other):
16528 
    return not (self == other)
16529 
 
16530 
class authorizePickup_result:
16531 
  """
16532 
  Attributes:
16533 
   - success
16534 
   - ex
16535 
  """
16536 
 
16537 
  thrift_spec = (
16538 
    (0, TType.BOOL, 'success', None, None, ), # 0
16539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16540 
  )
16541 
 
16542 
  def __init__(self, success=None, ex=None,):
16543 
    self.success = success
16544 
    self.ex = ex
16545 
 
16546 
  def read(self, iprot):
16547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16549 
      return
16550 
    iprot.readStructBegin()
16551 
    while True:
16552 
      (fname, ftype, fid) = iprot.readFieldBegin()
16553 
      if ftype == TType.STOP:
16554 
        break
16555 
      if fid == 0:
16556 
        if ftype == TType.BOOL:
16557 
          self.success = iprot.readBool();
16558 
        else:
16559 
          iprot.skip(ftype)
16560 
      elif fid == 1:
16561 
        if ftype == TType.STRUCT:
16562 
          self.ex = TransactionServiceException()
16563 
          self.ex.read(iprot)
16564 
        else:
16565 
          iprot.skip(ftype)
16566 
      else:
16567 
        iprot.skip(ftype)
16568 
      iprot.readFieldEnd()
16569 
    iprot.readStructEnd()
16570 
 
16571 
  def write(self, oprot):
16572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16574 
      return
16575 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16576 
    if self.success is not None:
2536 chandransh 16577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16578 
      oprot.writeBool(self.success)
16579 
      oprot.writeFieldEnd()
3431 rajveer 16580 
    if self.ex is not None:
2536 chandransh 16581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16582 
      self.ex.write(oprot)
16583 
      oprot.writeFieldEnd()
16584 
    oprot.writeFieldStop()
16585 
    oprot.writeStructEnd()
16586 
 
3431 rajveer 16587 
  def validate(self):
16588 
    return
16589 
 
16590 
 
2536 chandransh 16591 
  def __repr__(self):
16592 
    L = ['%s=%r' % (key, value)
16593 
      for key, value in self.__dict__.iteritems()]
16594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16595 
 
16596 
  def __eq__(self, other):
16597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16598 
 
16599 
  def __ne__(self, other):
16600 
    return not (self == other)
16601 
 
2764 chandransh 16602 
class markDoasAsPickedUp_args:
16603 
  """
16604 
  Attributes:
16605 
   - providerId
16606 
   - pickupDetails
16607 
  """
16608 
 
16609 
  thrift_spec = (
16610 
    None, # 0
16611 
    (1, TType.I64, 'providerId', None, None, ), # 1
16612 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16613 
  )
16614 
 
16615 
  def __init__(self, providerId=None, pickupDetails=None,):
16616 
    self.providerId = providerId
16617 
    self.pickupDetails = pickupDetails
16618 
 
16619 
  def read(self, iprot):
16620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16622 
      return
16623 
    iprot.readStructBegin()
16624 
    while True:
16625 
      (fname, ftype, fid) = iprot.readFieldBegin()
16626 
      if ftype == TType.STOP:
16627 
        break
16628 
      if fid == 1:
16629 
        if ftype == TType.I64:
16630 
          self.providerId = iprot.readI64();
16631 
        else:
16632 
          iprot.skip(ftype)
16633 
      elif fid == 2:
16634 
        if ftype == TType.MAP:
16635 
          self.pickupDetails = {}
6031 rajveer 16636 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16637 
          for _i368 in xrange(_size364):
16638 
            _key369 = iprot.readString();
16639 
            _val370 = iprot.readString();
16640 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16641 
          iprot.readMapEnd()
16642 
        else:
16643 
          iprot.skip(ftype)
16644 
      else:
16645 
        iprot.skip(ftype)
16646 
      iprot.readFieldEnd()
16647 
    iprot.readStructEnd()
16648 
 
16649 
  def write(self, oprot):
16650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16652 
      return
16653 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16654 
    if self.providerId is not None:
2764 chandransh 16655 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16656 
      oprot.writeI64(self.providerId)
16657 
      oprot.writeFieldEnd()
3431 rajveer 16658 
    if self.pickupDetails is not None:
2764 chandransh 16659 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16660 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16661 
      for kiter371,viter372 in self.pickupDetails.items():
16662 
        oprot.writeString(kiter371)
16663 
        oprot.writeString(viter372)
2764 chandransh 16664 
      oprot.writeMapEnd()
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
3431 rajveer 16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
2764 chandransh 16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class markDoasAsPickedUp_result:
4910 phani.kuma 16685 
 
16686 
  thrift_spec = (
16687 
  )
16688 
 
16689 
  def read(self, iprot):
16690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16692 
      return
16693 
    iprot.readStructBegin()
16694 
    while True:
16695 
      (fname, ftype, fid) = iprot.readFieldBegin()
16696 
      if ftype == TType.STOP:
16697 
        break
16698 
      else:
16699 
        iprot.skip(ftype)
16700 
      iprot.readFieldEnd()
16701 
    iprot.readStructEnd()
16702 
 
16703 
  def write(self, oprot):
16704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16706 
      return
16707 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16708 
    oprot.writeFieldStop()
16709 
    oprot.writeStructEnd()
16710 
 
16711 
  def validate(self):
16712 
    return
16713 
 
16714 
 
16715 
  def __repr__(self):
16716 
    L = ['%s=%r' % (key, value)
16717 
      for key, value in self.__dict__.iteritems()]
16718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16719 
 
16720 
  def __eq__(self, other):
16721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16722 
 
16723 
  def __ne__(self, other):
16724 
    return not (self == other)
16725 
 
16726 
class getDoasNotPickedUp_args:
2764 chandransh 16727 
  """
16728 
  Attributes:
4910 phani.kuma 16729 
   - providerId
16730 
  """
16731 
 
16732 
  thrift_spec = (
16733 
    None, # 0
16734 
    (1, TType.I64, 'providerId', None, None, ), # 1
16735 
  )
16736 
 
16737 
  def __init__(self, providerId=None,):
16738 
    self.providerId = providerId
16739 
 
16740 
  def read(self, iprot):
16741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16743 
      return
16744 
    iprot.readStructBegin()
16745 
    while True:
16746 
      (fname, ftype, fid) = iprot.readFieldBegin()
16747 
      if ftype == TType.STOP:
16748 
        break
16749 
      if fid == 1:
16750 
        if ftype == TType.I64:
16751 
          self.providerId = iprot.readI64();
16752 
        else:
16753 
          iprot.skip(ftype)
16754 
      else:
16755 
        iprot.skip(ftype)
16756 
      iprot.readFieldEnd()
16757 
    iprot.readStructEnd()
16758 
 
16759 
  def write(self, oprot):
16760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16762 
      return
16763 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16764 
    if self.providerId is not None:
16765 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16766 
      oprot.writeI64(self.providerId)
16767 
      oprot.writeFieldEnd()
16768 
    oprot.writeFieldStop()
16769 
    oprot.writeStructEnd()
16770 
 
16771 
  def validate(self):
16772 
    return
16773 
 
16774 
 
16775 
  def __repr__(self):
16776 
    L = ['%s=%r' % (key, value)
16777 
      for key, value in self.__dict__.iteritems()]
16778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16779 
 
16780 
  def __eq__(self, other):
16781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16782 
 
16783 
  def __ne__(self, other):
16784 
    return not (self == other)
16785 
 
16786 
class getDoasNotPickedUp_result:
16787 
  """
16788 
  Attributes:
2764 chandransh 16789 
   - success
16790 
  """
16791 
 
16792 
  thrift_spec = (
16793 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16794 
  )
16795 
 
16796 
  def __init__(self, success=None,):
16797 
    self.success = success
16798 
 
16799 
  def read(self, iprot):
16800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16802 
      return
16803 
    iprot.readStructBegin()
16804 
    while True:
16805 
      (fname, ftype, fid) = iprot.readFieldBegin()
16806 
      if ftype == TType.STOP:
16807 
        break
16808 
      if fid == 0:
16809 
        if ftype == TType.LIST:
16810 
          self.success = []
6031 rajveer 16811 
          (_etype376, _size373) = iprot.readListBegin()
16812 
          for _i377 in xrange(_size373):
16813 
            _elem378 = Order()
16814 
            _elem378.read(iprot)
16815 
            self.success.append(_elem378)
2764 chandransh 16816 
          iprot.readListEnd()
16817 
        else:
16818 
          iprot.skip(ftype)
16819 
      else:
16820 
        iprot.skip(ftype)
16821 
      iprot.readFieldEnd()
16822 
    iprot.readStructEnd()
16823 
 
16824 
  def write(self, oprot):
16825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16827 
      return
4910 phani.kuma 16828 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16829 
    if self.success is not None:
2764 chandransh 16830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 16832 
      for iter379 in self.success:
16833 
        iter379.write(oprot)
2764 chandransh 16834 
      oprot.writeListEnd()
16835 
      oprot.writeFieldEnd()
16836 
    oprot.writeFieldStop()
16837 
    oprot.writeStructEnd()
16838 
 
3431 rajveer 16839 
  def validate(self):
16840 
    return
16841 
 
16842 
 
2764 chandransh 16843 
  def __repr__(self):
16844 
    L = ['%s=%r' % (key, value)
16845 
      for key, value in self.__dict__.iteritems()]
16846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16847 
 
16848 
  def __eq__(self, other):
16849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16850 
 
16851 
  def __ne__(self, other):
16852 
    return not (self == other)
16853 
 
4741 phani.kuma 16854 
class markReturnOrdersAsPickedUp_args:
16855 
  """
16856 
  Attributes:
16857 
   - providerId
16858 
   - pickupDetails
16859 
  """
16860 
 
16861 
  thrift_spec = (
16862 
    None, # 0
16863 
    (1, TType.I64, 'providerId', None, None, ), # 1
16864 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16865 
  )
16866 
 
16867 
  def __init__(self, providerId=None, pickupDetails=None,):
16868 
    self.providerId = providerId
16869 
    self.pickupDetails = pickupDetails
16870 
 
16871 
  def read(self, iprot):
16872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16874 
      return
16875 
    iprot.readStructBegin()
16876 
    while True:
16877 
      (fname, ftype, fid) = iprot.readFieldBegin()
16878 
      if ftype == TType.STOP:
16879 
        break
16880 
      if fid == 1:
16881 
        if ftype == TType.I64:
16882 
          self.providerId = iprot.readI64();
16883 
        else:
16884 
          iprot.skip(ftype)
16885 
      elif fid == 2:
16886 
        if ftype == TType.MAP:
16887 
          self.pickupDetails = {}
6031 rajveer 16888 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16889 
          for _i384 in xrange(_size380):
16890 
            _key385 = iprot.readString();
16891 
            _val386 = iprot.readString();
16892 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16893 
          iprot.readMapEnd()
16894 
        else:
16895 
          iprot.skip(ftype)
16896 
      else:
16897 
        iprot.skip(ftype)
16898 
      iprot.readFieldEnd()
16899 
    iprot.readStructEnd()
16900 
 
16901 
  def write(self, oprot):
16902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16904 
      return
16905 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16906 
    if self.providerId is not None:
16907 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16908 
      oprot.writeI64(self.providerId)
16909 
      oprot.writeFieldEnd()
16910 
    if self.pickupDetails is not None:
16911 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16912 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16913 
      for kiter387,viter388 in self.pickupDetails.items():
16914 
        oprot.writeString(kiter387)
16915 
        oprot.writeString(viter388)
4741 phani.kuma 16916 
      oprot.writeMapEnd()
16917 
      oprot.writeFieldEnd()
16918 
    oprot.writeFieldStop()
16919 
    oprot.writeStructEnd()
16920 
 
16921 
  def validate(self):
16922 
    return
16923 
 
16924 
 
16925 
  def __repr__(self):
16926 
    L = ['%s=%r' % (key, value)
16927 
      for key, value in self.__dict__.iteritems()]
16928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16929 
 
16930 
  def __eq__(self, other):
16931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16932 
 
16933 
  def __ne__(self, other):
16934 
    return not (self == other)
16935 
 
16936 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16937 
 
16938 
  thrift_spec = (
16939 
  )
16940 
 
16941 
  def read(self, iprot):
16942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16944 
      return
16945 
    iprot.readStructBegin()
16946 
    while True:
16947 
      (fname, ftype, fid) = iprot.readFieldBegin()
16948 
      if ftype == TType.STOP:
16949 
        break
16950 
      else:
16951 
        iprot.skip(ftype)
16952 
      iprot.readFieldEnd()
16953 
    iprot.readStructEnd()
16954 
 
16955 
  def write(self, oprot):
16956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16958 
      return
16959 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16960 
    oprot.writeFieldStop()
16961 
    oprot.writeStructEnd()
16962 
 
16963 
  def validate(self):
16964 
    return
16965 
 
16966 
 
16967 
  def __repr__(self):
16968 
    L = ['%s=%r' % (key, value)
16969 
      for key, value in self.__dict__.iteritems()]
16970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16971 
 
16972 
  def __eq__(self, other):
16973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16974 
 
16975 
  def __ne__(self, other):
16976 
    return not (self == other)
16977 
 
16978 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16979 
  """
16980 
  Attributes:
4910 phani.kuma 16981 
   - providerId
16982 
  """
16983 
 
16984 
  thrift_spec = (
16985 
    None, # 0
16986 
    (1, TType.I64, 'providerId', None, None, ), # 1
16987 
  )
16988 
 
16989 
  def __init__(self, providerId=None,):
16990 
    self.providerId = providerId
16991 
 
16992 
  def read(self, iprot):
16993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16995 
      return
16996 
    iprot.readStructBegin()
16997 
    while True:
16998 
      (fname, ftype, fid) = iprot.readFieldBegin()
16999 
      if ftype == TType.STOP:
17000 
        break
17001 
      if fid == 1:
17002 
        if ftype == TType.I64:
17003 
          self.providerId = iprot.readI64();
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      else:
17007 
        iprot.skip(ftype)
17008 
      iprot.readFieldEnd()
17009 
    iprot.readStructEnd()
17010 
 
17011 
  def write(self, oprot):
17012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17014 
      return
17015 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17016 
    if self.providerId is not None:
17017 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17018 
      oprot.writeI64(self.providerId)
17019 
      oprot.writeFieldEnd()
17020 
    oprot.writeFieldStop()
17021 
    oprot.writeStructEnd()
17022 
 
17023 
  def validate(self):
17024 
    return
17025 
 
17026 
 
17027 
  def __repr__(self):
17028 
    L = ['%s=%r' % (key, value)
17029 
      for key, value in self.__dict__.iteritems()]
17030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17031 
 
17032 
  def __eq__(self, other):
17033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17034 
 
17035 
  def __ne__(self, other):
17036 
    return not (self == other)
17037 
 
17038 
class getReturnOrdersNotPickedUp_result:
17039 
  """
17040 
  Attributes:
4741 phani.kuma 17041 
   - success
17042 
  """
17043 
 
17044 
  thrift_spec = (
17045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17046 
  )
17047 
 
17048 
  def __init__(self, success=None,):
17049 
    self.success = success
17050 
 
17051 
  def read(self, iprot):
17052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17054 
      return
17055 
    iprot.readStructBegin()
17056 
    while True:
17057 
      (fname, ftype, fid) = iprot.readFieldBegin()
17058 
      if ftype == TType.STOP:
17059 
        break
17060 
      if fid == 0:
17061 
        if ftype == TType.LIST:
17062 
          self.success = []
6031 rajveer 17063 
          (_etype392, _size389) = iprot.readListBegin()
17064 
          for _i393 in xrange(_size389):
17065 
            _elem394 = Order()
17066 
            _elem394.read(iprot)
17067 
            self.success.append(_elem394)
4741 phani.kuma 17068 
          iprot.readListEnd()
17069 
        else:
17070 
          iprot.skip(ftype)
17071 
      else:
17072 
        iprot.skip(ftype)
17073 
      iprot.readFieldEnd()
17074 
    iprot.readStructEnd()
17075 
 
17076 
  def write(self, oprot):
17077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17079 
      return
4910 phani.kuma 17080 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17081 
    if self.success is not None:
17082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17084 
      for iter395 in self.success:
17085 
        iter395.write(oprot)
4741 phani.kuma 17086 
      oprot.writeListEnd()
17087 
      oprot.writeFieldEnd()
17088 
    oprot.writeFieldStop()
17089 
    oprot.writeStructEnd()
17090 
 
17091 
  def validate(self):
17092 
    return
17093 
 
17094 
 
17095 
  def __repr__(self):
17096 
    L = ['%s=%r' % (key, value)
17097 
      for key, value in self.__dict__.iteritems()]
17098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17099 
 
17100 
  def __eq__(self, other):
17101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17102 
 
17103 
  def __ne__(self, other):
17104 
    return not (self == other)
17105 
 
2616 chandransh 17106 
class receiveReturn_args:
2591 chandransh 17107 
  """
17108 
  Attributes:
17109 
   - orderId
4479 rajveer 17110 
   - receiveCondition
2591 chandransh 17111 
  """
2536 chandransh 17112 
 
2591 chandransh 17113 
  thrift_spec = (
17114 
    None, # 0
17115 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17116 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17117 
  )
17118 
 
4479 rajveer 17119 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17120 
    self.orderId = orderId
4479 rajveer 17121 
    self.receiveCondition = receiveCondition
2591 chandransh 17122 
 
17123 
  def read(self, iprot):
17124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17126 
      return
17127 
    iprot.readStructBegin()
17128 
    while True:
17129 
      (fname, ftype, fid) = iprot.readFieldBegin()
17130 
      if ftype == TType.STOP:
17131 
        break
17132 
      if fid == 1:
17133 
        if ftype == TType.I64:
17134 
          self.orderId = iprot.readI64();
17135 
        else:
17136 
          iprot.skip(ftype)
4479 rajveer 17137 
      elif fid == 2:
17138 
        if ftype == TType.I64:
17139 
          self.receiveCondition = iprot.readI64();
17140 
        else:
17141 
          iprot.skip(ftype)
2591 chandransh 17142 
      else:
17143 
        iprot.skip(ftype)
17144 
      iprot.readFieldEnd()
17145 
    iprot.readStructEnd()
17146 
 
17147 
  def write(self, oprot):
17148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17150 
      return
2616 chandransh 17151 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17152 
    if self.orderId is not None:
2591 chandransh 17153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17154 
      oprot.writeI64(self.orderId)
17155 
      oprot.writeFieldEnd()
4479 rajveer 17156 
    if self.receiveCondition is not None:
17157 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17158 
      oprot.writeI64(self.receiveCondition)
17159 
      oprot.writeFieldEnd()
2591 chandransh 17160 
    oprot.writeFieldStop()
17161 
    oprot.writeStructEnd()
17162 
 
3431 rajveer 17163 
  def validate(self):
17164 
    return
17165 
 
17166 
 
2591 chandransh 17167 
  def __repr__(self):
17168 
    L = ['%s=%r' % (key, value)
17169 
      for key, value in self.__dict__.iteritems()]
17170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17171 
 
17172 
  def __eq__(self, other):
17173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17174 
 
17175 
  def __ne__(self, other):
17176 
    return not (self == other)
17177 
 
2616 chandransh 17178 
class receiveReturn_result:
2591 chandransh 17179 
  """
17180 
  Attributes:
17181 
   - success
17182 
   - ex
17183 
  """
17184 
 
17185 
  thrift_spec = (
17186 
    (0, TType.BOOL, 'success', None, None, ), # 0
17187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17188 
  )
17189 
 
17190 
  def __init__(self, success=None, ex=None,):
17191 
    self.success = success
17192 
    self.ex = ex
17193 
 
17194 
  def read(self, iprot):
17195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17197 
      return
17198 
    iprot.readStructBegin()
17199 
    while True:
17200 
      (fname, ftype, fid) = iprot.readFieldBegin()
17201 
      if ftype == TType.STOP:
17202 
        break
17203 
      if fid == 0:
17204 
        if ftype == TType.BOOL:
17205 
          self.success = iprot.readBool();
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      elif fid == 1:
17209 
        if ftype == TType.STRUCT:
17210 
          self.ex = TransactionServiceException()
17211 
          self.ex.read(iprot)
17212 
        else:
17213 
          iprot.skip(ftype)
17214 
      else:
17215 
        iprot.skip(ftype)
17216 
      iprot.readFieldEnd()
17217 
    iprot.readStructEnd()
17218 
 
17219 
  def write(self, oprot):
17220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17222 
      return
2616 chandransh 17223 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17224 
    if self.success is not None:
2591 chandransh 17225 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17226 
      oprot.writeBool(self.success)
17227 
      oprot.writeFieldEnd()
3431 rajveer 17228 
    if self.ex is not None:
2591 chandransh 17229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17230 
      self.ex.write(oprot)
17231 
      oprot.writeFieldEnd()
17232 
    oprot.writeFieldStop()
17233 
    oprot.writeStructEnd()
17234 
 
3431 rajveer 17235 
  def validate(self):
17236 
    return
17237 
 
17238 
 
2591 chandransh 17239 
  def __repr__(self):
17240 
    L = ['%s=%r' % (key, value)
17241 
      for key, value in self.__dict__.iteritems()]
17242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17243 
 
17244 
  def __eq__(self, other):
17245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17246 
 
17247 
  def __ne__(self, other):
17248 
    return not (self == other)
17249 
 
17250 
class validateDoa_args:
17251 
  """
17252 
  Attributes:
17253 
   - orderId
17254 
   - isValid
17255 
  """
17256 
 
17257 
  thrift_spec = (
17258 
    None, # 0
17259 
    (1, TType.I64, 'orderId', None, None, ), # 1
17260 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17261 
  )
17262 
 
17263 
  def __init__(self, orderId=None, isValid=None,):
17264 
    self.orderId = orderId
17265 
    self.isValid = isValid
17266 
 
17267 
  def read(self, iprot):
17268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17270 
      return
17271 
    iprot.readStructBegin()
17272 
    while True:
17273 
      (fname, ftype, fid) = iprot.readFieldBegin()
17274 
      if ftype == TType.STOP:
17275 
        break
17276 
      if fid == 1:
17277 
        if ftype == TType.I64:
17278 
          self.orderId = iprot.readI64();
17279 
        else:
17280 
          iprot.skip(ftype)
17281 
      elif fid == 2:
17282 
        if ftype == TType.BOOL:
17283 
          self.isValid = iprot.readBool();
17284 
        else:
17285 
          iprot.skip(ftype)
17286 
      else:
17287 
        iprot.skip(ftype)
17288 
      iprot.readFieldEnd()
17289 
    iprot.readStructEnd()
17290 
 
17291 
  def write(self, oprot):
17292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17294 
      return
17295 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17296 
    if self.orderId is not None:
2591 chandransh 17297 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17298 
      oprot.writeI64(self.orderId)
17299 
      oprot.writeFieldEnd()
3431 rajveer 17300 
    if self.isValid is not None:
2591 chandransh 17301 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17302 
      oprot.writeBool(self.isValid)
17303 
      oprot.writeFieldEnd()
17304 
    oprot.writeFieldStop()
17305 
    oprot.writeStructEnd()
17306 
 
3431 rajveer 17307 
  def validate(self):
17308 
    return
17309 
 
17310 
 
2591 chandransh 17311 
  def __repr__(self):
17312 
    L = ['%s=%r' % (key, value)
17313 
      for key, value in self.__dict__.iteritems()]
17314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17315 
 
17316 
  def __eq__(self, other):
17317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17318 
 
17319 
  def __ne__(self, other):
17320 
    return not (self == other)
17321 
 
17322 
class validateDoa_result:
17323 
  """
17324 
  Attributes:
17325 
   - success
17326 
   - ex
17327 
  """
17328 
 
17329 
  thrift_spec = (
17330 
    (0, TType.BOOL, 'success', None, None, ), # 0
17331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17332 
  )
17333 
 
17334 
  def __init__(self, success=None, ex=None,):
17335 
    self.success = success
17336 
    self.ex = ex
17337 
 
17338 
  def read(self, iprot):
17339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17341 
      return
17342 
    iprot.readStructBegin()
17343 
    while True:
17344 
      (fname, ftype, fid) = iprot.readFieldBegin()
17345 
      if ftype == TType.STOP:
17346 
        break
17347 
      if fid == 0:
17348 
        if ftype == TType.BOOL:
17349 
          self.success = iprot.readBool();
17350 
        else:
17351 
          iprot.skip(ftype)
17352 
      elif fid == 1:
17353 
        if ftype == TType.STRUCT:
17354 
          self.ex = TransactionServiceException()
17355 
          self.ex.read(iprot)
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      else:
17359 
        iprot.skip(ftype)
17360 
      iprot.readFieldEnd()
17361 
    iprot.readStructEnd()
17362 
 
17363 
  def write(self, oprot):
17364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17366 
      return
17367 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17368 
    if self.success is not None:
2591 chandransh 17369 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17370 
      oprot.writeBool(self.success)
17371 
      oprot.writeFieldEnd()
3431 rajveer 17372 
    if self.ex is not None:
2591 chandransh 17373 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17374 
      self.ex.write(oprot)
17375 
      oprot.writeFieldEnd()
17376 
    oprot.writeFieldStop()
17377 
    oprot.writeStructEnd()
17378 
 
3431 rajveer 17379 
  def validate(self):
17380 
    return
17381 
 
17382 
 
2591 chandransh 17383 
  def __repr__(self):
17384 
    L = ['%s=%r' % (key, value)
17385 
      for key, value in self.__dict__.iteritems()]
17386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17387 
 
17388 
  def __eq__(self, other):
17389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17390 
 
17391 
  def __ne__(self, other):
17392 
    return not (self == other)
17393 
 
4495 rajveer 17394 
class validateReturnProduct_args:
17395 
  """
17396 
  Attributes:
17397 
   - orderId
17398 
   - isUsable
17399 
  """
17400 
 
17401 
  thrift_spec = (
17402 
    None, # 0
17403 
    (1, TType.I64, 'orderId', None, None, ), # 1
17404 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17405 
  )
17406 
 
17407 
  def __init__(self, orderId=None, isUsable=None,):
17408 
    self.orderId = orderId
17409 
    self.isUsable = isUsable
17410 
 
17411 
  def read(self, iprot):
17412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17414 
      return
17415 
    iprot.readStructBegin()
17416 
    while True:
17417 
      (fname, ftype, fid) = iprot.readFieldBegin()
17418 
      if ftype == TType.STOP:
17419 
        break
17420 
      if fid == 1:
17421 
        if ftype == TType.I64:
17422 
          self.orderId = iprot.readI64();
17423 
        else:
17424 
          iprot.skip(ftype)
17425 
      elif fid == 2:
17426 
        if ftype == TType.BOOL:
17427 
          self.isUsable = iprot.readBool();
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
17439 
    oprot.writeStructBegin('validateReturnProduct_args')
17440 
    if self.orderId is not None:
17441 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17442 
      oprot.writeI64(self.orderId)
17443 
      oprot.writeFieldEnd()
17444 
    if self.isUsable is not None:
17445 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17446 
      oprot.writeBool(self.isUsable)
17447 
      oprot.writeFieldEnd()
17448 
    oprot.writeFieldStop()
17449 
    oprot.writeStructEnd()
17450 
 
17451 
  def validate(self):
17452 
    return
17453 
 
17454 
 
17455 
  def __repr__(self):
17456 
    L = ['%s=%r' % (key, value)
17457 
      for key, value in self.__dict__.iteritems()]
17458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17459 
 
17460 
  def __eq__(self, other):
17461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17462 
 
17463 
  def __ne__(self, other):
17464 
    return not (self == other)
17465 
 
17466 
class validateReturnProduct_result:
17467 
  """
17468 
  Attributes:
17469 
   - success
17470 
   - ex
17471 
  """
17472 
 
17473 
  thrift_spec = (
17474 
    (0, TType.BOOL, 'success', None, None, ), # 0
17475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17476 
  )
17477 
 
17478 
  def __init__(self, success=None, ex=None,):
17479 
    self.success = success
17480 
    self.ex = ex
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 == 0:
17492 
        if ftype == TType.BOOL:
17493 
          self.success = iprot.readBool();
17494 
        else:
17495 
          iprot.skip(ftype)
17496 
      elif fid == 1:
17497 
        if ftype == TType.STRUCT:
17498 
          self.ex = TransactionServiceException()
17499 
          self.ex.read(iprot)
17500 
        else:
17501 
          iprot.skip(ftype)
17502 
      else:
17503 
        iprot.skip(ftype)
17504 
      iprot.readFieldEnd()
17505 
    iprot.readStructEnd()
17506 
 
17507 
  def write(self, oprot):
17508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17510 
      return
17511 
    oprot.writeStructBegin('validateReturnProduct_result')
17512 
    if self.success is not None:
17513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17514 
      oprot.writeBool(self.success)
17515 
      oprot.writeFieldEnd()
17516 
    if self.ex is not None:
17517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17518 
      self.ex.write(oprot)
17519 
      oprot.writeFieldEnd()
17520 
    oprot.writeFieldStop()
17521 
    oprot.writeStructEnd()
17522 
 
17523 
  def validate(self):
17524 
    return
17525 
 
17526 
 
17527 
  def __repr__(self):
17528 
    L = ['%s=%r' % (key, value)
17529 
      for key, value in self.__dict__.iteritems()]
17530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17531 
 
17532 
  def __eq__(self, other):
17533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17534 
 
17535 
  def __ne__(self, other):
17536 
    return not (self == other)
17537 
 
2616 chandransh 17538 
class reshipOrder_args:
17539 
  """
17540 
  Attributes:
17541 
   - orderId
17542 
  """
2591 chandransh 17543 
 
2616 chandransh 17544 
  thrift_spec = (
17545 
    None, # 0
17546 
    (1, TType.I64, 'orderId', None, None, ), # 1
17547 
  )
17548 
 
17549 
  def __init__(self, orderId=None,):
17550 
    self.orderId = orderId
17551 
 
17552 
  def read(self, iprot):
17553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17555 
      return
17556 
    iprot.readStructBegin()
17557 
    while True:
17558 
      (fname, ftype, fid) = iprot.readFieldBegin()
17559 
      if ftype == TType.STOP:
17560 
        break
17561 
      if fid == 1:
17562 
        if ftype == TType.I64:
17563 
          self.orderId = iprot.readI64();
17564 
        else:
17565 
          iprot.skip(ftype)
17566 
      else:
17567 
        iprot.skip(ftype)
17568 
      iprot.readFieldEnd()
17569 
    iprot.readStructEnd()
17570 
 
17571 
  def write(self, oprot):
17572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17574 
      return
17575 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17576 
    if self.orderId is not None:
2616 chandransh 17577 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17578 
      oprot.writeI64(self.orderId)
17579 
      oprot.writeFieldEnd()
17580 
    oprot.writeFieldStop()
17581 
    oprot.writeStructEnd()
17582 
 
3431 rajveer 17583 
  def validate(self):
17584 
    return
17585 
 
17586 
 
2616 chandransh 17587 
  def __repr__(self):
17588 
    L = ['%s=%r' % (key, value)
17589 
      for key, value in self.__dict__.iteritems()]
17590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17591 
 
17592 
  def __eq__(self, other):
17593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17594 
 
17595 
  def __ne__(self, other):
17596 
    return not (self == other)
17597 
 
17598 
class reshipOrder_result:
17599 
  """
17600 
  Attributes:
17601 
   - success
17602 
   - ex
17603 
  """
17604 
 
17605 
  thrift_spec = (
17606 
    (0, TType.I64, 'success', None, None, ), # 0
17607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17608 
  )
17609 
 
17610 
  def __init__(self, success=None, ex=None,):
17611 
    self.success = success
17612 
    self.ex = ex
17613 
 
17614 
  def read(self, iprot):
17615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17617 
      return
17618 
    iprot.readStructBegin()
17619 
    while True:
17620 
      (fname, ftype, fid) = iprot.readFieldBegin()
17621 
      if ftype == TType.STOP:
17622 
        break
17623 
      if fid == 0:
17624 
        if ftype == TType.I64:
17625 
          self.success = iprot.readI64();
17626 
        else:
17627 
          iprot.skip(ftype)
17628 
      elif fid == 1:
17629 
        if ftype == TType.STRUCT:
17630 
          self.ex = TransactionServiceException()
17631 
          self.ex.read(iprot)
17632 
        else:
17633 
          iprot.skip(ftype)
17634 
      else:
17635 
        iprot.skip(ftype)
17636 
      iprot.readFieldEnd()
17637 
    iprot.readStructEnd()
17638 
 
17639 
  def write(self, oprot):
17640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17642 
      return
17643 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17644 
    if self.success is not None:
2616 chandransh 17645 
      oprot.writeFieldBegin('success', TType.I64, 0)
17646 
      oprot.writeI64(self.success)
17647 
      oprot.writeFieldEnd()
3431 rajveer 17648 
    if self.ex is not None:
2616 chandransh 17649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17650 
      self.ex.write(oprot)
17651 
      oprot.writeFieldEnd()
17652 
    oprot.writeFieldStop()
17653 
    oprot.writeStructEnd()
17654 
 
3431 rajveer 17655 
  def validate(self):
17656 
    return
17657 
 
17658 
 
2616 chandransh 17659 
  def __repr__(self):
17660 
    L = ['%s=%r' % (key, value)
17661 
      for key, value in self.__dict__.iteritems()]
17662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17663 
 
17664 
  def __eq__(self, other):
17665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17666 
 
17667 
  def __ne__(self, other):
17668 
    return not (self == other)
17669 
 
17670 
class refundOrder_args:
17671 
  """
17672 
  Attributes:
17673 
   - orderId
3226 chandransh 17674 
   - refundedBy
17675 
   - reason
2616 chandransh 17676 
  """
17677 
 
17678 
  thrift_spec = (
17679 
    None, # 0
17680 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17681 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17682 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17683 
  )
17684 
 
3226 chandransh 17685 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17686 
    self.orderId = orderId
3226 chandransh 17687 
    self.refundedBy = refundedBy
17688 
    self.reason = reason
2616 chandransh 17689 
 
17690 
  def read(self, iprot):
17691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17693 
      return
17694 
    iprot.readStructBegin()
17695 
    while True:
17696 
      (fname, ftype, fid) = iprot.readFieldBegin()
17697 
      if ftype == TType.STOP:
17698 
        break
17699 
      if fid == 1:
17700 
        if ftype == TType.I64:
17701 
          self.orderId = iprot.readI64();
17702 
        else:
17703 
          iprot.skip(ftype)
3226 chandransh 17704 
      elif fid == 2:
17705 
        if ftype == TType.STRING:
17706 
          self.refundedBy = iprot.readString();
17707 
        else:
17708 
          iprot.skip(ftype)
17709 
      elif fid == 3:
17710 
        if ftype == TType.STRING:
17711 
          self.reason = iprot.readString();
17712 
        else:
17713 
          iprot.skip(ftype)
2616 chandransh 17714 
      else:
17715 
        iprot.skip(ftype)
17716 
      iprot.readFieldEnd()
17717 
    iprot.readStructEnd()
17718 
 
17719 
  def write(self, oprot):
17720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17722 
      return
17723 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17724 
    if self.orderId is not None:
2616 chandransh 17725 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17726 
      oprot.writeI64(self.orderId)
17727 
      oprot.writeFieldEnd()
3431 rajveer 17728 
    if self.refundedBy is not None:
3226 chandransh 17729 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17730 
      oprot.writeString(self.refundedBy)
17731 
      oprot.writeFieldEnd()
3431 rajveer 17732 
    if self.reason is not None:
3226 chandransh 17733 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17734 
      oprot.writeString(self.reason)
17735 
      oprot.writeFieldEnd()
2616 chandransh 17736 
    oprot.writeFieldStop()
17737 
    oprot.writeStructEnd()
17738 
 
3431 rajveer 17739 
  def validate(self):
17740 
    return
17741 
 
17742 
 
2616 chandransh 17743 
  def __repr__(self):
17744 
    L = ['%s=%r' % (key, value)
17745 
      for key, value in self.__dict__.iteritems()]
17746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17747 
 
17748 
  def __eq__(self, other):
17749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17750 
 
17751 
  def __ne__(self, other):
17752 
    return not (self == other)
17753 
 
17754 
class refundOrder_result:
17755 
  """
17756 
  Attributes:
17757 
   - success
17758 
   - ex
17759 
  """
17760 
 
17761 
  thrift_spec = (
17762 
    (0, TType.BOOL, 'success', None, None, ), # 0
17763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17764 
  )
17765 
 
17766 
  def __init__(self, success=None, ex=None,):
17767 
    self.success = success
17768 
    self.ex = ex
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 == 0:
17780 
        if ftype == TType.BOOL:
17781 
          self.success = iprot.readBool();
17782 
        else:
17783 
          iprot.skip(ftype)
17784 
      elif fid == 1:
17785 
        if ftype == TType.STRUCT:
17786 
          self.ex = TransactionServiceException()
17787 
          self.ex.read(iprot)
17788 
        else:
17789 
          iprot.skip(ftype)
17790 
      else:
17791 
        iprot.skip(ftype)
17792 
      iprot.readFieldEnd()
17793 
    iprot.readStructEnd()
17794 
 
17795 
  def write(self, oprot):
17796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17798 
      return
17799 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17800 
    if self.success is not None:
2616 chandransh 17801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17802 
      oprot.writeBool(self.success)
17803 
      oprot.writeFieldEnd()
3431 rajveer 17804 
    if self.ex is not None:
2616 chandransh 17805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17806 
      self.ex.write(oprot)
17807 
      oprot.writeFieldEnd()
17808 
    oprot.writeFieldStop()
17809 
    oprot.writeStructEnd()
17810 
 
3431 rajveer 17811 
  def validate(self):
17812 
    return
17813 
 
17814 
 
2616 chandransh 17815 
  def __repr__(self):
17816 
    L = ['%s=%r' % (key, value)
17817 
      for key, value in self.__dict__.iteritems()]
17818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17819 
 
17820 
  def __eq__(self, other):
17821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17822 
 
17823 
  def __ne__(self, other):
17824 
    return not (self == other)
17825 
 
2690 chandransh 17826 
class getReturnOrders_args:
17827 
  """
17828 
  Attributes:
17829 
   - warehouseId
17830 
   - fromDate
17831 
   - toDate
17832 
  """
2616 chandransh 17833 
 
2690 chandransh 17834 
  thrift_spec = (
17835 
    None, # 0
17836 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17837 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17838 
    (3, TType.I64, 'toDate', None, None, ), # 3
17839 
  )
17840 
 
17841 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17842 
    self.warehouseId = warehouseId
17843 
    self.fromDate = fromDate
17844 
    self.toDate = toDate
17845 
 
17846 
  def read(self, iprot):
17847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17849 
      return
17850 
    iprot.readStructBegin()
17851 
    while True:
17852 
      (fname, ftype, fid) = iprot.readFieldBegin()
17853 
      if ftype == TType.STOP:
17854 
        break
17855 
      if fid == 1:
17856 
        if ftype == TType.I64:
17857 
          self.warehouseId = iprot.readI64();
17858 
        else:
17859 
          iprot.skip(ftype)
17860 
      elif fid == 2:
17861 
        if ftype == TType.I64:
17862 
          self.fromDate = iprot.readI64();
17863 
        else:
17864 
          iprot.skip(ftype)
17865 
      elif fid == 3:
17866 
        if ftype == TType.I64:
17867 
          self.toDate = iprot.readI64();
17868 
        else:
17869 
          iprot.skip(ftype)
17870 
      else:
17871 
        iprot.skip(ftype)
17872 
      iprot.readFieldEnd()
17873 
    iprot.readStructEnd()
17874 
 
17875 
  def write(self, oprot):
17876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17878 
      return
17879 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17880 
    if self.warehouseId is not None:
2690 chandransh 17881 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17882 
      oprot.writeI64(self.warehouseId)
17883 
      oprot.writeFieldEnd()
3431 rajveer 17884 
    if self.fromDate is not None:
2690 chandransh 17885 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17886 
      oprot.writeI64(self.fromDate)
17887 
      oprot.writeFieldEnd()
3431 rajveer 17888 
    if self.toDate is not None:
2690 chandransh 17889 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17890 
      oprot.writeI64(self.toDate)
17891 
      oprot.writeFieldEnd()
17892 
    oprot.writeFieldStop()
17893 
    oprot.writeStructEnd()
17894 
 
3431 rajveer 17895 
  def validate(self):
17896 
    return
17897 
 
17898 
 
2690 chandransh 17899 
  def __repr__(self):
17900 
    L = ['%s=%r' % (key, value)
17901 
      for key, value in self.__dict__.iteritems()]
17902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17903 
 
17904 
  def __eq__(self, other):
17905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17906 
 
17907 
  def __ne__(self, other):
17908 
    return not (self == other)
17909 
 
17910 
class getReturnOrders_result:
17911 
  """
17912 
  Attributes:
17913 
   - success
17914 
  """
17915 
 
17916 
  thrift_spec = (
17917 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17918 
  )
17919 
 
17920 
  def __init__(self, success=None,):
17921 
    self.success = success
17922 
 
17923 
  def read(self, iprot):
17924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17926 
      return
17927 
    iprot.readStructBegin()
17928 
    while True:
17929 
      (fname, ftype, fid) = iprot.readFieldBegin()
17930 
      if ftype == TType.STOP:
17931 
        break
17932 
      if fid == 0:
17933 
        if ftype == TType.LIST:
17934 
          self.success = []
6031 rajveer 17935 
          (_etype399, _size396) = iprot.readListBegin()
17936 
          for _i400 in xrange(_size396):
17937 
            _elem401 = ReturnOrder()
17938 
            _elem401.read(iprot)
17939 
            self.success.append(_elem401)
2690 chandransh 17940 
          iprot.readListEnd()
17941 
        else:
17942 
          iprot.skip(ftype)
17943 
      else:
17944 
        iprot.skip(ftype)
17945 
      iprot.readFieldEnd()
17946 
    iprot.readStructEnd()
17947 
 
17948 
  def write(self, oprot):
17949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17951 
      return
17952 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17953 
    if self.success is not None:
2690 chandransh 17954 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17955 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17956 
      for iter402 in self.success:
17957 
        iter402.write(oprot)
2690 chandransh 17958 
      oprot.writeListEnd()
17959 
      oprot.writeFieldEnd()
17960 
    oprot.writeFieldStop()
17961 
    oprot.writeStructEnd()
17962 
 
3431 rajveer 17963 
  def validate(self):
17964 
    return
17965 
 
17966 
 
2690 chandransh 17967 
  def __repr__(self):
17968 
    L = ['%s=%r' % (key, value)
17969 
      for key, value in self.__dict__.iteritems()]
17970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17971 
 
17972 
  def __eq__(self, other):
17973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17974 
 
17975 
  def __ne__(self, other):
17976 
    return not (self == other)
17977 
 
5481 phani.kuma 17978 
class getAllReturnOrders_args:
17979 
  """
17980 
  Attributes:
17981 
   - onlyNotProcessed
17982 
   - fromDate
17983 
   - toDate
17984 
  """
17985 
 
17986 
  thrift_spec = (
17987 
    None, # 0
17988 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17989 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17990 
    (3, TType.I64, 'toDate', None, None, ), # 3
17991 
  )
17992 
 
17993 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17994 
    self.onlyNotProcessed = onlyNotProcessed
17995 
    self.fromDate = fromDate
17996 
    self.toDate = toDate
17997 
 
17998 
  def read(self, iprot):
17999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18001 
      return
18002 
    iprot.readStructBegin()
18003 
    while True:
18004 
      (fname, ftype, fid) = iprot.readFieldBegin()
18005 
      if ftype == TType.STOP:
18006 
        break
18007 
      if fid == 1:
18008 
        if ftype == TType.BOOL:
18009 
          self.onlyNotProcessed = iprot.readBool();
18010 
        else:
18011 
          iprot.skip(ftype)
18012 
      elif fid == 2:
18013 
        if ftype == TType.I64:
18014 
          self.fromDate = iprot.readI64();
18015 
        else:
18016 
          iprot.skip(ftype)
18017 
      elif fid == 3:
18018 
        if ftype == TType.I64:
18019 
          self.toDate = iprot.readI64();
18020 
        else:
18021 
          iprot.skip(ftype)
18022 
      else:
18023 
        iprot.skip(ftype)
18024 
      iprot.readFieldEnd()
18025 
    iprot.readStructEnd()
18026 
 
18027 
  def write(self, oprot):
18028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18030 
      return
18031 
    oprot.writeStructBegin('getAllReturnOrders_args')
18032 
    if self.onlyNotProcessed is not None:
18033 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18034 
      oprot.writeBool(self.onlyNotProcessed)
18035 
      oprot.writeFieldEnd()
18036 
    if self.fromDate is not None:
18037 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18038 
      oprot.writeI64(self.fromDate)
18039 
      oprot.writeFieldEnd()
18040 
    if self.toDate is not None:
18041 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18042 
      oprot.writeI64(self.toDate)
18043 
      oprot.writeFieldEnd()
18044 
    oprot.writeFieldStop()
18045 
    oprot.writeStructEnd()
18046 
 
18047 
  def validate(self):
18048 
    return
18049 
 
18050 
 
18051 
  def __repr__(self):
18052 
    L = ['%s=%r' % (key, value)
18053 
      for key, value in self.__dict__.iteritems()]
18054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18055 
 
18056 
  def __eq__(self, other):
18057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18058 
 
18059 
  def __ne__(self, other):
18060 
    return not (self == other)
18061 
 
18062 
class getAllReturnOrders_result:
18063 
  """
18064 
  Attributes:
18065 
   - success
18066 
  """
18067 
 
18068 
  thrift_spec = (
18069 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18070 
  )
18071 
 
18072 
  def __init__(self, success=None,):
18073 
    self.success = success
18074 
 
18075 
  def read(self, iprot):
18076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18078 
      return
18079 
    iprot.readStructBegin()
18080 
    while True:
18081 
      (fname, ftype, fid) = iprot.readFieldBegin()
18082 
      if ftype == TType.STOP:
18083 
        break
18084 
      if fid == 0:
18085 
        if ftype == TType.LIST:
18086 
          self.success = []
6031 rajveer 18087 
          (_etype406, _size403) = iprot.readListBegin()
18088 
          for _i407 in xrange(_size403):
18089 
            _elem408 = ReturnOrder()
18090 
            _elem408.read(iprot)
18091 
            self.success.append(_elem408)
5481 phani.kuma 18092 
          iprot.readListEnd()
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      else:
18096 
        iprot.skip(ftype)
18097 
      iprot.readFieldEnd()
18098 
    iprot.readStructEnd()
18099 
 
18100 
  def write(self, oprot):
18101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18103 
      return
18104 
    oprot.writeStructBegin('getAllReturnOrders_result')
18105 
    if self.success is not None:
18106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18107 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18108 
      for iter409 in self.success:
18109 
        iter409.write(oprot)
5481 phani.kuma 18110 
      oprot.writeListEnd()
18111 
      oprot.writeFieldEnd()
18112 
    oprot.writeFieldStop()
18113 
    oprot.writeStructEnd()
18114 
 
18115 
  def validate(self):
18116 
    return
18117 
 
18118 
 
18119 
  def __repr__(self):
18120 
    L = ['%s=%r' % (key, value)
18121 
      for key, value in self.__dict__.iteritems()]
18122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18123 
 
18124 
  def __eq__(self, other):
18125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18126 
 
18127 
  def __ne__(self, other):
18128 
    return not (self == other)
18129 
 
2700 chandransh 18130 
class getReturnOrder_args:
18131 
  """
18132 
  Attributes:
18133 
   - id
18134 
  """
18135 
 
18136 
  thrift_spec = (
18137 
    None, # 0
18138 
    (1, TType.I64, 'id', None, None, ), # 1
18139 
  )
18140 
 
18141 
  def __init__(self, id=None,):
18142 
    self.id = id
18143 
 
18144 
  def read(self, iprot):
18145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18147 
      return
18148 
    iprot.readStructBegin()
18149 
    while True:
18150 
      (fname, ftype, fid) = iprot.readFieldBegin()
18151 
      if ftype == TType.STOP:
18152 
        break
18153 
      if fid == 1:
18154 
        if ftype == TType.I64:
18155 
          self.id = iprot.readI64();
18156 
        else:
18157 
          iprot.skip(ftype)
18158 
      else:
18159 
        iprot.skip(ftype)
18160 
      iprot.readFieldEnd()
18161 
    iprot.readStructEnd()
18162 
 
18163 
  def write(self, oprot):
18164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18166 
      return
18167 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18168 
    if self.id is not None:
2700 chandransh 18169 
      oprot.writeFieldBegin('id', TType.I64, 1)
18170 
      oprot.writeI64(self.id)
18171 
      oprot.writeFieldEnd()
18172 
    oprot.writeFieldStop()
18173 
    oprot.writeStructEnd()
18174 
 
3431 rajveer 18175 
  def validate(self):
18176 
    return
18177 
 
18178 
 
2700 chandransh 18179 
  def __repr__(self):
18180 
    L = ['%s=%r' % (key, value)
18181 
      for key, value in self.__dict__.iteritems()]
18182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18183 
 
18184 
  def __eq__(self, other):
18185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18186 
 
18187 
  def __ne__(self, other):
18188 
    return not (self == other)
18189 
 
18190 
class getReturnOrder_result:
18191 
  """
18192 
  Attributes:
18193 
   - success
18194 
   - ex
18195 
  """
18196 
 
18197 
  thrift_spec = (
18198 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18200 
  )
18201 
 
18202 
  def __init__(self, success=None, ex=None,):
18203 
    self.success = success
18204 
    self.ex = ex
18205 
 
18206 
  def read(self, iprot):
18207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18209 
      return
18210 
    iprot.readStructBegin()
18211 
    while True:
18212 
      (fname, ftype, fid) = iprot.readFieldBegin()
18213 
      if ftype == TType.STOP:
18214 
        break
18215 
      if fid == 0:
18216 
        if ftype == TType.STRUCT:
18217 
          self.success = ReturnOrder()
18218 
          self.success.read(iprot)
18219 
        else:
18220 
          iprot.skip(ftype)
18221 
      elif fid == 1:
18222 
        if ftype == TType.STRUCT:
18223 
          self.ex = TransactionServiceException()
18224 
          self.ex.read(iprot)
18225 
        else:
18226 
          iprot.skip(ftype)
18227 
      else:
18228 
        iprot.skip(ftype)
18229 
      iprot.readFieldEnd()
18230 
    iprot.readStructEnd()
18231 
 
18232 
  def write(self, oprot):
18233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18235 
      return
18236 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18237 
    if self.success is not None:
2700 chandransh 18238 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18239 
      self.success.write(oprot)
18240 
      oprot.writeFieldEnd()
3431 rajveer 18241 
    if self.ex is not None:
2700 chandransh 18242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18243 
      self.ex.write(oprot)
18244 
      oprot.writeFieldEnd()
18245 
    oprot.writeFieldStop()
18246 
    oprot.writeStructEnd()
18247 
 
3431 rajveer 18248 
  def validate(self):
18249 
    return
18250 
 
18251 
 
2700 chandransh 18252 
  def __repr__(self):
18253 
    L = ['%s=%r' % (key, value)
18254 
      for key, value in self.__dict__.iteritems()]
18255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18256 
 
18257 
  def __eq__(self, other):
18258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18259 
 
18260 
  def __ne__(self, other):
18261 
    return not (self == other)
18262 
 
2690 chandransh 18263 
class processReturn_args:
18264 
  """
18265 
  Attributes:
18266 
   - returnOrderId
18267 
  """
18268 
 
18269 
  thrift_spec = (
18270 
    None, # 0
18271 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18272 
  )
18273 
 
18274 
  def __init__(self, returnOrderId=None,):
18275 
    self.returnOrderId = returnOrderId
18276 
 
18277 
  def read(self, iprot):
18278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18280 
      return
18281 
    iprot.readStructBegin()
18282 
    while True:
18283 
      (fname, ftype, fid) = iprot.readFieldBegin()
18284 
      if ftype == TType.STOP:
18285 
        break
18286 
      if fid == 1:
18287 
        if ftype == TType.I64:
18288 
          self.returnOrderId = iprot.readI64();
18289 
        else:
18290 
          iprot.skip(ftype)
18291 
      else:
18292 
        iprot.skip(ftype)
18293 
      iprot.readFieldEnd()
18294 
    iprot.readStructEnd()
18295 
 
18296 
  def write(self, oprot):
18297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18299 
      return
18300 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18301 
    if self.returnOrderId is not None:
2690 chandransh 18302 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18303 
      oprot.writeI64(self.returnOrderId)
18304 
      oprot.writeFieldEnd()
18305 
    oprot.writeFieldStop()
18306 
    oprot.writeStructEnd()
18307 
 
3431 rajveer 18308 
  def validate(self):
18309 
    return
18310 
 
18311 
 
2690 chandransh 18312 
  def __repr__(self):
18313 
    L = ['%s=%r' % (key, value)
18314 
      for key, value in self.__dict__.iteritems()]
18315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18316 
 
18317 
  def __eq__(self, other):
18318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18319 
 
18320 
  def __ne__(self, other):
18321 
    return not (self == other)
18322 
 
18323 
class processReturn_result:
18324 
  """
18325 
  Attributes:
18326 
   - ex
18327 
  """
18328 
 
18329 
  thrift_spec = (
18330 
    None, # 0
18331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18332 
  )
18333 
 
18334 
  def __init__(self, ex=None,):
18335 
    self.ex = ex
18336 
 
18337 
  def read(self, iprot):
18338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18340 
      return
18341 
    iprot.readStructBegin()
18342 
    while True:
18343 
      (fname, ftype, fid) = iprot.readFieldBegin()
18344 
      if ftype == TType.STOP:
18345 
        break
18346 
      if fid == 1:
18347 
        if ftype == TType.STRUCT:
18348 
          self.ex = TransactionServiceException()
18349 
          self.ex.read(iprot)
18350 
        else:
18351 
          iprot.skip(ftype)
18352 
      else:
18353 
        iprot.skip(ftype)
18354 
      iprot.readFieldEnd()
18355 
    iprot.readStructEnd()
18356 
 
18357 
  def write(self, oprot):
18358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18360 
      return
18361 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18362 
    if self.ex is not None:
2690 chandransh 18363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18364 
      self.ex.write(oprot)
18365 
      oprot.writeFieldEnd()
18366 
    oprot.writeFieldStop()
18367 
    oprot.writeStructEnd()
18368 
 
3431 rajveer 18369 
  def validate(self):
18370 
    return
18371 
 
18372 
 
2690 chandransh 18373 
  def __repr__(self):
18374 
    L = ['%s=%r' % (key, value)
18375 
      for key, value in self.__dict__.iteritems()]
18376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18377 
 
18378 
  def __eq__(self, other):
18379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18380 
 
18381 
  def __ne__(self, other):
18382 
    return not (self == other)
18383 
 
3451 chandransh 18384 
class updateWeight_args:
18385 
  """
18386 
  Attributes:
18387 
   - orderId
18388 
   - weight
18389 
  """
18390 
 
18391 
  thrift_spec = (
18392 
    None, # 0
18393 
    (1, TType.I64, 'orderId', None, None, ), # 1
18394 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18395 
  )
18396 
 
18397 
  def __init__(self, orderId=None, weight=None,):
18398 
    self.orderId = orderId
18399 
    self.weight = weight
18400 
 
18401 
  def read(self, iprot):
18402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18404 
      return
18405 
    iprot.readStructBegin()
18406 
    while True:
18407 
      (fname, ftype, fid) = iprot.readFieldBegin()
18408 
      if ftype == TType.STOP:
18409 
        break
18410 
      if fid == 1:
18411 
        if ftype == TType.I64:
18412 
          self.orderId = iprot.readI64();
18413 
        else:
18414 
          iprot.skip(ftype)
18415 
      elif fid == 2:
18416 
        if ftype == TType.DOUBLE:
18417 
          self.weight = iprot.readDouble();
18418 
        else:
18419 
          iprot.skip(ftype)
18420 
      else:
18421 
        iprot.skip(ftype)
18422 
      iprot.readFieldEnd()
18423 
    iprot.readStructEnd()
18424 
 
18425 
  def write(self, oprot):
18426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18428 
      return
18429 
    oprot.writeStructBegin('updateWeight_args')
18430 
    if self.orderId is not None:
18431 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18432 
      oprot.writeI64(self.orderId)
18433 
      oprot.writeFieldEnd()
18434 
    if self.weight is not None:
18435 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18436 
      oprot.writeDouble(self.weight)
18437 
      oprot.writeFieldEnd()
18438 
    oprot.writeFieldStop()
18439 
    oprot.writeStructEnd()
18440 
 
18441 
  def validate(self):
18442 
    return
18443 
 
18444 
 
18445 
  def __repr__(self):
18446 
    L = ['%s=%r' % (key, value)
18447 
      for key, value in self.__dict__.iteritems()]
18448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18449 
 
18450 
  def __eq__(self, other):
18451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18452 
 
18453 
  def __ne__(self, other):
18454 
    return not (self == other)
18455 
 
18456 
class updateWeight_result:
18457 
  """
18458 
  Attributes:
18459 
   - success
18460 
   - ex
18461 
  """
18462 
 
18463 
  thrift_spec = (
18464 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18466 
  )
18467 
 
18468 
  def __init__(self, success=None, ex=None,):
18469 
    self.success = success
18470 
    self.ex = ex
18471 
 
18472 
  def read(self, iprot):
18473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18475 
      return
18476 
    iprot.readStructBegin()
18477 
    while True:
18478 
      (fname, ftype, fid) = iprot.readFieldBegin()
18479 
      if ftype == TType.STOP:
18480 
        break
18481 
      if fid == 0:
18482 
        if ftype == TType.STRUCT:
18483 
          self.success = Order()
18484 
          self.success.read(iprot)
18485 
        else:
18486 
          iprot.skip(ftype)
18487 
      elif fid == 1:
18488 
        if ftype == TType.STRUCT:
18489 
          self.ex = TransactionServiceException()
18490 
          self.ex.read(iprot)
18491 
        else:
18492 
          iprot.skip(ftype)
18493 
      else:
18494 
        iprot.skip(ftype)
18495 
      iprot.readFieldEnd()
18496 
    iprot.readStructEnd()
18497 
 
18498 
  def write(self, oprot):
18499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18501 
      return
18502 
    oprot.writeStructBegin('updateWeight_result')
18503 
    if self.success is not None:
18504 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18505 
      self.success.write(oprot)
18506 
      oprot.writeFieldEnd()
18507 
    if self.ex is not None:
18508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18509 
      self.ex.write(oprot)
18510 
      oprot.writeFieldEnd()
18511 
    oprot.writeFieldStop()
18512 
    oprot.writeStructEnd()
18513 
 
18514 
  def validate(self):
18515 
    return
18516 
 
18517 
 
18518 
  def __repr__(self):
18519 
    L = ['%s=%r' % (key, value)
18520 
      for key, value in self.__dict__.iteritems()]
18521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18522 
 
18523 
  def __eq__(self, other):
18524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18525 
 
18526 
  def __ne__(self, other):
18527 
    return not (self == other)
3469 chandransh 18528 
 
18529 
class changeItem_args:
18530 
  """
18531 
  Attributes:
18532 
   - orderId
18533 
   - itemId
18534 
  """
18535 
 
18536 
  thrift_spec = (
18537 
    None, # 0
18538 
    (1, TType.I64, 'orderId', None, None, ), # 1
18539 
    (2, TType.I64, 'itemId', None, None, ), # 2
18540 
  )
18541 
 
18542 
  def __init__(self, orderId=None, itemId=None,):
18543 
    self.orderId = orderId
18544 
    self.itemId = itemId
18545 
 
18546 
  def read(self, iprot):
18547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18549 
      return
18550 
    iprot.readStructBegin()
18551 
    while True:
18552 
      (fname, ftype, fid) = iprot.readFieldBegin()
18553 
      if ftype == TType.STOP:
18554 
        break
18555 
      if fid == 1:
18556 
        if ftype == TType.I64:
18557 
          self.orderId = iprot.readI64();
18558 
        else:
18559 
          iprot.skip(ftype)
18560 
      elif fid == 2:
18561 
        if ftype == TType.I64:
18562 
          self.itemId = iprot.readI64();
18563 
        else:
18564 
          iprot.skip(ftype)
18565 
      else:
18566 
        iprot.skip(ftype)
18567 
      iprot.readFieldEnd()
18568 
    iprot.readStructEnd()
18569 
 
18570 
  def write(self, oprot):
18571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18573 
      return
18574 
    oprot.writeStructBegin('changeItem_args')
18575 
    if self.orderId is not None:
18576 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18577 
      oprot.writeI64(self.orderId)
18578 
      oprot.writeFieldEnd()
18579 
    if self.itemId is not None:
18580 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18581 
      oprot.writeI64(self.itemId)
18582 
      oprot.writeFieldEnd()
18583 
    oprot.writeFieldStop()
18584 
    oprot.writeStructEnd()
18585 
 
18586 
  def validate(self):
18587 
    return
18588 
 
18589 
 
18590 
  def __repr__(self):
18591 
    L = ['%s=%r' % (key, value)
18592 
      for key, value in self.__dict__.iteritems()]
18593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18594 
 
18595 
  def __eq__(self, other):
18596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18597 
 
18598 
  def __ne__(self, other):
18599 
    return not (self == other)
18600 
 
18601 
class changeItem_result:
18602 
  """
18603 
  Attributes:
18604 
   - success
18605 
   - ex
18606 
  """
18607 
 
18608 
  thrift_spec = (
18609 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18611 
  )
18612 
 
18613 
  def __init__(self, success=None, ex=None,):
18614 
    self.success = success
18615 
    self.ex = ex
18616 
 
18617 
  def read(self, iprot):
18618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18620 
      return
18621 
    iprot.readStructBegin()
18622 
    while True:
18623 
      (fname, ftype, fid) = iprot.readFieldBegin()
18624 
      if ftype == TType.STOP:
18625 
        break
18626 
      if fid == 0:
18627 
        if ftype == TType.STRUCT:
18628 
          self.success = Order()
18629 
          self.success.read(iprot)
18630 
        else:
18631 
          iprot.skip(ftype)
18632 
      elif fid == 1:
18633 
        if ftype == TType.STRUCT:
18634 
          self.ex = TransactionServiceException()
18635 
          self.ex.read(iprot)
18636 
        else:
18637 
          iprot.skip(ftype)
18638 
      else:
18639 
        iprot.skip(ftype)
18640 
      iprot.readFieldEnd()
18641 
    iprot.readStructEnd()
18642 
 
18643 
  def write(self, oprot):
18644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18646 
      return
18647 
    oprot.writeStructBegin('changeItem_result')
18648 
    if self.success is not None:
18649 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18650 
      self.success.write(oprot)
18651 
      oprot.writeFieldEnd()
18652 
    if self.ex is not None:
18653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18654 
      self.ex.write(oprot)
18655 
      oprot.writeFieldEnd()
18656 
    oprot.writeFieldStop()
18657 
    oprot.writeStructEnd()
18658 
 
18659 
  def validate(self):
18660 
    return
18661 
 
18662 
 
18663 
  def __repr__(self):
18664 
    L = ['%s=%r' % (key, value)
18665 
      for key, value in self.__dict__.iteritems()]
18666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18667 
 
18668 
  def __eq__(self, other):
18669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18670 
 
18671 
  def __ne__(self, other):
18672 
    return not (self == other)
18673 
 
18674 
class shiftToWarehouse_args:
18675 
  """
18676 
  Attributes:
18677 
   - orderId
18678 
   - warehouseId
18679 
  """
18680 
 
18681 
  thrift_spec = (
18682 
    None, # 0
18683 
    (1, TType.I64, 'orderId', None, None, ), # 1
18684 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18685 
  )
18686 
 
18687 
  def __init__(self, orderId=None, warehouseId=None,):
18688 
    self.orderId = orderId
18689 
    self.warehouseId = warehouseId
18690 
 
18691 
  def read(self, iprot):
18692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18694 
      return
18695 
    iprot.readStructBegin()
18696 
    while True:
18697 
      (fname, ftype, fid) = iprot.readFieldBegin()
18698 
      if ftype == TType.STOP:
18699 
        break
18700 
      if fid == 1:
18701 
        if ftype == TType.I64:
18702 
          self.orderId = iprot.readI64();
18703 
        else:
18704 
          iprot.skip(ftype)
18705 
      elif fid == 2:
18706 
        if ftype == TType.I64:
18707 
          self.warehouseId = iprot.readI64();
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      else:
18711 
        iprot.skip(ftype)
18712 
      iprot.readFieldEnd()
18713 
    iprot.readStructEnd()
18714 
 
18715 
  def write(self, oprot):
18716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18718 
      return
18719 
    oprot.writeStructBegin('shiftToWarehouse_args')
18720 
    if self.orderId is not None:
18721 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18722 
      oprot.writeI64(self.orderId)
18723 
      oprot.writeFieldEnd()
18724 
    if self.warehouseId is not None:
18725 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18726 
      oprot.writeI64(self.warehouseId)
18727 
      oprot.writeFieldEnd()
18728 
    oprot.writeFieldStop()
18729 
    oprot.writeStructEnd()
18730 
 
18731 
  def validate(self):
18732 
    return
18733 
 
18734 
 
18735 
  def __repr__(self):
18736 
    L = ['%s=%r' % (key, value)
18737 
      for key, value in self.__dict__.iteritems()]
18738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18739 
 
18740 
  def __eq__(self, other):
18741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18742 
 
18743 
  def __ne__(self, other):
18744 
    return not (self == other)
18745 
 
18746 
class shiftToWarehouse_result:
18747 
  """
18748 
  Attributes:
18749 
   - success
18750 
   - ex
18751 
  """
18752 
 
18753 
  thrift_spec = (
18754 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18756 
  )
18757 
 
18758 
  def __init__(self, success=None, ex=None,):
18759 
    self.success = success
18760 
    self.ex = ex
18761 
 
18762 
  def read(self, iprot):
18763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18765 
      return
18766 
    iprot.readStructBegin()
18767 
    while True:
18768 
      (fname, ftype, fid) = iprot.readFieldBegin()
18769 
      if ftype == TType.STOP:
18770 
        break
18771 
      if fid == 0:
18772 
        if ftype == TType.STRUCT:
18773 
          self.success = Order()
18774 
          self.success.read(iprot)
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      elif fid == 1:
18778 
        if ftype == TType.STRUCT:
18779 
          self.ex = TransactionServiceException()
18780 
          self.ex.read(iprot)
18781 
        else:
18782 
          iprot.skip(ftype)
18783 
      else:
18784 
        iprot.skip(ftype)
18785 
      iprot.readFieldEnd()
18786 
    iprot.readStructEnd()
18787 
 
18788 
  def write(self, oprot):
18789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18791 
      return
18792 
    oprot.writeStructBegin('shiftToWarehouse_result')
18793 
    if self.success is not None:
18794 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18795 
      self.success.write(oprot)
18796 
      oprot.writeFieldEnd()
18797 
    if self.ex is not None:
18798 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18799 
      self.ex.write(oprot)
18800 
      oprot.writeFieldEnd()
18801 
    oprot.writeFieldStop()
18802 
    oprot.writeStructEnd()
18803 
 
18804 
  def validate(self):
18805 
    return
18806 
 
18807 
 
18808 
  def __repr__(self):
18809 
    L = ['%s=%r' % (key, value)
18810 
      for key, value in self.__dict__.iteritems()]
18811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18812 
 
18813 
  def __eq__(self, other):
18814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18815 
 
18816 
  def __ne__(self, other):
18817 
    return not (self == other)
3553 chandransh 18818 
 
18819 
class addDelayReason_args:
18820 
  """
18821 
  Attributes:
18822 
   - orderId
18823 
   - delayReason
3986 chandransh 18824 
   - furtherDelay
4647 rajveer 18825 
   - delayReasonText
3553 chandransh 18826 
  """
18827 
 
18828 
  thrift_spec = (
18829 
    None, # 0
18830 
    (1, TType.I64, 'orderId', None, None, ), # 1
18831 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18832 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18833 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18834 
  )
18835 
 
4647 rajveer 18836 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18837 
    self.orderId = orderId
18838 
    self.delayReason = delayReason
3986 chandransh 18839 
    self.furtherDelay = furtherDelay
4647 rajveer 18840 
    self.delayReasonText = delayReasonText
3553 chandransh 18841 
 
18842 
  def read(self, iprot):
18843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18845 
      return
18846 
    iprot.readStructBegin()
18847 
    while True:
18848 
      (fname, ftype, fid) = iprot.readFieldBegin()
18849 
      if ftype == TType.STOP:
18850 
        break
18851 
      if fid == 1:
18852 
        if ftype == TType.I64:
18853 
          self.orderId = iprot.readI64();
18854 
        else:
18855 
          iprot.skip(ftype)
18856 
      elif fid == 2:
18857 
        if ftype == TType.I32:
18858 
          self.delayReason = iprot.readI32();
18859 
        else:
18860 
          iprot.skip(ftype)
3986 chandransh 18861 
      elif fid == 3:
18862 
        if ftype == TType.I64:
18863 
          self.furtherDelay = iprot.readI64();
18864 
        else:
18865 
          iprot.skip(ftype)
4647 rajveer 18866 
      elif fid == 4:
18867 
        if ftype == TType.STRING:
18868 
          self.delayReasonText = iprot.readString();
18869 
        else:
18870 
          iprot.skip(ftype)
3553 chandransh 18871 
      else:
18872 
        iprot.skip(ftype)
18873 
      iprot.readFieldEnd()
18874 
    iprot.readStructEnd()
18875 
 
18876 
  def write(self, oprot):
18877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18879 
      return
18880 
    oprot.writeStructBegin('addDelayReason_args')
18881 
    if self.orderId is not None:
18882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18883 
      oprot.writeI64(self.orderId)
18884 
      oprot.writeFieldEnd()
18885 
    if self.delayReason is not None:
18886 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18887 
      oprot.writeI32(self.delayReason)
18888 
      oprot.writeFieldEnd()
3986 chandransh 18889 
    if self.furtherDelay is not None:
18890 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18891 
      oprot.writeI64(self.furtherDelay)
18892 
      oprot.writeFieldEnd()
4647 rajveer 18893 
    if self.delayReasonText is not None:
18894 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18895 
      oprot.writeString(self.delayReasonText)
18896 
      oprot.writeFieldEnd()
3553 chandransh 18897 
    oprot.writeFieldStop()
18898 
    oprot.writeStructEnd()
18899 
 
18900 
  def validate(self):
18901 
    return
18902 
 
18903 
 
18904 
  def __repr__(self):
18905 
    L = ['%s=%r' % (key, value)
18906 
      for key, value in self.__dict__.iteritems()]
18907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18908 
 
18909 
  def __eq__(self, other):
18910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18911 
 
18912 
  def __ne__(self, other):
18913 
    return not (self == other)
18914 
 
18915 
class addDelayReason_result:
18916 
  """
18917 
  Attributes:
18918 
   - success
18919 
   - ex
18920 
  """
18921 
 
18922 
  thrift_spec = (
18923 
    (0, TType.BOOL, 'success', None, None, ), # 0
18924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18925 
  )
18926 
 
18927 
  def __init__(self, success=None, ex=None,):
18928 
    self.success = success
18929 
    self.ex = ex
18930 
 
18931 
  def read(self, iprot):
18932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18934 
      return
18935 
    iprot.readStructBegin()
18936 
    while True:
18937 
      (fname, ftype, fid) = iprot.readFieldBegin()
18938 
      if ftype == TType.STOP:
18939 
        break
18940 
      if fid == 0:
18941 
        if ftype == TType.BOOL:
18942 
          self.success = iprot.readBool();
18943 
        else:
18944 
          iprot.skip(ftype)
18945 
      elif fid == 1:
18946 
        if ftype == TType.STRUCT:
18947 
          self.ex = TransactionServiceException()
18948 
          self.ex.read(iprot)
18949 
        else:
18950 
          iprot.skip(ftype)
18951 
      else:
18952 
        iprot.skip(ftype)
18953 
      iprot.readFieldEnd()
18954 
    iprot.readStructEnd()
18955 
 
18956 
  def write(self, oprot):
18957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18959 
      return
18960 
    oprot.writeStructBegin('addDelayReason_result')
18961 
    if self.success is not None:
18962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18963 
      oprot.writeBool(self.success)
18964 
      oprot.writeFieldEnd()
18965 
    if self.ex is not None:
18966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18967 
      self.ex.write(oprot)
18968 
      oprot.writeFieldEnd()
18969 
    oprot.writeFieldStop()
18970 
    oprot.writeStructEnd()
18971 
 
18972 
  def validate(self):
18973 
    return
18974 
 
18975 
 
18976 
  def __repr__(self):
18977 
    L = ['%s=%r' % (key, value)
18978 
      for key, value in self.__dict__.iteritems()]
18979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18980 
 
18981 
  def __eq__(self, other):
18982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18983 
 
18984 
  def __ne__(self, other):
18985 
    return not (self == other)
3956 chandransh 18986 
 
18987 
class reconcileCodCollection_args:
18988 
  """
18989 
  Attributes:
18990 
   - collectedAmountMap
18991 
   - xferBy
18992 
   - xferTxnId
18993 
   - xferDate
18994 
  """
18995 
 
18996 
  thrift_spec = (
18997 
    None, # 0
18998 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18999 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19000 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19001 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19002 
  )
19003 
 
19004 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19005 
    self.collectedAmountMap = collectedAmountMap
19006 
    self.xferBy = xferBy
19007 
    self.xferTxnId = xferTxnId
19008 
    self.xferDate = xferDate
19009 
 
19010 
  def read(self, iprot):
19011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19013 
      return
19014 
    iprot.readStructBegin()
19015 
    while True:
19016 
      (fname, ftype, fid) = iprot.readFieldBegin()
19017 
      if ftype == TType.STOP:
19018 
        break
19019 
      if fid == 1:
19020 
        if ftype == TType.MAP:
19021 
          self.collectedAmountMap = {}
6031 rajveer 19022 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19023 
          for _i414 in xrange(_size410):
19024 
            _key415 = iprot.readString();
19025 
            _val416 = iprot.readDouble();
19026 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19027 
          iprot.readMapEnd()
19028 
        else:
19029 
          iprot.skip(ftype)
19030 
      elif fid == 2:
19031 
        if ftype == TType.STRING:
19032 
          self.xferBy = iprot.readString();
19033 
        else:
19034 
          iprot.skip(ftype)
19035 
      elif fid == 3:
19036 
        if ftype == TType.STRING:
19037 
          self.xferTxnId = iprot.readString();
19038 
        else:
19039 
          iprot.skip(ftype)
19040 
      elif fid == 4:
19041 
        if ftype == TType.I64:
19042 
          self.xferDate = iprot.readI64();
19043 
        else:
19044 
          iprot.skip(ftype)
19045 
      else:
19046 
        iprot.skip(ftype)
19047 
      iprot.readFieldEnd()
19048 
    iprot.readStructEnd()
19049 
 
19050 
  def write(self, oprot):
19051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19053 
      return
19054 
    oprot.writeStructBegin('reconcileCodCollection_args')
19055 
    if self.collectedAmountMap is not None:
19056 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19057 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19058 
      for kiter417,viter418 in self.collectedAmountMap.items():
19059 
        oprot.writeString(kiter417)
19060 
        oprot.writeDouble(viter418)
3956 chandransh 19061 
      oprot.writeMapEnd()
19062 
      oprot.writeFieldEnd()
19063 
    if self.xferBy is not None:
19064 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19065 
      oprot.writeString(self.xferBy)
19066 
      oprot.writeFieldEnd()
19067 
    if self.xferTxnId is not None:
19068 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19069 
      oprot.writeString(self.xferTxnId)
19070 
      oprot.writeFieldEnd()
19071 
    if self.xferDate is not None:
19072 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19073 
      oprot.writeI64(self.xferDate)
19074 
      oprot.writeFieldEnd()
19075 
    oprot.writeFieldStop()
19076 
    oprot.writeStructEnd()
19077 
 
19078 
  def validate(self):
19079 
    return
19080 
 
19081 
 
19082 
  def __repr__(self):
19083 
    L = ['%s=%r' % (key, value)
19084 
      for key, value in self.__dict__.iteritems()]
19085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19086 
 
19087 
  def __eq__(self, other):
19088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19089 
 
19090 
  def __ne__(self, other):
19091 
    return not (self == other)
19092 
 
19093 
class reconcileCodCollection_result:
19094 
  """
19095 
  Attributes:
19096 
   - success
19097 
   - ex
19098 
  """
19099 
 
19100 
  thrift_spec = (
19101 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19103 
  )
19104 
 
19105 
  def __init__(self, success=None, ex=None,):
19106 
    self.success = success
19107 
    self.ex = ex
19108 
 
19109 
  def read(self, iprot):
19110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19112 
      return
19113 
    iprot.readStructBegin()
19114 
    while True:
19115 
      (fname, ftype, fid) = iprot.readFieldBegin()
19116 
      if ftype == TType.STOP:
19117 
        break
19118 
      if fid == 0:
19119 
        if ftype == TType.MAP:
19120 
          self.success = {}
6031 rajveer 19121 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19122 
          for _i423 in xrange(_size419):
19123 
            _key424 = iprot.readString();
19124 
            _val425 = iprot.readString();
19125 
            self.success[_key424] = _val425
3956 chandransh 19126 
          iprot.readMapEnd()
19127 
        else:
19128 
          iprot.skip(ftype)
19129 
      elif fid == 1:
19130 
        if ftype == TType.STRUCT:
19131 
          self.ex = TransactionServiceException()
19132 
          self.ex.read(iprot)
19133 
        else:
19134 
          iprot.skip(ftype)
19135 
      else:
19136 
        iprot.skip(ftype)
19137 
      iprot.readFieldEnd()
19138 
    iprot.readStructEnd()
19139 
 
19140 
  def write(self, oprot):
19141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19143 
      return
19144 
    oprot.writeStructBegin('reconcileCodCollection_result')
19145 
    if self.success is not None:
19146 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19147 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19148 
      for kiter426,viter427 in self.success.items():
19149 
        oprot.writeString(kiter426)
19150 
        oprot.writeString(viter427)
3956 chandransh 19151 
      oprot.writeMapEnd()
19152 
      oprot.writeFieldEnd()
19153 
    if self.ex is not None:
19154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19155 
      self.ex.write(oprot)
19156 
      oprot.writeFieldEnd()
19157 
    oprot.writeFieldStop()
19158 
    oprot.writeStructEnd()
19159 
 
19160 
  def validate(self):
19161 
    return
19162 
 
19163 
 
19164 
  def __repr__(self):
19165 
    L = ['%s=%r' % (key, value)
19166 
      for key, value in self.__dict__.iteritems()]
19167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19168 
 
19169 
  def __eq__(self, other):
19170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19171 
 
19172 
  def __ne__(self, other):
19173 
    return not (self == other)
4008 mandeep.dh 19174 
 
19175 
class getTransactionsRequiringExtraProcessing_args:
19176 
  """
19177 
  Attributes:
19178 
   - category
19179 
  """
19180 
 
19181 
  thrift_spec = (
19182 
    None, # 0
19183 
    (1, TType.I32, 'category', None, None, ), # 1
19184 
  )
19185 
 
19186 
  def __init__(self, category=None,):
19187 
    self.category = category
19188 
 
19189 
  def read(self, iprot):
19190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19192 
      return
19193 
    iprot.readStructBegin()
19194 
    while True:
19195 
      (fname, ftype, fid) = iprot.readFieldBegin()
19196 
      if ftype == TType.STOP:
19197 
        break
19198 
      if fid == 1:
19199 
        if ftype == TType.I32:
19200 
          self.category = iprot.readI32();
19201 
        else:
19202 
          iprot.skip(ftype)
19203 
      else:
19204 
        iprot.skip(ftype)
19205 
      iprot.readFieldEnd()
19206 
    iprot.readStructEnd()
19207 
 
19208 
  def write(self, oprot):
19209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19211 
      return
19212 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19213 
    if self.category is not None:
19214 
      oprot.writeFieldBegin('category', TType.I32, 1)
19215 
      oprot.writeI32(self.category)
19216 
      oprot.writeFieldEnd()
19217 
    oprot.writeFieldStop()
19218 
    oprot.writeStructEnd()
19219 
 
19220 
  def validate(self):
19221 
    return
19222 
 
19223 
 
19224 
  def __repr__(self):
19225 
    L = ['%s=%r' % (key, value)
19226 
      for key, value in self.__dict__.iteritems()]
19227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19228 
 
19229 
  def __eq__(self, other):
19230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19231 
 
19232 
  def __ne__(self, other):
19233 
    return not (self == other)
19234 
 
19235 
class getTransactionsRequiringExtraProcessing_result:
19236 
  """
19237 
  Attributes:
19238 
   - success
19239 
  """
19240 
 
19241 
  thrift_spec = (
19242 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19243 
  )
19244 
 
19245 
  def __init__(self, success=None,):
19246 
    self.success = success
19247 
 
19248 
  def read(self, iprot):
19249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19251 
      return
19252 
    iprot.readStructBegin()
19253 
    while True:
19254 
      (fname, ftype, fid) = iprot.readFieldBegin()
19255 
      if ftype == TType.STOP:
19256 
        break
19257 
      if fid == 0:
19258 
        if ftype == TType.LIST:
19259 
          self.success = []
6031 rajveer 19260 
          (_etype431, _size428) = iprot.readListBegin()
19261 
          for _i432 in xrange(_size428):
19262 
            _elem433 = iprot.readI64();
19263 
            self.success.append(_elem433)
4008 mandeep.dh 19264 
          iprot.readListEnd()
19265 
        else:
19266 
          iprot.skip(ftype)
19267 
      else:
19268 
        iprot.skip(ftype)
19269 
      iprot.readFieldEnd()
19270 
    iprot.readStructEnd()
19271 
 
19272 
  def write(self, oprot):
19273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19275 
      return
19276 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19277 
    if self.success is not None:
19278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19279 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19280 
      for iter434 in self.success:
19281 
        oprot.writeI64(iter434)
4008 mandeep.dh 19282 
      oprot.writeListEnd()
19283 
      oprot.writeFieldEnd()
19284 
    oprot.writeFieldStop()
19285 
    oprot.writeStructEnd()
19286 
 
19287 
  def validate(self):
19288 
    return
19289 
 
19290 
 
19291 
  def __repr__(self):
19292 
    L = ['%s=%r' % (key, value)
19293 
      for key, value in self.__dict__.iteritems()]
19294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19295 
 
19296 
  def __eq__(self, other):
19297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19298 
 
19299 
  def __ne__(self, other):
19300 
    return not (self == other)
19301 
 
19302 
class markTransactionAsProcessed_args:
19303 
  """
19304 
  Attributes:
19305 
   - transactionId
19306 
   - category
19307 
  """
19308 
 
19309 
  thrift_spec = (
19310 
    None, # 0
19311 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19312 
    (2, TType.I32, 'category', None, None, ), # 2
19313 
  )
19314 
 
19315 
  def __init__(self, transactionId=None, category=None,):
19316 
    self.transactionId = transactionId
19317 
    self.category = category
19318 
 
19319 
  def read(self, iprot):
19320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19322 
      return
19323 
    iprot.readStructBegin()
19324 
    while True:
19325 
      (fname, ftype, fid) = iprot.readFieldBegin()
19326 
      if ftype == TType.STOP:
19327 
        break
19328 
      if fid == 1:
19329 
        if ftype == TType.I64:
19330 
          self.transactionId = iprot.readI64();
19331 
        else:
19332 
          iprot.skip(ftype)
19333 
      elif fid == 2:
19334 
        if ftype == TType.I32:
19335 
          self.category = iprot.readI32();
19336 
        else:
19337 
          iprot.skip(ftype)
19338 
      else:
19339 
        iprot.skip(ftype)
19340 
      iprot.readFieldEnd()
19341 
    iprot.readStructEnd()
19342 
 
19343 
  def write(self, oprot):
19344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19346 
      return
19347 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19348 
    if self.transactionId is not None:
19349 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19350 
      oprot.writeI64(self.transactionId)
19351 
      oprot.writeFieldEnd()
19352 
    if self.category is not None:
19353 
      oprot.writeFieldBegin('category', TType.I32, 2)
19354 
      oprot.writeI32(self.category)
19355 
      oprot.writeFieldEnd()
19356 
    oprot.writeFieldStop()
19357 
    oprot.writeStructEnd()
19358 
 
19359 
  def validate(self):
19360 
    return
19361 
 
19362 
 
19363 
  def __repr__(self):
19364 
    L = ['%s=%r' % (key, value)
19365 
      for key, value in self.__dict__.iteritems()]
19366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19367 
 
19368 
  def __eq__(self, other):
19369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19370 
 
19371 
  def __ne__(self, other):
19372 
    return not (self == other)
19373 
 
19374 
class markTransactionAsProcessed_result:
19375 
 
19376 
  thrift_spec = (
19377 
  )
19378 
 
19379 
  def read(self, iprot):
19380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19382 
      return
19383 
    iprot.readStructBegin()
19384 
    while True:
19385 
      (fname, ftype, fid) = iprot.readFieldBegin()
19386 
      if ftype == TType.STOP:
19387 
        break
19388 
      else:
19389 
        iprot.skip(ftype)
19390 
      iprot.readFieldEnd()
19391 
    iprot.readStructEnd()
19392 
 
19393 
  def write(self, oprot):
19394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19396 
      return
19397 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19398 
    oprot.writeFieldStop()
19399 
    oprot.writeStructEnd()
19400 
 
19401 
  def validate(self):
19402 
    return
19403 
 
19404 
 
19405 
  def __repr__(self):
19406 
    L = ['%s=%r' % (key, value)
19407 
      for key, value in self.__dict__.iteritems()]
19408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19409 
 
19410 
  def __eq__(self, other):
19411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19412 
 
19413 
  def __ne__(self, other):
19414 
    return not (self == other)
4018 chandransh 19415 
 
19416 
class getItemWiseRiskyOrdersCount_args:
19417 
 
19418 
  thrift_spec = (
19419 
  )
19420 
 
19421 
  def read(self, iprot):
19422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19424 
      return
19425 
    iprot.readStructBegin()
19426 
    while True:
19427 
      (fname, ftype, fid) = iprot.readFieldBegin()
19428 
      if ftype == TType.STOP:
19429 
        break
19430 
      else:
19431 
        iprot.skip(ftype)
19432 
      iprot.readFieldEnd()
19433 
    iprot.readStructEnd()
19434 
 
19435 
  def write(self, oprot):
19436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19438 
      return
19439 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19440 
    oprot.writeFieldStop()
19441 
    oprot.writeStructEnd()
19442 
 
19443 
  def validate(self):
19444 
    return
19445 
 
19446 
 
19447 
  def __repr__(self):
19448 
    L = ['%s=%r' % (key, value)
19449 
      for key, value in self.__dict__.iteritems()]
19450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19451 
 
19452 
  def __eq__(self, other):
19453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19454 
 
19455 
  def __ne__(self, other):
19456 
    return not (self == other)
19457 
 
19458 
class getItemWiseRiskyOrdersCount_result:
19459 
  """
19460 
  Attributes:
19461 
   - success
19462 
  """
19463 
 
19464 
  thrift_spec = (
19465 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19466 
  )
19467 
 
19468 
  def __init__(self, success=None,):
19469 
    self.success = success
19470 
 
19471 
  def read(self, iprot):
19472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19474 
      return
19475 
    iprot.readStructBegin()
19476 
    while True:
19477 
      (fname, ftype, fid) = iprot.readFieldBegin()
19478 
      if ftype == TType.STOP:
19479 
        break
19480 
      if fid == 0:
19481 
        if ftype == TType.MAP:
19482 
          self.success = {}
6031 rajveer 19483 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19484 
          for _i439 in xrange(_size435):
19485 
            _key440 = iprot.readI64();
19486 
            _val441 = iprot.readI64();
19487 
            self.success[_key440] = _val441
4018 chandransh 19488 
          iprot.readMapEnd()
19489 
        else:
19490 
          iprot.skip(ftype)
19491 
      else:
19492 
        iprot.skip(ftype)
19493 
      iprot.readFieldEnd()
19494 
    iprot.readStructEnd()
19495 
 
19496 
  def write(self, oprot):
19497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19499 
      return
19500 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19501 
    if self.success is not None:
19502 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19503 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19504 
      for kiter442,viter443 in self.success.items():
19505 
        oprot.writeI64(kiter442)
19506 
        oprot.writeI64(viter443)
4018 chandransh 19507 
      oprot.writeMapEnd()
19508 
      oprot.writeFieldEnd()
19509 
    oprot.writeFieldStop()
19510 
    oprot.writeStructEnd()
19511 
 
19512 
  def validate(self):
19513 
    return
19514 
 
19515 
 
19516 
  def __repr__(self):
19517 
    L = ['%s=%r' % (key, value)
19518 
      for key, value in self.__dict__.iteritems()]
19519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19520 
 
19521 
  def __eq__(self, other):
19522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19523 
 
19524 
  def __ne__(self, other):
19525 
    return not (self == other)
4247 rajveer 19526 
 
4295 varun.gupt 19527 
class getOrdersForItemIds_args:
19528 
  """
19529 
  Attributes:
19530 
   - itemIds
19531 
  """
19532 
 
19533 
  thrift_spec = (
19534 
    None, # 0
19535 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19536 
  )
19537 
 
19538 
  def __init__(self, itemIds=None,):
19539 
    self.itemIds = itemIds
19540 
 
19541 
  def read(self, iprot):
19542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19544 
      return
19545 
    iprot.readStructBegin()
19546 
    while True:
19547 
      (fname, ftype, fid) = iprot.readFieldBegin()
19548 
      if ftype == TType.STOP:
19549 
        break
19550 
      if fid == 1:
19551 
        if ftype == TType.LIST:
19552 
          self.itemIds = []
6031 rajveer 19553 
          (_etype447, _size444) = iprot.readListBegin()
19554 
          for _i448 in xrange(_size444):
19555 
            _elem449 = iprot.readI64();
19556 
            self.itemIds.append(_elem449)
4295 varun.gupt 19557 
          iprot.readListEnd()
19558 
        else:
19559 
          iprot.skip(ftype)
19560 
      else:
19561 
        iprot.skip(ftype)
19562 
      iprot.readFieldEnd()
19563 
    iprot.readStructEnd()
19564 
 
19565 
  def write(self, oprot):
19566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19568 
      return
19569 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19570 
    if self.itemIds is not None:
19571 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19572 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19573 
      for iter450 in self.itemIds:
19574 
        oprot.writeI64(iter450)
4295 varun.gupt 19575 
      oprot.writeListEnd()
19576 
      oprot.writeFieldEnd()
19577 
    oprot.writeFieldStop()
19578 
    oprot.writeStructEnd()
19579 
 
19580 
  def validate(self):
19581 
    return
19582 
 
19583 
 
19584 
  def __repr__(self):
19585 
    L = ['%s=%r' % (key, value)
19586 
      for key, value in self.__dict__.iteritems()]
19587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19588 
 
19589 
  def __eq__(self, other):
19590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19591 
 
19592 
  def __ne__(self, other):
19593 
    return not (self == other)
19594 
 
19595 
class getOrdersForItemIds_result:
19596 
  """
19597 
  Attributes:
19598 
   - success
19599 
  """
19600 
 
19601 
  thrift_spec = (
19602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19603 
  )
19604 
 
19605 
  def __init__(self, success=None,):
19606 
    self.success = success
19607 
 
19608 
  def read(self, iprot):
19609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19611 
      return
19612 
    iprot.readStructBegin()
19613 
    while True:
19614 
      (fname, ftype, fid) = iprot.readFieldBegin()
19615 
      if ftype == TType.STOP:
19616 
        break
19617 
      if fid == 0:
19618 
        if ftype == TType.LIST:
19619 
          self.success = []
6031 rajveer 19620 
          (_etype454, _size451) = iprot.readListBegin()
19621 
          for _i455 in xrange(_size451):
19622 
            _elem456 = Order()
19623 
            _elem456.read(iprot)
19624 
            self.success.append(_elem456)
4295 varun.gupt 19625 
          iprot.readListEnd()
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      else:
19629 
        iprot.skip(ftype)
19630 
      iprot.readFieldEnd()
19631 
    iprot.readStructEnd()
19632 
 
19633 
  def write(self, oprot):
19634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19636 
      return
19637 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19638 
    if self.success is not None:
19639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 19641 
      for iter457 in self.success:
19642 
        iter457.write(oprot)
4295 varun.gupt 19643 
      oprot.writeListEnd()
19644 
      oprot.writeFieldEnd()
19645 
    oprot.writeFieldStop()
19646 
    oprot.writeStructEnd()
19647 
 
19648 
  def validate(self):
19649 
    return
19650 
 
19651 
 
19652 
  def __repr__(self):
19653 
    L = ['%s=%r' % (key, value)
19654 
      for key, value in self.__dict__.iteritems()]
19655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19656 
 
19657 
  def __eq__(self, other):
19658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19659 
 
19660 
  def __ne__(self, other):
19661 
    return not (self == other)
19662 
 
4247 rajveer 19663 
class markOrderCancellationRequestReceived_args:
19664 
  """
19665 
  Attributes:
19666 
   - orderId
19667 
  """
19668 
 
19669 
  thrift_spec = (
19670 
    None, # 0
19671 
    (1, TType.I64, 'orderId', None, None, ), # 1
19672 
  )
19673 
 
19674 
  def __init__(self, orderId=None,):
19675 
    self.orderId = orderId
19676 
 
19677 
  def read(self, iprot):
19678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19680 
      return
19681 
    iprot.readStructBegin()
19682 
    while True:
19683 
      (fname, ftype, fid) = iprot.readFieldBegin()
19684 
      if ftype == TType.STOP:
19685 
        break
19686 
      if fid == 1:
19687 
        if ftype == TType.I64:
19688 
          self.orderId = iprot.readI64();
19689 
        else:
19690 
          iprot.skip(ftype)
19691 
      else:
19692 
        iprot.skip(ftype)
19693 
      iprot.readFieldEnd()
19694 
    iprot.readStructEnd()
19695 
 
19696 
  def write(self, oprot):
19697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19699 
      return
19700 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19701 
    if self.orderId is not None:
19702 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19703 
      oprot.writeI64(self.orderId)
19704 
      oprot.writeFieldEnd()
19705 
    oprot.writeFieldStop()
19706 
    oprot.writeStructEnd()
19707 
 
19708 
  def validate(self):
19709 
    return
19710 
 
19711 
 
19712 
  def __repr__(self):
19713 
    L = ['%s=%r' % (key, value)
19714 
      for key, value in self.__dict__.iteritems()]
19715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19716 
 
19717 
  def __eq__(self, other):
19718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19719 
 
19720 
  def __ne__(self, other):
19721 
    return not (self == other)
19722 
 
19723 
class markOrderCancellationRequestReceived_result:
19724 
  """
19725 
  Attributes:
19726 
   - ex
19727 
  """
19728 
 
19729 
  thrift_spec = (
19730 
    None, # 0
19731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19732 
  )
19733 
 
19734 
  def __init__(self, ex=None,):
19735 
    self.ex = ex
19736 
 
19737 
  def read(self, iprot):
19738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19740 
      return
19741 
    iprot.readStructBegin()
19742 
    while True:
19743 
      (fname, ftype, fid) = iprot.readFieldBegin()
19744 
      if ftype == TType.STOP:
19745 
        break
19746 
      if fid == 1:
19747 
        if ftype == TType.STRUCT:
19748 
          self.ex = TransactionServiceException()
19749 
          self.ex.read(iprot)
19750 
        else:
19751 
          iprot.skip(ftype)
19752 
      else:
19753 
        iprot.skip(ftype)
19754 
      iprot.readFieldEnd()
19755 
    iprot.readStructEnd()
19756 
 
19757 
  def write(self, oprot):
19758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19760 
      return
19761 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19762 
    if self.ex is not None:
19763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19764 
      self.ex.write(oprot)
19765 
      oprot.writeFieldEnd()
19766 
    oprot.writeFieldStop()
19767 
    oprot.writeStructEnd()
19768 
 
19769 
  def validate(self):
19770 
    return
19771 
 
19772 
 
19773 
  def __repr__(self):
19774 
    L = ['%s=%r' % (key, value)
19775 
      for key, value in self.__dict__.iteritems()]
19776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19777 
 
19778 
  def __eq__(self, other):
19779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19780 
 
19781 
  def __ne__(self, other):
19782 
    return not (self == other)
19783 
 
19784 
class markOrderCancellationRequestConfirmed_args:
19785 
  """
19786 
  Attributes:
19787 
   - orderId
19788 
  """
19789 
 
19790 
  thrift_spec = (
19791 
    None, # 0
19792 
    (1, TType.I64, 'orderId', None, None, ), # 1
19793 
  )
19794 
 
19795 
  def __init__(self, orderId=None,):
19796 
    self.orderId = orderId
19797 
 
19798 
  def read(self, iprot):
19799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19801 
      return
19802 
    iprot.readStructBegin()
19803 
    while True:
19804 
      (fname, ftype, fid) = iprot.readFieldBegin()
19805 
      if ftype == TType.STOP:
19806 
        break
19807 
      if fid == 1:
19808 
        if ftype == TType.I64:
19809 
          self.orderId = iprot.readI64();
19810 
        else:
19811 
          iprot.skip(ftype)
19812 
      else:
19813 
        iprot.skip(ftype)
19814 
      iprot.readFieldEnd()
19815 
    iprot.readStructEnd()
19816 
 
19817 
  def write(self, oprot):
19818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19820 
      return
19821 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19822 
    if self.orderId is not None:
19823 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19824 
      oprot.writeI64(self.orderId)
19825 
      oprot.writeFieldEnd()
19826 
    oprot.writeFieldStop()
19827 
    oprot.writeStructEnd()
19828 
 
19829 
  def validate(self):
19830 
    return
19831 
 
19832 
 
19833 
  def __repr__(self):
19834 
    L = ['%s=%r' % (key, value)
19835 
      for key, value in self.__dict__.iteritems()]
19836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19837 
 
19838 
  def __eq__(self, other):
19839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19840 
 
19841 
  def __ne__(self, other):
19842 
    return not (self == other)
19843 
 
19844 
class markOrderCancellationRequestConfirmed_result:
19845 
  """
19846 
  Attributes:
19847 
   - ex
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    None, # 0
19852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19853 
  )
19854 
 
19855 
  def __init__(self, ex=None,):
19856 
    self.ex = ex
19857 
 
19858 
  def read(self, iprot):
19859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19861 
      return
19862 
    iprot.readStructBegin()
19863 
    while True:
19864 
      (fname, ftype, fid) = iprot.readFieldBegin()
19865 
      if ftype == TType.STOP:
19866 
        break
19867 
      if fid == 1:
19868 
        if ftype == TType.STRUCT:
19869 
          self.ex = TransactionServiceException()
19870 
          self.ex.read(iprot)
19871 
        else:
19872 
          iprot.skip(ftype)
19873 
      else:
19874 
        iprot.skip(ftype)
19875 
      iprot.readFieldEnd()
19876 
    iprot.readStructEnd()
19877 
 
19878 
  def write(self, oprot):
19879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19881 
      return
19882 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19883 
    if self.ex is not None:
19884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19885 
      self.ex.write(oprot)
19886 
      oprot.writeFieldEnd()
19887 
    oprot.writeFieldStop()
19888 
    oprot.writeStructEnd()
19889 
 
19890 
  def validate(self):
19891 
    return
19892 
 
19893 
 
19894 
  def __repr__(self):
19895 
    L = ['%s=%r' % (key, value)
19896 
      for key, value in self.__dict__.iteritems()]
19897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19898 
 
19899 
  def __eq__(self, other):
19900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19901 
 
19902 
  def __ne__(self, other):
19903 
    return not (self == other)
19904 
 
19905 
class markOrderCancellationRequestDenied_args:
19906 
  """
19907 
  Attributes:
19908 
   - orderId
19909 
  """
19910 
 
19911 
  thrift_spec = (
19912 
    None, # 0
19913 
    (1, TType.I64, 'orderId', None, None, ), # 1
19914 
  )
19915 
 
19916 
  def __init__(self, orderId=None,):
19917 
    self.orderId = orderId
19918 
 
19919 
  def read(self, iprot):
19920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19922 
      return
19923 
    iprot.readStructBegin()
19924 
    while True:
19925 
      (fname, ftype, fid) = iprot.readFieldBegin()
19926 
      if ftype == TType.STOP:
19927 
        break
19928 
      if fid == 1:
19929 
        if ftype == TType.I64:
19930 
          self.orderId = iprot.readI64();
19931 
        else:
19932 
          iprot.skip(ftype)
19933 
      else:
19934 
        iprot.skip(ftype)
19935 
      iprot.readFieldEnd()
19936 
    iprot.readStructEnd()
19937 
 
19938 
  def write(self, oprot):
19939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19941 
      return
19942 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19943 
    if self.orderId is not None:
19944 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19945 
      oprot.writeI64(self.orderId)
19946 
      oprot.writeFieldEnd()
19947 
    oprot.writeFieldStop()
19948 
    oprot.writeStructEnd()
19949 
 
19950 
  def validate(self):
19951 
    return
19952 
 
19953 
 
19954 
  def __repr__(self):
19955 
    L = ['%s=%r' % (key, value)
19956 
      for key, value in self.__dict__.iteritems()]
19957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19958 
 
19959 
  def __eq__(self, other):
19960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19961 
 
19962 
  def __ne__(self, other):
19963 
    return not (self == other)
19964 
 
19965 
class markOrderCancellationRequestDenied_result:
19966 
  """
19967 
  Attributes:
19968 
   - ex
19969 
  """
19970 
 
19971 
  thrift_spec = (
19972 
    None, # 0
19973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19974 
  )
19975 
 
19976 
  def __init__(self, ex=None,):
19977 
    self.ex = ex
19978 
 
19979 
  def read(self, iprot):
19980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19982 
      return
19983 
    iprot.readStructBegin()
19984 
    while True:
19985 
      (fname, ftype, fid) = iprot.readFieldBegin()
19986 
      if ftype == TType.STOP:
19987 
        break
19988 
      if fid == 1:
19989 
        if ftype == TType.STRUCT:
19990 
          self.ex = TransactionServiceException()
19991 
          self.ex.read(iprot)
19992 
        else:
19993 
          iprot.skip(ftype)
19994 
      else:
19995 
        iprot.skip(ftype)
19996 
      iprot.readFieldEnd()
19997 
    iprot.readStructEnd()
19998 
 
19999 
  def write(self, oprot):
20000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20002 
      return
20003 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20004 
    if self.ex is not None:
20005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20006 
      self.ex.write(oprot)
20007 
      oprot.writeFieldEnd()
20008 
    oprot.writeFieldStop()
20009 
    oprot.writeStructEnd()
20010 
 
20011 
  def validate(self):
20012 
    return
20013 
 
20014 
 
20015 
  def __repr__(self):
20016 
    L = ['%s=%r' % (key, value)
20017 
      for key, value in self.__dict__.iteritems()]
20018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20019 
 
20020 
  def __eq__(self, other):
20021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20022 
 
20023 
  def __ne__(self, other):
20024 
    return not (self == other)
20025 
 
4258 rajveer 20026 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20027 
  """
20028 
  Attributes:
4258 rajveer 20029 
   - transactionId
4247 rajveer 20030 
  """
20031 
 
20032 
  thrift_spec = (
20033 
    None, # 0
4258 rajveer 20034 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20035 
  )
20036 
 
4258 rajveer 20037 
  def __init__(self, transactionId=None,):
20038 
    self.transactionId = transactionId
4247 rajveer 20039 
 
20040 
  def read(self, iprot):
20041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20043 
      return
20044 
    iprot.readStructBegin()
20045 
    while True:
20046 
      (fname, ftype, fid) = iprot.readFieldBegin()
20047 
      if ftype == TType.STOP:
20048 
        break
20049 
      if fid == 1:
20050 
        if ftype == TType.I64:
4258 rajveer 20051 
          self.transactionId = iprot.readI64();
4247 rajveer 20052 
        else:
20053 
          iprot.skip(ftype)
20054 
      else:
20055 
        iprot.skip(ftype)
20056 
      iprot.readFieldEnd()
20057 
    iprot.readStructEnd()
20058 
 
20059 
  def write(self, oprot):
20060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20062 
      return
4258 rajveer 20063 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20064 
    if self.transactionId is not None:
20065 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20066 
      oprot.writeI64(self.transactionId)
4247 rajveer 20067 
      oprot.writeFieldEnd()
20068 
    oprot.writeFieldStop()
20069 
    oprot.writeStructEnd()
20070 
 
20071 
  def validate(self):
20072 
    return
20073 
 
20074 
 
20075 
  def __repr__(self):
20076 
    L = ['%s=%r' % (key, value)
20077 
      for key, value in self.__dict__.iteritems()]
20078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20079 
 
20080 
  def __eq__(self, other):
20081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20082 
 
20083 
  def __ne__(self, other):
20084 
    return not (self == other)
20085 
 
4258 rajveer 20086 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20087 
  """
20088 
  Attributes:
20089 
   - ex
20090 
  """
20091 
 
20092 
  thrift_spec = (
20093 
    None, # 0
20094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20095 
  )
20096 
 
20097 
  def __init__(self, ex=None,):
20098 
    self.ex = ex
20099 
 
20100 
  def read(self, iprot):
20101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20103 
      return
20104 
    iprot.readStructBegin()
20105 
    while True:
20106 
      (fname, ftype, fid) = iprot.readFieldBegin()
20107 
      if ftype == TType.STOP:
20108 
        break
20109 
      if fid == 1:
20110 
        if ftype == TType.STRUCT:
20111 
          self.ex = TransactionServiceException()
20112 
          self.ex.read(iprot)
20113 
        else:
20114 
          iprot.skip(ftype)
20115 
      else:
20116 
        iprot.skip(ftype)
20117 
      iprot.readFieldEnd()
20118 
    iprot.readStructEnd()
20119 
 
20120 
  def write(self, oprot):
20121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20123 
      return
4258 rajveer 20124 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20125 
    if self.ex is not None:
20126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20127 
      self.ex.write(oprot)
20128 
      oprot.writeFieldEnd()
20129 
    oprot.writeFieldStop()
20130 
    oprot.writeStructEnd()
20131 
 
20132 
  def validate(self):
20133 
    return
20134 
 
20135 
 
20136 
  def __repr__(self):
20137 
    L = ['%s=%r' % (key, value)
20138 
      for key, value in self.__dict__.iteritems()]
20139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20140 
 
20141 
  def __eq__(self, other):
20142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20143 
 
20144 
  def __ne__(self, other):
20145 
    return not (self == other)
4259 anupam.sin 20146 
 
20147 
class refundTransaction_args:
20148 
  """
20149 
  Attributes:
20150 
   - transactionId
20151 
   - refundedBy
20152 
   - reason
20153 
  """
20154 
 
20155 
  thrift_spec = (
20156 
    None, # 0
20157 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20158 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20159 
    (3, TType.STRING, 'reason', None, None, ), # 3
20160 
  )
20161 
 
20162 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20163 
    self.transactionId = transactionId
20164 
    self.refundedBy = refundedBy
20165 
    self.reason = reason
20166 
 
20167 
  def read(self, iprot):
20168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20170 
      return
20171 
    iprot.readStructBegin()
20172 
    while True:
20173 
      (fname, ftype, fid) = iprot.readFieldBegin()
20174 
      if ftype == TType.STOP:
20175 
        break
20176 
      if fid == 1:
20177 
        if ftype == TType.I64:
20178 
          self.transactionId = iprot.readI64();
20179 
        else:
20180 
          iprot.skip(ftype)
20181 
      elif fid == 2:
20182 
        if ftype == TType.STRING:
20183 
          self.refundedBy = iprot.readString();
20184 
        else:
20185 
          iprot.skip(ftype)
20186 
      elif fid == 3:
20187 
        if ftype == TType.STRING:
20188 
          self.reason = iprot.readString();
20189 
        else:
20190 
          iprot.skip(ftype)
20191 
      else:
20192 
        iprot.skip(ftype)
20193 
      iprot.readFieldEnd()
20194 
    iprot.readStructEnd()
20195 
 
20196 
  def write(self, oprot):
20197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20199 
      return
20200 
    oprot.writeStructBegin('refundTransaction_args')
20201 
    if self.transactionId is not None:
20202 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20203 
      oprot.writeI64(self.transactionId)
20204 
      oprot.writeFieldEnd()
20205 
    if self.refundedBy is not None:
20206 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20207 
      oprot.writeString(self.refundedBy)
20208 
      oprot.writeFieldEnd()
20209 
    if self.reason is not None:
20210 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20211 
      oprot.writeString(self.reason)
20212 
      oprot.writeFieldEnd()
20213 
    oprot.writeFieldStop()
20214 
    oprot.writeStructEnd()
20215 
 
20216 
  def validate(self):
20217 
    return
20218 
 
20219 
 
20220 
  def __repr__(self):
20221 
    L = ['%s=%r' % (key, value)
20222 
      for key, value in self.__dict__.iteritems()]
20223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20224 
 
20225 
  def __eq__(self, other):
20226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20227 
 
20228 
  def __ne__(self, other):
20229 
    return not (self == other)
20230 
 
20231 
class refundTransaction_result:
20232 
  """
20233 
  Attributes:
20234 
   - ex
20235 
  """
20236 
 
20237 
  thrift_spec = (
20238 
    None, # 0
20239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20240 
  )
20241 
 
20242 
  def __init__(self, ex=None,):
20243 
    self.ex = ex
20244 
 
20245 
  def read(self, iprot):
20246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20248 
      return
20249 
    iprot.readStructBegin()
20250 
    while True:
20251 
      (fname, ftype, fid) = iprot.readFieldBegin()
20252 
      if ftype == TType.STOP:
20253 
        break
20254 
      if fid == 1:
20255 
        if ftype == TType.STRUCT:
20256 
          self.ex = TransactionServiceException()
20257 
          self.ex.read(iprot)
20258 
        else:
20259 
          iprot.skip(ftype)
20260 
      else:
20261 
        iprot.skip(ftype)
20262 
      iprot.readFieldEnd()
20263 
    iprot.readStructEnd()
20264 
 
20265 
  def write(self, oprot):
20266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20268 
      return
20269 
    oprot.writeStructBegin('refundTransaction_result')
20270 
    if self.ex is not None:
20271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20272 
      self.ex.write(oprot)
20273 
      oprot.writeFieldEnd()
20274 
    oprot.writeFieldStop()
20275 
    oprot.writeStructEnd()
20276 
 
20277 
  def validate(self):
20278 
    return
20279 
 
20280 
 
20281 
  def __repr__(self):
20282 
    L = ['%s=%r' % (key, value)
20283 
      for key, value in self.__dict__.iteritems()]
20284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20285 
 
20286 
  def __eq__(self, other):
20287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20288 
 
20289 
  def __ne__(self, other):
20290 
    return not (self == other)
4285 rajveer 20291 
 
4324 mandeep.dh 20292 
class updateShipmentAddress_args:
20293 
  """
20294 
  Attributes:
20295 
   - orderId
20296 
   - addressId
20297 
  """
20298 
 
20299 
  thrift_spec = (
20300 
    None, # 0
20301 
    (1, TType.I64, 'orderId', None, None, ), # 1
20302 
    (2, TType.I64, 'addressId', None, None, ), # 2
20303 
  )
20304 
 
20305 
  def __init__(self, orderId=None, addressId=None,):
20306 
    self.orderId = orderId
20307 
    self.addressId = addressId
20308 
 
20309 
  def read(self, iprot):
20310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20312 
      return
20313 
    iprot.readStructBegin()
20314 
    while True:
20315 
      (fname, ftype, fid) = iprot.readFieldBegin()
20316 
      if ftype == TType.STOP:
20317 
        break
20318 
      if fid == 1:
20319 
        if ftype == TType.I64:
20320 
          self.orderId = iprot.readI64();
20321 
        else:
20322 
          iprot.skip(ftype)
20323 
      elif fid == 2:
20324 
        if ftype == TType.I64:
20325 
          self.addressId = iprot.readI64();
20326 
        else:
20327 
          iprot.skip(ftype)
20328 
      else:
20329 
        iprot.skip(ftype)
20330 
      iprot.readFieldEnd()
20331 
    iprot.readStructEnd()
20332 
 
20333 
  def write(self, oprot):
20334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20336 
      return
20337 
    oprot.writeStructBegin('updateShipmentAddress_args')
20338 
    if self.orderId is not None:
20339 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20340 
      oprot.writeI64(self.orderId)
20341 
      oprot.writeFieldEnd()
20342 
    if self.addressId is not None:
20343 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20344 
      oprot.writeI64(self.addressId)
20345 
      oprot.writeFieldEnd()
20346 
    oprot.writeFieldStop()
20347 
    oprot.writeStructEnd()
20348 
 
20349 
  def validate(self):
20350 
    return
20351 
 
20352 
 
20353 
  def __repr__(self):
20354 
    L = ['%s=%r' % (key, value)
20355 
      for key, value in self.__dict__.iteritems()]
20356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20357 
 
20358 
  def __eq__(self, other):
20359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20360 
 
20361 
  def __ne__(self, other):
20362 
    return not (self == other)
20363 
 
20364 
class updateShipmentAddress_result:
20365 
  """
20366 
  Attributes:
20367 
   - ex
20368 
  """
20369 
 
20370 
  thrift_spec = (
20371 
    None, # 0
20372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20373 
  )
20374 
 
20375 
  def __init__(self, ex=None,):
20376 
    self.ex = ex
20377 
 
20378 
  def read(self, iprot):
20379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20381 
      return
20382 
    iprot.readStructBegin()
20383 
    while True:
20384 
      (fname, ftype, fid) = iprot.readFieldBegin()
20385 
      if ftype == TType.STOP:
20386 
        break
20387 
      if fid == 1:
20388 
        if ftype == TType.STRUCT:
20389 
          self.ex = TransactionServiceException()
20390 
          self.ex.read(iprot)
20391 
        else:
20392 
          iprot.skip(ftype)
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('updateShipmentAddress_result')
20403 
    if self.ex is not None:
20404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20405 
      self.ex.write(oprot)
20406 
      oprot.writeFieldEnd()
20407 
    oprot.writeFieldStop()
20408 
    oprot.writeStructEnd()
20409 
 
20410 
  def validate(self):
20411 
    return
20412 
 
20413 
 
20414 
  def __repr__(self):
20415 
    L = ['%s=%r' % (key, value)
20416 
      for key, value in self.__dict__.iteritems()]
20417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20418 
 
20419 
  def __eq__(self, other):
20420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20421 
 
20422 
  def __ne__(self, other):
20423 
    return not (self == other)
20424 
 
4285 rajveer 20425 
class acceptOrdersForItemId_args:
20426 
  """
20427 
  Attributes:
20428 
   - itemId
20429 
   - inventory
20430 
  """
20431 
 
20432 
  thrift_spec = (
20433 
    None, # 0
20434 
    (1, TType.I64, 'itemId', None, None, ), # 1
20435 
    (2, TType.I64, 'inventory', None, None, ), # 2
20436 
  )
20437 
 
20438 
  def __init__(self, itemId=None, inventory=None,):
20439 
    self.itemId = itemId
20440 
    self.inventory = inventory
20441 
 
20442 
  def read(self, iprot):
20443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20445 
      return
20446 
    iprot.readStructBegin()
20447 
    while True:
20448 
      (fname, ftype, fid) = iprot.readFieldBegin()
20449 
      if ftype == TType.STOP:
20450 
        break
20451 
      if fid == 1:
20452 
        if ftype == TType.I64:
20453 
          self.itemId = iprot.readI64();
20454 
        else:
20455 
          iprot.skip(ftype)
20456 
      elif fid == 2:
20457 
        if ftype == TType.I64:
20458 
          self.inventory = iprot.readI64();
20459 
        else:
20460 
          iprot.skip(ftype)
20461 
      else:
20462 
        iprot.skip(ftype)
20463 
      iprot.readFieldEnd()
20464 
    iprot.readStructEnd()
20465 
 
20466 
  def write(self, oprot):
20467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20469 
      return
20470 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20471 
    if self.itemId is not None:
20472 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20473 
      oprot.writeI64(self.itemId)
20474 
      oprot.writeFieldEnd()
20475 
    if self.inventory is not None:
20476 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20477 
      oprot.writeI64(self.inventory)
20478 
      oprot.writeFieldEnd()
20479 
    oprot.writeFieldStop()
20480 
    oprot.writeStructEnd()
20481 
 
20482 
  def validate(self):
20483 
    return
20484 
 
20485 
 
20486 
  def __repr__(self):
20487 
    L = ['%s=%r' % (key, value)
20488 
      for key, value in self.__dict__.iteritems()]
20489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20490 
 
20491 
  def __eq__(self, other):
20492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20493 
 
20494 
  def __ne__(self, other):
20495 
    return not (self == other)
20496 
 
20497 
class acceptOrdersForItemId_result:
20498 
  """
20499 
  Attributes:
20500 
   - success
20501 
   - ex
20502 
  """
20503 
 
20504 
  thrift_spec = (
20505 
    (0, TType.BOOL, 'success', None, None, ), # 0
20506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20507 
  )
20508 
 
20509 
  def __init__(self, success=None, ex=None,):
20510 
    self.success = success
20511 
    self.ex = ex
20512 
 
20513 
  def read(self, iprot):
20514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20516 
      return
20517 
    iprot.readStructBegin()
20518 
    while True:
20519 
      (fname, ftype, fid) = iprot.readFieldBegin()
20520 
      if ftype == TType.STOP:
20521 
        break
20522 
      if fid == 0:
20523 
        if ftype == TType.BOOL:
20524 
          self.success = iprot.readBool();
20525 
        else:
20526 
          iprot.skip(ftype)
20527 
      elif fid == 1:
20528 
        if ftype == TType.STRUCT:
20529 
          self.ex = TransactionServiceException()
20530 
          self.ex.read(iprot)
20531 
        else:
20532 
          iprot.skip(ftype)
20533 
      else:
20534 
        iprot.skip(ftype)
20535 
      iprot.readFieldEnd()
20536 
    iprot.readStructEnd()
20537 
 
20538 
  def write(self, oprot):
20539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20541 
      return
20542 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20543 
    if self.success is not None:
20544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20545 
      oprot.writeBool(self.success)
20546 
      oprot.writeFieldEnd()
20547 
    if self.ex is not None:
20548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20549 
      self.ex.write(oprot)
20550 
      oprot.writeFieldEnd()
20551 
    oprot.writeFieldStop()
20552 
    oprot.writeStructEnd()
20553 
 
20554 
  def validate(self):
20555 
    return
20556 
 
20557 
 
20558 
  def __repr__(self):
20559 
    L = ['%s=%r' % (key, value)
20560 
      for key, value in self.__dict__.iteritems()]
20561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20562 
 
20563 
  def __eq__(self, other):
20564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20565 
 
20566 
  def __ne__(self, other):
20567 
    return not (self == other)
4303 rajveer 20568 
 
20569 
class markOrdersAsPORaised_args:
20570 
  """
20571 
  Attributes:
20572 
   - vendorId
20573 
   - itemId
20574 
   - quantity
20575 
   - estimate
4369 rajveer 20576 
   - isReminder
4303 rajveer 20577 
  """
20578 
 
20579 
  thrift_spec = (
20580 
    None, # 0
20581 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20582 
    (2, TType.I64, 'itemId', None, None, ), # 2
20583 
    (3, TType.I64, 'quantity', None, None, ), # 3
20584 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20585 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20586 
  )
20587 
 
4369 rajveer 20588 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20589 
    self.vendorId = vendorId
20590 
    self.itemId = itemId
20591 
    self.quantity = quantity
20592 
    self.estimate = estimate
4369 rajveer 20593 
    self.isReminder = isReminder
4303 rajveer 20594 
 
20595 
  def read(self, iprot):
20596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20598 
      return
20599 
    iprot.readStructBegin()
20600 
    while True:
20601 
      (fname, ftype, fid) = iprot.readFieldBegin()
20602 
      if ftype == TType.STOP:
20603 
        break
20604 
      if fid == 1:
20605 
        if ftype == TType.I64:
20606 
          self.vendorId = iprot.readI64();
20607 
        else:
20608 
          iprot.skip(ftype)
20609 
      elif fid == 2:
20610 
        if ftype == TType.I64:
20611 
          self.itemId = iprot.readI64();
20612 
        else:
20613 
          iprot.skip(ftype)
20614 
      elif fid == 3:
20615 
        if ftype == TType.I64:
20616 
          self.quantity = iprot.readI64();
20617 
        else:
20618 
          iprot.skip(ftype)
20619 
      elif fid == 4:
20620 
        if ftype == TType.I64:
20621 
          self.estimate = iprot.readI64();
20622 
        else:
20623 
          iprot.skip(ftype)
4369 rajveer 20624 
      elif fid == 5:
20625 
        if ftype == TType.BOOL:
20626 
          self.isReminder = iprot.readBool();
20627 
        else:
20628 
          iprot.skip(ftype)
4303 rajveer 20629 
      else:
20630 
        iprot.skip(ftype)
20631 
      iprot.readFieldEnd()
20632 
    iprot.readStructEnd()
20633 
 
20634 
  def write(self, oprot):
20635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20637 
      return
20638 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20639 
    if self.vendorId is not None:
20640 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20641 
      oprot.writeI64(self.vendorId)
20642 
      oprot.writeFieldEnd()
20643 
    if self.itemId is not None:
20644 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20645 
      oprot.writeI64(self.itemId)
20646 
      oprot.writeFieldEnd()
20647 
    if self.quantity is not None:
20648 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20649 
      oprot.writeI64(self.quantity)
20650 
      oprot.writeFieldEnd()
20651 
    if self.estimate is not None:
20652 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20653 
      oprot.writeI64(self.estimate)
20654 
      oprot.writeFieldEnd()
4369 rajveer 20655 
    if self.isReminder is not None:
20656 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20657 
      oprot.writeBool(self.isReminder)
20658 
      oprot.writeFieldEnd()
4303 rajveer 20659 
    oprot.writeFieldStop()
20660 
    oprot.writeStructEnd()
20661 
 
20662 
  def validate(self):
20663 
    return
20664 
 
20665 
 
20666 
  def __repr__(self):
20667 
    L = ['%s=%r' % (key, value)
20668 
      for key, value in self.__dict__.iteritems()]
20669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20670 
 
20671 
  def __eq__(self, other):
20672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20673 
 
20674 
  def __ne__(self, other):
20675 
    return not (self == other)
20676 
 
20677 
class markOrdersAsPORaised_result:
20678 
  """
20679 
  Attributes:
20680 
   - ex
20681 
  """
20682 
 
20683 
  thrift_spec = (
20684 
    None, # 0
20685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20686 
  )
20687 
 
20688 
  def __init__(self, ex=None,):
20689 
    self.ex = ex
20690 
 
20691 
  def read(self, iprot):
20692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20694 
      return
20695 
    iprot.readStructBegin()
20696 
    while True:
20697 
      (fname, ftype, fid) = iprot.readFieldBegin()
20698 
      if ftype == TType.STOP:
20699 
        break
20700 
      if fid == 1:
20701 
        if ftype == TType.STRUCT:
20702 
          self.ex = TransactionServiceException()
20703 
          self.ex.read(iprot)
20704 
        else:
20705 
          iprot.skip(ftype)
20706 
      else:
20707 
        iprot.skip(ftype)
20708 
      iprot.readFieldEnd()
20709 
    iprot.readStructEnd()
20710 
 
20711 
  def write(self, oprot):
20712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20714 
      return
20715 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20716 
    if self.ex is not None:
20717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20718 
      self.ex.write(oprot)
20719 
      oprot.writeFieldEnd()
20720 
    oprot.writeFieldStop()
20721 
    oprot.writeStructEnd()
20722 
 
20723 
  def validate(self):
20724 
    return
20725 
 
20726 
 
20727 
  def __repr__(self):
20728 
    L = ['%s=%r' % (key, value)
20729 
      for key, value in self.__dict__.iteritems()]
20730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20731 
 
20732 
  def __eq__(self, other):
20733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20734 
 
20735 
  def __ne__(self, other):
20736 
    return not (self == other)
20737 
 
20738 
class markOrdersAsReversalInitiated_args:
20739 
  """
20740 
  Attributes:
20741 
   - vendorId
20742 
   - itemId
20743 
   - quantity
20744 
   - estimate
4369 rajveer 20745 
   - isReminder
4303 rajveer 20746 
  """
20747 
 
20748 
  thrift_spec = (
20749 
    None, # 0
20750 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20751 
    (2, TType.I64, 'itemId', None, None, ), # 2
20752 
    (3, TType.I64, 'quantity', None, None, ), # 3
20753 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20754 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20755 
  )
20756 
 
4369 rajveer 20757 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20758 
    self.vendorId = vendorId
20759 
    self.itemId = itemId
20760 
    self.quantity = quantity
20761 
    self.estimate = estimate
4369 rajveer 20762 
    self.isReminder = isReminder
4303 rajveer 20763 
 
20764 
  def read(self, iprot):
20765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20767 
      return
20768 
    iprot.readStructBegin()
20769 
    while True:
20770 
      (fname, ftype, fid) = iprot.readFieldBegin()
20771 
      if ftype == TType.STOP:
20772 
        break
20773 
      if fid == 1:
20774 
        if ftype == TType.I64:
20775 
          self.vendorId = iprot.readI64();
20776 
        else:
20777 
          iprot.skip(ftype)
20778 
      elif fid == 2:
20779 
        if ftype == TType.I64:
20780 
          self.itemId = iprot.readI64();
20781 
        else:
20782 
          iprot.skip(ftype)
20783 
      elif fid == 3:
20784 
        if ftype == TType.I64:
20785 
          self.quantity = iprot.readI64();
20786 
        else:
20787 
          iprot.skip(ftype)
20788 
      elif fid == 4:
20789 
        if ftype == TType.I64:
20790 
          self.estimate = iprot.readI64();
20791 
        else:
20792 
          iprot.skip(ftype)
4369 rajveer 20793 
      elif fid == 5:
20794 
        if ftype == TType.BOOL:
20795 
          self.isReminder = iprot.readBool();
20796 
        else:
20797 
          iprot.skip(ftype)
4303 rajveer 20798 
      else:
20799 
        iprot.skip(ftype)
20800 
      iprot.readFieldEnd()
20801 
    iprot.readStructEnd()
20802 
 
20803 
  def write(self, oprot):
20804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20806 
      return
20807 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20808 
    if self.vendorId is not None:
20809 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20810 
      oprot.writeI64(self.vendorId)
20811 
      oprot.writeFieldEnd()
20812 
    if self.itemId is not None:
20813 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20814 
      oprot.writeI64(self.itemId)
20815 
      oprot.writeFieldEnd()
20816 
    if self.quantity is not None:
20817 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20818 
      oprot.writeI64(self.quantity)
20819 
      oprot.writeFieldEnd()
20820 
    if self.estimate is not None:
20821 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20822 
      oprot.writeI64(self.estimate)
20823 
      oprot.writeFieldEnd()
4369 rajveer 20824 
    if self.isReminder is not None:
20825 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20826 
      oprot.writeBool(self.isReminder)
20827 
      oprot.writeFieldEnd()
4303 rajveer 20828 
    oprot.writeFieldStop()
20829 
    oprot.writeStructEnd()
20830 
 
20831 
  def validate(self):
20832 
    return
20833 
 
20834 
 
20835 
  def __repr__(self):
20836 
    L = ['%s=%r' % (key, value)
20837 
      for key, value in self.__dict__.iteritems()]
20838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20839 
 
20840 
  def __eq__(self, other):
20841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20842 
 
20843 
  def __ne__(self, other):
20844 
    return not (self == other)
20845 
 
20846 
class markOrdersAsReversalInitiated_result:
20847 
  """
20848 
  Attributes:
20849 
   - ex
20850 
  """
20851 
 
20852 
  thrift_spec = (
20853 
    None, # 0
20854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20855 
  )
20856 
 
20857 
  def __init__(self, ex=None,):
20858 
    self.ex = ex
20859 
 
20860 
  def read(self, iprot):
20861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20863 
      return
20864 
    iprot.readStructBegin()
20865 
    while True:
20866 
      (fname, ftype, fid) = iprot.readFieldBegin()
20867 
      if ftype == TType.STOP:
20868 
        break
20869 
      if fid == 1:
20870 
        if ftype == TType.STRUCT:
20871 
          self.ex = TransactionServiceException()
20872 
          self.ex.read(iprot)
20873 
        else:
20874 
          iprot.skip(ftype)
20875 
      else:
20876 
        iprot.skip(ftype)
20877 
      iprot.readFieldEnd()
20878 
    iprot.readStructEnd()
20879 
 
20880 
  def write(self, oprot):
20881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20883 
      return
20884 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20885 
    if self.ex is not None:
20886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20887 
      self.ex.write(oprot)
20888 
      oprot.writeFieldEnd()
20889 
    oprot.writeFieldStop()
20890 
    oprot.writeStructEnd()
20891 
 
20892 
  def validate(self):
20893 
    return
20894 
 
20895 
 
20896 
  def __repr__(self):
20897 
    L = ['%s=%r' % (key, value)
20898 
      for key, value in self.__dict__.iteritems()]
20899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20900 
 
20901 
  def __eq__(self, other):
20902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20903 
 
20904 
  def __ne__(self, other):
20905 
    return not (self == other)
20906 
 
20907 
class markOrdersAsNotAvailabke_args:
20908 
  """
20909 
  Attributes:
20910 
   - vendorId
20911 
   - itemId
20912 
   - quantity
20913 
   - estimate
4369 rajveer 20914 
   - isReminder
4303 rajveer 20915 
  """
20916 
 
20917 
  thrift_spec = (
20918 
    None, # 0
20919 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20920 
    (2, TType.I64, 'itemId', None, None, ), # 2
20921 
    (3, TType.I64, 'quantity', None, None, ), # 3
20922 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20923 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20924 
  )
20925 
 
4369 rajveer 20926 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20927 
    self.vendorId = vendorId
20928 
    self.itemId = itemId
20929 
    self.quantity = quantity
20930 
    self.estimate = estimate
4369 rajveer 20931 
    self.isReminder = isReminder
4303 rajveer 20932 
 
20933 
  def read(self, iprot):
20934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20936 
      return
20937 
    iprot.readStructBegin()
20938 
    while True:
20939 
      (fname, ftype, fid) = iprot.readFieldBegin()
20940 
      if ftype == TType.STOP:
20941 
        break
20942 
      if fid == 1:
20943 
        if ftype == TType.I64:
20944 
          self.vendorId = iprot.readI64();
20945 
        else:
20946 
          iprot.skip(ftype)
20947 
      elif fid == 2:
20948 
        if ftype == TType.I64:
20949 
          self.itemId = iprot.readI64();
20950 
        else:
20951 
          iprot.skip(ftype)
20952 
      elif fid == 3:
20953 
        if ftype == TType.I64:
20954 
          self.quantity = iprot.readI64();
20955 
        else:
20956 
          iprot.skip(ftype)
20957 
      elif fid == 4:
20958 
        if ftype == TType.I64:
20959 
          self.estimate = iprot.readI64();
20960 
        else:
20961 
          iprot.skip(ftype)
4369 rajveer 20962 
      elif fid == 5:
20963 
        if ftype == TType.BOOL:
20964 
          self.isReminder = iprot.readBool();
20965 
        else:
20966 
          iprot.skip(ftype)
4303 rajveer 20967 
      else:
20968 
        iprot.skip(ftype)
20969 
      iprot.readFieldEnd()
20970 
    iprot.readStructEnd()
20971 
 
20972 
  def write(self, oprot):
20973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20975 
      return
20976 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20977 
    if self.vendorId is not None:
20978 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20979 
      oprot.writeI64(self.vendorId)
20980 
      oprot.writeFieldEnd()
20981 
    if self.itemId is not None:
20982 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20983 
      oprot.writeI64(self.itemId)
20984 
      oprot.writeFieldEnd()
20985 
    if self.quantity is not None:
20986 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20987 
      oprot.writeI64(self.quantity)
20988 
      oprot.writeFieldEnd()
20989 
    if self.estimate is not None:
20990 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20991 
      oprot.writeI64(self.estimate)
20992 
      oprot.writeFieldEnd()
4369 rajveer 20993 
    if self.isReminder is not None:
20994 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20995 
      oprot.writeBool(self.isReminder)
20996 
      oprot.writeFieldEnd()
4303 rajveer 20997 
    oprot.writeFieldStop()
20998 
    oprot.writeStructEnd()
20999 
 
21000 
  def validate(self):
21001 
    return
21002 
 
21003 
 
21004 
  def __repr__(self):
21005 
    L = ['%s=%r' % (key, value)
21006 
      for key, value in self.__dict__.iteritems()]
21007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21008 
 
21009 
  def __eq__(self, other):
21010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21011 
 
21012 
  def __ne__(self, other):
21013 
    return not (self == other)
21014 
 
21015 
class markOrdersAsNotAvailabke_result:
21016 
  """
21017 
  Attributes:
21018 
   - ex
21019 
  """
21020 
 
21021 
  thrift_spec = (
21022 
    None, # 0
21023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21024 
  )
21025 
 
21026 
  def __init__(self, ex=None,):
21027 
    self.ex = ex
21028 
 
21029 
  def read(self, iprot):
21030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21032 
      return
21033 
    iprot.readStructBegin()
21034 
    while True:
21035 
      (fname, ftype, fid) = iprot.readFieldBegin()
21036 
      if ftype == TType.STOP:
21037 
        break
21038 
      if fid == 1:
21039 
        if ftype == TType.STRUCT:
21040 
          self.ex = TransactionServiceException()
21041 
          self.ex.read(iprot)
21042 
        else:
21043 
          iprot.skip(ftype)
21044 
      else:
21045 
        iprot.skip(ftype)
21046 
      iprot.readFieldEnd()
21047 
    iprot.readStructEnd()
21048 
 
21049 
  def write(self, oprot):
21050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21052 
      return
21053 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21054 
    if self.ex is not None:
21055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21056 
      self.ex.write(oprot)
21057 
      oprot.writeFieldEnd()
21058 
    oprot.writeFieldStop()
21059 
    oprot.writeStructEnd()
21060 
 
21061 
  def validate(self):
21062 
    return
21063 
 
21064 
 
21065 
  def __repr__(self):
21066 
    L = ['%s=%r' % (key, value)
21067 
      for key, value in self.__dict__.iteritems()]
21068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21069 
 
21070 
  def __eq__(self, other):
21071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21072 
 
21073 
  def __ne__(self, other):
21074 
    return not (self == other)
4369 rajveer 21075 
 
21076 
class markOrdersAsTimeout_args:
21077 
  """
21078 
  Attributes:
21079 
   - vendorId
21080 
  """
21081 
 
21082 
  thrift_spec = (
21083 
    None, # 0
21084 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21085 
  )
21086 
 
21087 
  def __init__(self, vendorId=None,):
21088 
    self.vendorId = vendorId
21089 
 
21090 
  def read(self, iprot):
21091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21093 
      return
21094 
    iprot.readStructBegin()
21095 
    while True:
21096 
      (fname, ftype, fid) = iprot.readFieldBegin()
21097 
      if ftype == TType.STOP:
21098 
        break
21099 
      if fid == 1:
21100 
        if ftype == TType.I64:
21101 
          self.vendorId = iprot.readI64();
21102 
        else:
21103 
          iprot.skip(ftype)
21104 
      else:
21105 
        iprot.skip(ftype)
21106 
      iprot.readFieldEnd()
21107 
    iprot.readStructEnd()
21108 
 
21109 
  def write(self, oprot):
21110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21112 
      return
21113 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21114 
    if self.vendorId is not None:
21115 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21116 
      oprot.writeI64(self.vendorId)
21117 
      oprot.writeFieldEnd()
21118 
    oprot.writeFieldStop()
21119 
    oprot.writeStructEnd()
21120 
 
21121 
  def validate(self):
21122 
    return
21123 
 
21124 
 
21125 
  def __repr__(self):
21126 
    L = ['%s=%r' % (key, value)
21127 
      for key, value in self.__dict__.iteritems()]
21128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21129 
 
21130 
  def __eq__(self, other):
21131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21132 
 
21133 
  def __ne__(self, other):
21134 
    return not (self == other)
21135 
 
21136 
class markOrdersAsTimeout_result:
21137 
  """
21138 
  Attributes:
21139 
   - success
21140 
   - ex
21141 
  """
21142 
 
21143 
  thrift_spec = (
21144 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21146 
  )
21147 
 
21148 
  def __init__(self, success=None, ex=None,):
21149 
    self.success = success
21150 
    self.ex = ex
21151 
 
21152 
  def read(self, iprot):
21153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21155 
      return
21156 
    iprot.readStructBegin()
21157 
    while True:
21158 
      (fname, ftype, fid) = iprot.readFieldBegin()
21159 
      if ftype == TType.STOP:
21160 
        break
21161 
      if fid == 0:
21162 
        if ftype == TType.MAP:
21163 
          self.success = {}
6031 rajveer 21164 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21165 
          for _i462 in xrange(_size458):
21166 
            _key463 = iprot.readI32();
21167 
            _val464 = TimeoutSummary()
21168 
            _val464.read(iprot)
21169 
            self.success[_key463] = _val464
4369 rajveer 21170 
          iprot.readMapEnd()
21171 
        else:
21172 
          iprot.skip(ftype)
21173 
      elif fid == 1:
21174 
        if ftype == TType.STRUCT:
21175 
          self.ex = TransactionServiceException()
21176 
          self.ex.read(iprot)
21177 
        else:
21178 
          iprot.skip(ftype)
21179 
      else:
21180 
        iprot.skip(ftype)
21181 
      iprot.readFieldEnd()
21182 
    iprot.readStructEnd()
21183 
 
21184 
  def write(self, oprot):
21185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21187 
      return
21188 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21189 
    if self.success is not None:
21190 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21191 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21192 
      for kiter465,viter466 in self.success.items():
21193 
        oprot.writeI32(kiter465)
21194 
        viter466.write(oprot)
4369 rajveer 21195 
      oprot.writeMapEnd()
21196 
      oprot.writeFieldEnd()
21197 
    if self.ex is not None:
21198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21199 
      self.ex.write(oprot)
21200 
      oprot.writeFieldEnd()
21201 
    oprot.writeFieldStop()
21202 
    oprot.writeStructEnd()
21203 
 
21204 
  def validate(self):
21205 
    return
21206 
 
21207 
 
21208 
  def __repr__(self):
21209 
    L = ['%s=%r' % (key, value)
21210 
      for key, value in self.__dict__.iteritems()]
21211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21212 
 
21213 
  def __eq__(self, other):
21214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21215 
 
21216 
  def __ne__(self, other):
21217 
    return not (self == other)
4386 anupam.sin 21218 
 
4662 rajveer 21219 
class markOrderAsLostInTransit_args:
21220 
  """
21221 
  Attributes:
21222 
   - orderId
21223 
  """
21224 
 
21225 
  thrift_spec = (
21226 
    None, # 0
21227 
    (1, TType.I64, 'orderId', None, None, ), # 1
21228 
  )
21229 
 
21230 
  def __init__(self, orderId=None,):
21231 
    self.orderId = orderId
21232 
 
21233 
  def read(self, iprot):
21234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21236 
      return
21237 
    iprot.readStructBegin()
21238 
    while True:
21239 
      (fname, ftype, fid) = iprot.readFieldBegin()
21240 
      if ftype == TType.STOP:
21241 
        break
21242 
      if fid == 1:
21243 
        if ftype == TType.I64:
21244 
          self.orderId = iprot.readI64();
21245 
        else:
21246 
          iprot.skip(ftype)
21247 
      else:
21248 
        iprot.skip(ftype)
21249 
      iprot.readFieldEnd()
21250 
    iprot.readStructEnd()
21251 
 
21252 
  def write(self, oprot):
21253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21255 
      return
21256 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21257 
    if self.orderId is not None:
21258 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21259 
      oprot.writeI64(self.orderId)
21260 
      oprot.writeFieldEnd()
21261 
    oprot.writeFieldStop()
21262 
    oprot.writeStructEnd()
21263 
 
21264 
  def validate(self):
21265 
    return
21266 
 
21267 
 
21268 
  def __repr__(self):
21269 
    L = ['%s=%r' % (key, value)
21270 
      for key, value in self.__dict__.iteritems()]
21271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21272 
 
21273 
  def __eq__(self, other):
21274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21275 
 
21276 
  def __ne__(self, other):
21277 
    return not (self == other)
21278 
 
21279 
class markOrderAsLostInTransit_result:
21280 
  """
21281 
  Attributes:
21282 
   - success
21283 
   - ex
21284 
  """
21285 
 
21286 
  thrift_spec = (
21287 
    (0, TType.BOOL, 'success', None, None, ), # 0
21288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21289 
  )
21290 
 
21291 
  def __init__(self, success=None, ex=None,):
21292 
    self.success = success
21293 
    self.ex = ex
21294 
 
21295 
  def read(self, iprot):
21296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21298 
      return
21299 
    iprot.readStructBegin()
21300 
    while True:
21301 
      (fname, ftype, fid) = iprot.readFieldBegin()
21302 
      if ftype == TType.STOP:
21303 
        break
21304 
      if fid == 0:
21305 
        if ftype == TType.BOOL:
21306 
          self.success = iprot.readBool();
21307 
        else:
21308 
          iprot.skip(ftype)
21309 
      elif fid == 1:
21310 
        if ftype == TType.STRUCT:
21311 
          self.ex = TransactionServiceException()
21312 
          self.ex.read(iprot)
21313 
        else:
21314 
          iprot.skip(ftype)
21315 
      else:
21316 
        iprot.skip(ftype)
21317 
      iprot.readFieldEnd()
21318 
    iprot.readStructEnd()
21319 
 
21320 
  def write(self, oprot):
21321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21323 
      return
21324 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21325 
    if self.success is not None:
21326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21327 
      oprot.writeBool(self.success)
21328 
      oprot.writeFieldEnd()
21329 
    if self.ex is not None:
21330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21331 
      self.ex.write(oprot)
21332 
      oprot.writeFieldEnd()
21333 
    oprot.writeFieldStop()
21334 
    oprot.writeStructEnd()
21335 
 
21336 
  def validate(self):
21337 
    return
21338 
 
21339 
 
21340 
  def __repr__(self):
21341 
    L = ['%s=%r' % (key, value)
21342 
      for key, value in self.__dict__.iteritems()]
21343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21344 
 
21345 
  def __eq__(self, other):
21346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21347 
 
21348 
  def __ne__(self, other):
21349 
    return not (self == other)
21350 
 
4386 anupam.sin 21351 
class getOrderForAwb_args:
21352 
  """
21353 
  Attributes:
21354 
   - awb
21355 
  """
21356 
 
21357 
  thrift_spec = (
21358 
    None, # 0
21359 
    (1, TType.STRING, 'awb', None, None, ), # 1
21360 
  )
21361 
 
21362 
  def __init__(self, awb=None,):
21363 
    self.awb = awb
21364 
 
21365 
  def read(self, iprot):
21366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21368 
      return
21369 
    iprot.readStructBegin()
21370 
    while True:
21371 
      (fname, ftype, fid) = iprot.readFieldBegin()
21372 
      if ftype == TType.STOP:
21373 
        break
21374 
      if fid == 1:
21375 
        if ftype == TType.STRING:
21376 
          self.awb = iprot.readString();
21377 
        else:
21378 
          iprot.skip(ftype)
21379 
      else:
21380 
        iprot.skip(ftype)
21381 
      iprot.readFieldEnd()
21382 
    iprot.readStructEnd()
21383 
 
21384 
  def write(self, oprot):
21385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21387 
      return
21388 
    oprot.writeStructBegin('getOrderForAwb_args')
21389 
    if self.awb is not None:
21390 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21391 
      oprot.writeString(self.awb)
21392 
      oprot.writeFieldEnd()
21393 
    oprot.writeFieldStop()
21394 
    oprot.writeStructEnd()
21395 
 
21396 
  def validate(self):
21397 
    return
21398 
 
21399 
 
21400 
  def __repr__(self):
21401 
    L = ['%s=%r' % (key, value)
21402 
      for key, value in self.__dict__.iteritems()]
21403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21404 
 
21405 
  def __eq__(self, other):
21406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21407 
 
21408 
  def __ne__(self, other):
21409 
    return not (self == other)
21410 
 
21411 
class getOrderForAwb_result:
21412 
  """
21413 
  Attributes:
21414 
   - success
21415 
   - ex
21416 
  """
21417 
 
21418 
  thrift_spec = (
21419 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21421 
  )
21422 
 
21423 
  def __init__(self, success=None, ex=None,):
21424 
    self.success = success
21425 
    self.ex = ex
21426 
 
21427 
  def read(self, iprot):
21428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21430 
      return
21431 
    iprot.readStructBegin()
21432 
    while True:
21433 
      (fname, ftype, fid) = iprot.readFieldBegin()
21434 
      if ftype == TType.STOP:
21435 
        break
21436 
      if fid == 0:
21437 
        if ftype == TType.STRUCT:
21438 
          self.success = Order()
21439 
          self.success.read(iprot)
21440 
        else:
21441 
          iprot.skip(ftype)
21442 
      elif fid == 1:
21443 
        if ftype == TType.STRUCT:
21444 
          self.ex = TransactionServiceException()
21445 
          self.ex.read(iprot)
21446 
        else:
21447 
          iprot.skip(ftype)
21448 
      else:
21449 
        iprot.skip(ftype)
21450 
      iprot.readFieldEnd()
21451 
    iprot.readStructEnd()
21452 
 
21453 
  def write(self, oprot):
21454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21456 
      return
21457 
    oprot.writeStructBegin('getOrderForAwb_result')
21458 
    if self.success is not None:
21459 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21460 
      self.success.write(oprot)
21461 
      oprot.writeFieldEnd()
21462 
    if self.ex is not None:
21463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21464 
      self.ex.write(oprot)
21465 
      oprot.writeFieldEnd()
21466 
    oprot.writeFieldStop()
21467 
    oprot.writeStructEnd()
21468 
 
21469 
  def validate(self):
21470 
    return
21471 
 
21472 
 
21473 
  def __repr__(self):
21474 
    L = ['%s=%r' % (key, value)
21475 
      for key, value in self.__dict__.iteritems()]
21476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21477 
 
21478 
  def __eq__(self, other):
21479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21480 
 
21481 
  def __ne__(self, other):
21482 
    return not (self == other)
4506 phani.kuma 21483 
 
21484 
class getOrdersForProviderForStatus_args:
21485 
  """
21486 
  Attributes:
21487 
   - logistics_provider_id
4910 phani.kuma 21488 
   - order_status_list
4506 phani.kuma 21489 
  """
21490 
 
21491 
  thrift_spec = (
21492 
    None, # 0
21493 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21494 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21495 
  )
21496 
 
4910 phani.kuma 21497 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21498 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21499 
    self.order_status_list = order_status_list
4506 phani.kuma 21500 
 
21501 
  def read(self, iprot):
21502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21504 
      return
21505 
    iprot.readStructBegin()
21506 
    while True:
21507 
      (fname, ftype, fid) = iprot.readFieldBegin()
21508 
      if ftype == TType.STOP:
21509 
        break
21510 
      if fid == 1:
21511 
        if ftype == TType.I64:
21512 
          self.logistics_provider_id = iprot.readI64();
21513 
        else:
21514 
          iprot.skip(ftype)
21515 
      elif fid == 2:
4910 phani.kuma 21516 
        if ftype == TType.LIST:
21517 
          self.order_status_list = []
6031 rajveer 21518 
          (_etype470, _size467) = iprot.readListBegin()
21519 
          for _i471 in xrange(_size467):
21520 
            _elem472 = iprot.readI32();
21521 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21522 
          iprot.readListEnd()
4506 phani.kuma 21523 
        else:
21524 
          iprot.skip(ftype)
21525 
      else:
21526 
        iprot.skip(ftype)
21527 
      iprot.readFieldEnd()
21528 
    iprot.readStructEnd()
21529 
 
21530 
  def write(self, oprot):
21531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21533 
      return
21534 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21535 
    if self.logistics_provider_id is not None:
21536 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21537 
      oprot.writeI64(self.logistics_provider_id)
21538 
      oprot.writeFieldEnd()
4910 phani.kuma 21539 
    if self.order_status_list is not None:
21540 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21541 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21542 
      for iter473 in self.order_status_list:
21543 
        oprot.writeI32(iter473)
4910 phani.kuma 21544 
      oprot.writeListEnd()
4506 phani.kuma 21545 
      oprot.writeFieldEnd()
21546 
    oprot.writeFieldStop()
21547 
    oprot.writeStructEnd()
21548 
 
21549 
  def validate(self):
21550 
    return
21551 
 
21552 
 
21553 
  def __repr__(self):
21554 
    L = ['%s=%r' % (key, value)
21555 
      for key, value in self.__dict__.iteritems()]
21556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21557 
 
21558 
  def __eq__(self, other):
21559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21560 
 
21561 
  def __ne__(self, other):
21562 
    return not (self == other)
21563 
 
21564 
class getOrdersForProviderForStatus_result:
21565 
  """
21566 
  Attributes:
21567 
   - success
21568 
   - ex
21569 
  """
21570 
 
21571 
  thrift_spec = (
21572 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21574 
  )
21575 
 
21576 
  def __init__(self, success=None, ex=None,):
21577 
    self.success = success
21578 
    self.ex = ex
21579 
 
21580 
  def read(self, iprot):
21581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21583 
      return
21584 
    iprot.readStructBegin()
21585 
    while True:
21586 
      (fname, ftype, fid) = iprot.readFieldBegin()
21587 
      if ftype == TType.STOP:
21588 
        break
21589 
      if fid == 0:
21590 
        if ftype == TType.LIST:
21591 
          self.success = []
6031 rajveer 21592 
          (_etype477, _size474) = iprot.readListBegin()
21593 
          for _i478 in xrange(_size474):
21594 
            _elem479 = Order()
21595 
            _elem479.read(iprot)
21596 
            self.success.append(_elem479)
4506 phani.kuma 21597 
          iprot.readListEnd()
21598 
        else:
21599 
          iprot.skip(ftype)
21600 
      elif fid == 1:
21601 
        if ftype == TType.STRUCT:
21602 
          self.ex = TransactionServiceException()
21603 
          self.ex.read(iprot)
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('getOrdersForProviderForStatus_result')
21616 
    if self.success is not None:
21617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21619 
      for iter480 in self.success:
21620 
        iter480.write(oprot)
4506 phani.kuma 21621 
      oprot.writeListEnd()
21622 
      oprot.writeFieldEnd()
21623 
    if self.ex is not None:
21624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21625 
      self.ex.write(oprot)
21626 
      oprot.writeFieldEnd()
21627 
    oprot.writeFieldStop()
21628 
    oprot.writeStructEnd()
21629 
 
21630 
  def validate(self):
21631 
    return
21632 
 
21633 
 
21634 
  def __repr__(self):
21635 
    L = ['%s=%r' % (key, value)
21636 
      for key, value in self.__dict__.iteritems()]
21637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21638 
 
21639 
  def __eq__(self, other):
21640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21641 
 
21642 
  def __ne__(self, other):
21643 
    return not (self == other)
4600 varun.gupt 21644 
 
21645 
class getBilledOrdersForVendor_args:
21646 
  """
21647 
  Attributes:
21648 
   - vendorId
21649 
   - billingDateFrom
21650 
   - billingDateTo
21651 
  """
21652 
 
21653 
  thrift_spec = (
21654 
    None, # 0
21655 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21656 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21657 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21658 
  )
21659 
 
21660 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21661 
    self.vendorId = vendorId
21662 
    self.billingDateFrom = billingDateFrom
21663 
    self.billingDateTo = billingDateTo
21664 
 
21665 
  def read(self, iprot):
21666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21668 
      return
21669 
    iprot.readStructBegin()
21670 
    while True:
21671 
      (fname, ftype, fid) = iprot.readFieldBegin()
21672 
      if ftype == TType.STOP:
21673 
        break
21674 
      if fid == 1:
21675 
        if ftype == TType.I64:
21676 
          self.vendorId = iprot.readI64();
21677 
        else:
21678 
          iprot.skip(ftype)
21679 
      elif fid == 2:
21680 
        if ftype == TType.I64:
21681 
          self.billingDateFrom = iprot.readI64();
21682 
        else:
21683 
          iprot.skip(ftype)
21684 
      elif fid == 3:
21685 
        if ftype == TType.I64:
21686 
          self.billingDateTo = iprot.readI64();
21687 
        else:
21688 
          iprot.skip(ftype)
21689 
      else:
21690 
        iprot.skip(ftype)
21691 
      iprot.readFieldEnd()
21692 
    iprot.readStructEnd()
21693 
 
21694 
  def write(self, oprot):
21695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21697 
      return
21698 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21699 
    if self.vendorId is not None:
21700 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21701 
      oprot.writeI64(self.vendorId)
21702 
      oprot.writeFieldEnd()
21703 
    if self.billingDateFrom is not None:
21704 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21705 
      oprot.writeI64(self.billingDateFrom)
21706 
      oprot.writeFieldEnd()
21707 
    if self.billingDateTo is not None:
21708 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21709 
      oprot.writeI64(self.billingDateTo)
21710 
      oprot.writeFieldEnd()
21711 
    oprot.writeFieldStop()
21712 
    oprot.writeStructEnd()
21713 
 
21714 
  def validate(self):
21715 
    return
21716 
 
21717 
 
21718 
  def __repr__(self):
21719 
    L = ['%s=%r' % (key, value)
21720 
      for key, value in self.__dict__.iteritems()]
21721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21722 
 
21723 
  def __eq__(self, other):
21724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21725 
 
21726 
  def __ne__(self, other):
21727 
    return not (self == other)
21728 
 
21729 
class getBilledOrdersForVendor_result:
21730 
  """
21731 
  Attributes:
21732 
   - success
21733 
   - ex
21734 
  """
21735 
 
21736 
  thrift_spec = (
21737 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21739 
  )
21740 
 
21741 
  def __init__(self, success=None, ex=None,):
21742 
    self.success = success
21743 
    self.ex = ex
21744 
 
21745 
  def read(self, iprot):
21746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21748 
      return
21749 
    iprot.readStructBegin()
21750 
    while True:
21751 
      (fname, ftype, fid) = iprot.readFieldBegin()
21752 
      if ftype == TType.STOP:
21753 
        break
21754 
      if fid == 0:
21755 
        if ftype == TType.LIST:
21756 
          self.success = []
6031 rajveer 21757 
          (_etype484, _size481) = iprot.readListBegin()
21758 
          for _i485 in xrange(_size481):
21759 
            _elem486 = Order()
21760 
            _elem486.read(iprot)
21761 
            self.success.append(_elem486)
4600 varun.gupt 21762 
          iprot.readListEnd()
21763 
        else:
21764 
          iprot.skip(ftype)
21765 
      elif fid == 1:
21766 
        if ftype == TType.STRUCT:
21767 
          self.ex = TransactionServiceException()
21768 
          self.ex.read(iprot)
21769 
        else:
21770 
          iprot.skip(ftype)
21771 
      else:
21772 
        iprot.skip(ftype)
21773 
      iprot.readFieldEnd()
21774 
    iprot.readStructEnd()
21775 
 
21776 
  def write(self, oprot):
21777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21779 
      return
21780 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21781 
    if self.success is not None:
21782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21784 
      for iter487 in self.success:
21785 
        iter487.write(oprot)
4600 varun.gupt 21786 
      oprot.writeListEnd()
21787 
      oprot.writeFieldEnd()
21788 
    if self.ex is not None:
21789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21790 
      self.ex.write(oprot)
21791 
      oprot.writeFieldEnd()
21792 
    oprot.writeFieldStop()
21793 
    oprot.writeStructEnd()
21794 
 
21795 
  def validate(self):
21796 
    return
21797 
 
21798 
 
21799 
  def __repr__(self):
21800 
    L = ['%s=%r' % (key, value)
21801 
      for key, value in self.__dict__.iteritems()]
21802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21803 
 
21804 
  def __eq__(self, other):
21805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21806 
 
21807 
  def __ne__(self, other):
21808 
    return not (self == other)
21809 
 
4607 rajveer 21810 
class getSlippedSippingDateOrders_args:
21811 
 
21812 
  thrift_spec = (
21813 
  )
21814 
 
21815 
  def read(self, iprot):
21816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21818 
      return
21819 
    iprot.readStructBegin()
21820 
    while True:
21821 
      (fname, ftype, fid) = iprot.readFieldBegin()
21822 
      if ftype == TType.STOP:
21823 
        break
21824 
      else:
21825 
        iprot.skip(ftype)
21826 
      iprot.readFieldEnd()
21827 
    iprot.readStructEnd()
21828 
 
21829 
  def write(self, oprot):
21830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21832 
      return
21833 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21834 
    oprot.writeFieldStop()
21835 
    oprot.writeStructEnd()
21836 
 
21837 
  def validate(self):
21838 
    return
21839 
 
21840 
 
21841 
  def __repr__(self):
21842 
    L = ['%s=%r' % (key, value)
21843 
      for key, value in self.__dict__.iteritems()]
21844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21845 
 
21846 
  def __eq__(self, other):
21847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21848 
 
21849 
  def __ne__(self, other):
21850 
    return not (self == other)
21851 
 
21852 
class getSlippedSippingDateOrders_result:
21853 
  """
21854 
  Attributes:
21855 
   - success
21856 
   - ex
21857 
  """
21858 
 
21859 
  thrift_spec = (
21860 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21862 
  )
21863 
 
21864 
  def __init__(self, success=None, ex=None,):
21865 
    self.success = success
21866 
    self.ex = ex
21867 
 
21868 
  def read(self, iprot):
21869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21871 
      return
21872 
    iprot.readStructBegin()
21873 
    while True:
21874 
      (fname, ftype, fid) = iprot.readFieldBegin()
21875 
      if ftype == TType.STOP:
21876 
        break
21877 
      if fid == 0:
21878 
        if ftype == TType.LIST:
21879 
          self.success = []
6031 rajveer 21880 
          (_etype491, _size488) = iprot.readListBegin()
21881 
          for _i492 in xrange(_size488):
21882 
            _elem493 = Order()
21883 
            _elem493.read(iprot)
21884 
            self.success.append(_elem493)
4607 rajveer 21885 
          iprot.readListEnd()
21886 
        else:
21887 
          iprot.skip(ftype)
21888 
      elif fid == 1:
21889 
        if ftype == TType.STRUCT:
21890 
          self.ex = TransactionServiceException()
21891 
          self.ex.read(iprot)
21892 
        else:
21893 
          iprot.skip(ftype)
21894 
      else:
21895 
        iprot.skip(ftype)
21896 
      iprot.readFieldEnd()
21897 
    iprot.readStructEnd()
21898 
 
21899 
  def write(self, oprot):
21900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21902 
      return
21903 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21904 
    if self.success is not None:
21905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21906 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21907 
      for iter494 in self.success:
21908 
        iter494.write(oprot)
4607 rajveer 21909 
      oprot.writeListEnd()
21910 
      oprot.writeFieldEnd()
21911 
    if self.ex is not None:
21912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21913 
      self.ex.write(oprot)
21914 
      oprot.writeFieldEnd()
21915 
    oprot.writeFieldStop()
21916 
    oprot.writeStructEnd()
21917 
 
21918 
  def validate(self):
21919 
    return
21920 
 
21921 
 
21922 
  def __repr__(self):
21923 
    L = ['%s=%r' % (key, value)
21924 
      for key, value in self.__dict__.iteritems()]
21925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21926 
 
21927 
  def __eq__(self, other):
21928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21929 
 
21930 
  def __ne__(self, other):
21931 
    return not (self == other)
21932 
 
4709 rajveer 21933 
class getCancelledOrders_args:
21934 
  """
21935 
  Attributes:
21936 
   - cancelDateFrom
21937 
   - cancelDateTo
21938 
  """
21939 
 
21940 
  thrift_spec = (
21941 
    None, # 0
21942 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21943 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21944 
  )
21945 
 
21946 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21947 
    self.cancelDateFrom = cancelDateFrom
21948 
    self.cancelDateTo = cancelDateTo
21949 
 
21950 
  def read(self, iprot):
21951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21953 
      return
21954 
    iprot.readStructBegin()
21955 
    while True:
21956 
      (fname, ftype, fid) = iprot.readFieldBegin()
21957 
      if ftype == TType.STOP:
21958 
        break
21959 
      if fid == 1:
21960 
        if ftype == TType.I64:
21961 
          self.cancelDateFrom = iprot.readI64();
21962 
        else:
21963 
          iprot.skip(ftype)
21964 
      elif fid == 2:
21965 
        if ftype == TType.I64:
21966 
          self.cancelDateTo = iprot.readI64();
21967 
        else:
21968 
          iprot.skip(ftype)
21969 
      else:
21970 
        iprot.skip(ftype)
21971 
      iprot.readFieldEnd()
21972 
    iprot.readStructEnd()
21973 
 
21974 
  def write(self, oprot):
21975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21977 
      return
21978 
    oprot.writeStructBegin('getCancelledOrders_args')
21979 
    if self.cancelDateFrom is not None:
21980 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21981 
      oprot.writeI64(self.cancelDateFrom)
21982 
      oprot.writeFieldEnd()
21983 
    if self.cancelDateTo is not None:
21984 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21985 
      oprot.writeI64(self.cancelDateTo)
21986 
      oprot.writeFieldEnd()
21987 
    oprot.writeFieldStop()
21988 
    oprot.writeStructEnd()
21989 
 
21990 
  def validate(self):
21991 
    return
21992 
 
21993 
 
21994 
  def __repr__(self):
21995 
    L = ['%s=%r' % (key, value)
21996 
      for key, value in self.__dict__.iteritems()]
21997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21998 
 
21999 
  def __eq__(self, other):
22000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22001 
 
22002 
  def __ne__(self, other):
22003 
    return not (self == other)
22004 
 
22005 
class getCancelledOrders_result:
22006 
  """
22007 
  Attributes:
22008 
   - success
22009 
   - ex
22010 
  """
22011 
 
22012 
  thrift_spec = (
22013 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22015 
  )
22016 
 
22017 
  def __init__(self, success=None, ex=None,):
22018 
    self.success = success
22019 
    self.ex = ex
22020 
 
22021 
  def read(self, iprot):
22022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22024 
      return
22025 
    iprot.readStructBegin()
22026 
    while True:
22027 
      (fname, ftype, fid) = iprot.readFieldBegin()
22028 
      if ftype == TType.STOP:
22029 
        break
22030 
      if fid == 0:
22031 
        if ftype == TType.LIST:
22032 
          self.success = []
6031 rajveer 22033 
          (_etype498, _size495) = iprot.readListBegin()
22034 
          for _i499 in xrange(_size495):
22035 
            _elem500 = Order()
22036 
            _elem500.read(iprot)
22037 
            self.success.append(_elem500)
4709 rajveer 22038 
          iprot.readListEnd()
22039 
        else:
22040 
          iprot.skip(ftype)
22041 
      elif fid == 1:
22042 
        if ftype == TType.STRUCT:
22043 
          self.ex = TransactionServiceException()
22044 
          self.ex.read(iprot)
22045 
        else:
22046 
          iprot.skip(ftype)
22047 
      else:
22048 
        iprot.skip(ftype)
22049 
      iprot.readFieldEnd()
22050 
    iprot.readStructEnd()
22051 
 
22052 
  def write(self, oprot):
22053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22055 
      return
22056 
    oprot.writeStructBegin('getCancelledOrders_result')
22057 
    if self.success is not None:
22058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22060 
      for iter501 in self.success:
22061 
        iter501.write(oprot)
4709 rajveer 22062 
      oprot.writeListEnd()
22063 
      oprot.writeFieldEnd()
22064 
    if self.ex is not None:
22065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22066 
      self.ex.write(oprot)
22067 
      oprot.writeFieldEnd()
22068 
    oprot.writeFieldStop()
22069 
    oprot.writeStructEnd()
22070 
 
22071 
  def validate(self):
22072 
    return
22073 
 
22074 
 
22075 
  def __repr__(self):
22076 
    L = ['%s=%r' % (key, value)
22077 
      for key, value in self.__dict__.iteritems()]
22078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22079 
 
22080 
  def __eq__(self, other):
22081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22082 
 
22083 
  def __ne__(self, other):
22084 
    return not (self == other)
22085 
 
4600 varun.gupt 22086 
class saveBluedartSettlements_args:
22087 
  """
22088 
  Attributes:
22089 
   - mapAWBAndAmount
22090 
  """
22091 
 
22092 
  thrift_spec = (
22093 
    None, # 0
22094 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22095 
  )
22096 
 
22097 
  def __init__(self, mapAWBAndAmount=None,):
22098 
    self.mapAWBAndAmount = mapAWBAndAmount
22099 
 
22100 
  def read(self, iprot):
22101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22103 
      return
22104 
    iprot.readStructBegin()
22105 
    while True:
22106 
      (fname, ftype, fid) = iprot.readFieldBegin()
22107 
      if ftype == TType.STOP:
22108 
        break
22109 
      if fid == 1:
22110 
        if ftype == TType.MAP:
22111 
          self.mapAWBAndAmount = {}
6031 rajveer 22112 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22113 
          for _i506 in xrange(_size502):
22114 
            _key507 = iprot.readI64();
22115 
            _val508 = iprot.readDouble();
22116 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22117 
          iprot.readMapEnd()
22118 
        else:
22119 
          iprot.skip(ftype)
22120 
      else:
22121 
        iprot.skip(ftype)
22122 
      iprot.readFieldEnd()
22123 
    iprot.readStructEnd()
22124 
 
22125 
  def write(self, oprot):
22126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22128 
      return
22129 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22130 
    if self.mapAWBAndAmount is not None:
22131 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22132 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22133 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22134 
        oprot.writeI64(kiter509)
22135 
        oprot.writeDouble(viter510)
4600 varun.gupt 22136 
      oprot.writeMapEnd()
22137 
      oprot.writeFieldEnd()
22138 
    oprot.writeFieldStop()
22139 
    oprot.writeStructEnd()
22140 
 
22141 
  def validate(self):
22142 
    return
22143 
 
22144 
 
22145 
  def __repr__(self):
22146 
    L = ['%s=%r' % (key, value)
22147 
      for key, value in self.__dict__.iteritems()]
22148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22149 
 
22150 
  def __eq__(self, other):
22151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22152 
 
22153 
  def __ne__(self, other):
22154 
    return not (self == other)
22155 
 
22156 
class saveBluedartSettlements_result:
22157 
  """
22158 
  Attributes:
22159 
   - ex
22160 
  """
22161 
 
22162 
  thrift_spec = (
22163 
    None, # 0
22164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22165 
  )
22166 
 
22167 
  def __init__(self, ex=None,):
22168 
    self.ex = ex
22169 
 
22170 
  def read(self, iprot):
22171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22173 
      return
22174 
    iprot.readStructBegin()
22175 
    while True:
22176 
      (fname, ftype, fid) = iprot.readFieldBegin()
22177 
      if ftype == TType.STOP:
22178 
        break
22179 
      if fid == 1:
22180 
        if ftype == TType.STRUCT:
22181 
          self.ex = TransactionServiceException()
22182 
          self.ex.read(iprot)
22183 
        else:
22184 
          iprot.skip(ftype)
22185 
      else:
22186 
        iprot.skip(ftype)
22187 
      iprot.readFieldEnd()
22188 
    iprot.readStructEnd()
22189 
 
22190 
  def write(self, oprot):
22191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22193 
      return
22194 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22195 
    if self.ex is not None:
22196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22197 
      self.ex.write(oprot)
22198 
      oprot.writeFieldEnd()
22199 
    oprot.writeFieldStop()
22200 
    oprot.writeStructEnd()
22201 
 
22202 
  def validate(self):
22203 
    return
22204 
 
22205 
 
22206 
  def __repr__(self):
22207 
    L = ['%s=%r' % (key, value)
22208 
      for key, value in self.__dict__.iteritems()]
22209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22210 
 
22211 
  def __eq__(self, other):
22212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22213 
 
22214 
  def __ne__(self, other):
22215 
    return not (self == other)
22216 
 
22217 
class savePaymentSettlements_args:
22218 
  """
22219 
  Attributes:
22220 
   - settlementDate
22221 
   - paymentGatewayId
4905 varun.gupt 22222 
   - referenceId
4600 varun.gupt 22223 
   - serviceTax
22224 
   - otherCharges
22225 
   - netCollection
22226 
  """
22227 
 
22228 
  thrift_spec = (
22229 
    None, # 0
22230 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22231 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22232 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22233 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22234 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22235 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22236 
  )
22237 
 
4905 varun.gupt 22238 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22239 
    self.settlementDate = settlementDate
22240 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22241 
    self.referenceId = referenceId
4600 varun.gupt 22242 
    self.serviceTax = serviceTax
22243 
    self.otherCharges = otherCharges
22244 
    self.netCollection = netCollection
22245 
 
22246 
  def read(self, iprot):
22247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22249 
      return
22250 
    iprot.readStructBegin()
22251 
    while True:
22252 
      (fname, ftype, fid) = iprot.readFieldBegin()
22253 
      if ftype == TType.STOP:
22254 
        break
22255 
      if fid == 1:
22256 
        if ftype == TType.I64:
22257 
          self.settlementDate = iprot.readI64();
22258 
        else:
22259 
          iprot.skip(ftype)
22260 
      elif fid == 2:
22261 
        if ftype == TType.I64:
22262 
          self.paymentGatewayId = iprot.readI64();
22263 
        else:
22264 
          iprot.skip(ftype)
22265 
      elif fid == 3:
22266 
        if ftype == TType.I64:
4905 varun.gupt 22267 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22268 
        else:
22269 
          iprot.skip(ftype)
22270 
      elif fid == 4:
22271 
        if ftype == TType.DOUBLE:
22272 
          self.serviceTax = iprot.readDouble();
22273 
        else:
22274 
          iprot.skip(ftype)
22275 
      elif fid == 5:
22276 
        if ftype == TType.DOUBLE:
22277 
          self.otherCharges = iprot.readDouble();
22278 
        else:
22279 
          iprot.skip(ftype)
22280 
      elif fid == 6:
22281 
        if ftype == TType.DOUBLE:
22282 
          self.netCollection = iprot.readDouble();
22283 
        else:
22284 
          iprot.skip(ftype)
22285 
      else:
22286 
        iprot.skip(ftype)
22287 
      iprot.readFieldEnd()
22288 
    iprot.readStructEnd()
22289 
 
22290 
  def write(self, oprot):
22291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22293 
      return
22294 
    oprot.writeStructBegin('savePaymentSettlements_args')
22295 
    if self.settlementDate is not None:
22296 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22297 
      oprot.writeI64(self.settlementDate)
22298 
      oprot.writeFieldEnd()
22299 
    if self.paymentGatewayId is not None:
22300 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22301 
      oprot.writeI64(self.paymentGatewayId)
22302 
      oprot.writeFieldEnd()
4905 varun.gupt 22303 
    if self.referenceId is not None:
22304 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22305 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22306 
      oprot.writeFieldEnd()
22307 
    if self.serviceTax is not None:
22308 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22309 
      oprot.writeDouble(self.serviceTax)
22310 
      oprot.writeFieldEnd()
22311 
    if self.otherCharges is not None:
22312 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22313 
      oprot.writeDouble(self.otherCharges)
22314 
      oprot.writeFieldEnd()
22315 
    if self.netCollection is not None:
22316 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22317 
      oprot.writeDouble(self.netCollection)
22318 
      oprot.writeFieldEnd()
22319 
    oprot.writeFieldStop()
22320 
    oprot.writeStructEnd()
22321 
 
22322 
  def validate(self):
22323 
    return
22324 
 
22325 
 
22326 
  def __repr__(self):
22327 
    L = ['%s=%r' % (key, value)
22328 
      for key, value in self.__dict__.iteritems()]
22329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22330 
 
22331 
  def __eq__(self, other):
22332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22333 
 
22334 
  def __ne__(self, other):
22335 
    return not (self == other)
22336 
 
22337 
class savePaymentSettlements_result:
22338 
  """
22339 
  Attributes:
22340 
   - ex
22341 
  """
22342 
 
22343 
  thrift_spec = (
22344 
    None, # 0
22345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22346 
  )
22347 
 
22348 
  def __init__(self, ex=None,):
22349 
    self.ex = ex
22350 
 
22351 
  def read(self, iprot):
22352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22354 
      return
22355 
    iprot.readStructBegin()
22356 
    while True:
22357 
      (fname, ftype, fid) = iprot.readFieldBegin()
22358 
      if ftype == TType.STOP:
22359 
        break
22360 
      if fid == 1:
22361 
        if ftype == TType.STRUCT:
22362 
          self.ex = TransactionServiceException()
22363 
          self.ex.read(iprot)
22364 
        else:
22365 
          iprot.skip(ftype)
22366 
      else:
22367 
        iprot.skip(ftype)
22368 
      iprot.readFieldEnd()
22369 
    iprot.readStructEnd()
22370 
 
22371 
  def write(self, oprot):
22372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22374 
      return
22375 
    oprot.writeStructBegin('savePaymentSettlements_result')
22376 
    if self.ex is not None:
22377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22378 
      self.ex.write(oprot)
22379 
      oprot.writeFieldEnd()
22380 
    oprot.writeFieldStop()
22381 
    oprot.writeStructEnd()
22382 
 
22383 
  def validate(self):
22384 
    return
22385 
 
22386 
 
22387 
  def __repr__(self):
22388 
    L = ['%s=%r' % (key, value)
22389 
      for key, value in self.__dict__.iteritems()]
22390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22391 
 
22392 
  def __eq__(self, other):
22393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22394 
 
22395 
  def __ne__(self, other):
22396 
    return not (self == other)
22397 
 
22398 
class saveEBSSettlementSummary_args:
22399 
  """
22400 
  Attributes:
22401 
   - settlementId
22402 
   - settlementDate
22403 
   - transactionDateFrom
22404 
   - transactionDateTo
22405 
   - amount
22406 
  """
22407 
 
22408 
  thrift_spec = (
22409 
    None, # 0
22410 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22411 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22412 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22413 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22414 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22415 
  )
22416 
 
22417 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22418 
    self.settlementId = settlementId
22419 
    self.settlementDate = settlementDate
22420 
    self.transactionDateFrom = transactionDateFrom
22421 
    self.transactionDateTo = transactionDateTo
22422 
    self.amount = amount
22423 
 
22424 
  def read(self, iprot):
22425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22427 
      return
22428 
    iprot.readStructBegin()
22429 
    while True:
22430 
      (fname, ftype, fid) = iprot.readFieldBegin()
22431 
      if ftype == TType.STOP:
22432 
        break
22433 
      if fid == 1:
22434 
        if ftype == TType.I64:
22435 
          self.settlementId = iprot.readI64();
22436 
        else:
22437 
          iprot.skip(ftype)
22438 
      elif fid == 2:
22439 
        if ftype == TType.I64:
22440 
          self.settlementDate = iprot.readI64();
22441 
        else:
22442 
          iprot.skip(ftype)
22443 
      elif fid == 3:
22444 
        if ftype == TType.I64:
22445 
          self.transactionDateFrom = iprot.readI64();
22446 
        else:
22447 
          iprot.skip(ftype)
22448 
      elif fid == 4:
22449 
        if ftype == TType.I64:
22450 
          self.transactionDateTo = iprot.readI64();
22451 
        else:
22452 
          iprot.skip(ftype)
22453 
      elif fid == 5:
22454 
        if ftype == TType.DOUBLE:
22455 
          self.amount = iprot.readDouble();
22456 
        else:
22457 
          iprot.skip(ftype)
22458 
      else:
22459 
        iprot.skip(ftype)
22460 
      iprot.readFieldEnd()
22461 
    iprot.readStructEnd()
22462 
 
22463 
  def write(self, oprot):
22464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22466 
      return
22467 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22468 
    if self.settlementId is not None:
22469 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22470 
      oprot.writeI64(self.settlementId)
22471 
      oprot.writeFieldEnd()
22472 
    if self.settlementDate is not None:
22473 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22474 
      oprot.writeI64(self.settlementDate)
22475 
      oprot.writeFieldEnd()
22476 
    if self.transactionDateFrom is not None:
22477 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22478 
      oprot.writeI64(self.transactionDateFrom)
22479 
      oprot.writeFieldEnd()
22480 
    if self.transactionDateTo is not None:
22481 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22482 
      oprot.writeI64(self.transactionDateTo)
22483 
      oprot.writeFieldEnd()
22484 
    if self.amount is not None:
22485 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22486 
      oprot.writeDouble(self.amount)
22487 
      oprot.writeFieldEnd()
22488 
    oprot.writeFieldStop()
22489 
    oprot.writeStructEnd()
22490 
 
22491 
  def validate(self):
22492 
    return
22493 
 
22494 
 
22495 
  def __repr__(self):
22496 
    L = ['%s=%r' % (key, value)
22497 
      for key, value in self.__dict__.iteritems()]
22498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22499 
 
22500 
  def __eq__(self, other):
22501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22502 
 
22503 
  def __ne__(self, other):
22504 
    return not (self == other)
22505 
 
22506 
class saveEBSSettlementSummary_result:
22507 
  """
22508 
  Attributes:
22509 
   - ex
22510 
  """
22511 
 
22512 
  thrift_spec = (
22513 
    None, # 0
22514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22515 
  )
22516 
 
22517 
  def __init__(self, ex=None,):
22518 
    self.ex = ex
22519 
 
22520 
  def read(self, iprot):
22521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22523 
      return
22524 
    iprot.readStructBegin()
22525 
    while True:
22526 
      (fname, ftype, fid) = iprot.readFieldBegin()
22527 
      if ftype == TType.STOP:
22528 
        break
22529 
      if fid == 1:
22530 
        if ftype == TType.STRUCT:
22531 
          self.ex = TransactionServiceException()
22532 
          self.ex.read(iprot)
22533 
        else:
22534 
          iprot.skip(ftype)
22535 
      else:
22536 
        iprot.skip(ftype)
22537 
      iprot.readFieldEnd()
22538 
    iprot.readStructEnd()
22539 
 
22540 
  def write(self, oprot):
22541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22543 
      return
22544 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22545 
    if self.ex is not None:
22546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22547 
      self.ex.write(oprot)
22548 
      oprot.writeFieldEnd()
22549 
    oprot.writeFieldStop()
22550 
    oprot.writeStructEnd()
22551 
 
22552 
  def validate(self):
22553 
    return
22554 
 
22555 
 
22556 
  def __repr__(self):
22557 
    L = ['%s=%r' % (key, value)
22558 
      for key, value in self.__dict__.iteritems()]
22559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22560 
 
22561 
  def __eq__(self, other):
22562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22563 
 
22564 
  def __ne__(self, other):
22565 
    return not (self == other)
22566 
 
5386 phani.kuma 22567 
class getSettlementForPrepaid_args:
4600 varun.gupt 22568 
  """
22569 
  Attributes:
5189 varun.gupt 22570 
   - referenceId
22571 
   - isRefund
4600 varun.gupt 22572 
  """
22573 
 
22574 
  thrift_spec = (
22575 
    None, # 0
5189 varun.gupt 22576 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22577 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22578 
  )
22579 
 
5386 phani.kuma 22580 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22581 
    self.referenceId = referenceId
22582 
    self.isRefund = isRefund
4600 varun.gupt 22583 
 
22584 
  def read(self, iprot):
22585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22587 
      return
22588 
    iprot.readStructBegin()
22589 
    while True:
22590 
      (fname, ftype, fid) = iprot.readFieldBegin()
22591 
      if ftype == TType.STOP:
22592 
        break
22593 
      if fid == 1:
22594 
        if ftype == TType.I64:
5189 varun.gupt 22595 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22596 
        else:
22597 
          iprot.skip(ftype)
5189 varun.gupt 22598 
      elif fid == 2:
22599 
        if ftype == TType.BOOL:
22600 
          self.isRefund = iprot.readBool();
22601 
        else:
22602 
          iprot.skip(ftype)
4600 varun.gupt 22603 
      else:
22604 
        iprot.skip(ftype)
22605 
      iprot.readFieldEnd()
22606 
    iprot.readStructEnd()
22607 
 
22608 
  def write(self, oprot):
22609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22611 
      return
5386 phani.kuma 22612 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22613 
    if self.referenceId is not None:
22614 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22615 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22616 
      oprot.writeFieldEnd()
5386 phani.kuma 22617 
    if self.isRefund is not None:
22618 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22619 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22620 
      oprot.writeFieldEnd()
5386 phani.kuma 22621 
    oprot.writeFieldStop()
22622 
    oprot.writeStructEnd()
22623 
 
22624 
  def validate(self):
22625 
    return
22626 
 
22627 
 
22628 
  def __repr__(self):
22629 
    L = ['%s=%r' % (key, value)
22630 
      for key, value in self.__dict__.iteritems()]
22631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22632 
 
22633 
  def __eq__(self, other):
22634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22635 
 
22636 
  def __ne__(self, other):
22637 
    return not (self == other)
22638 
 
22639 
class getSettlementForPrepaid_result:
22640 
  """
22641 
  Attributes:
22642 
   - success
22643 
   - ex
22644 
  """
22645 
 
22646 
  thrift_spec = (
22647 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22648 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22649 
  )
22650 
 
22651 
  def __init__(self, success=None, ex=None,):
22652 
    self.success = success
22653 
    self.ex = ex
22654 
 
22655 
  def read(self, iprot):
22656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22658 
      return
22659 
    iprot.readStructBegin()
22660 
    while True:
22661 
      (fname, ftype, fid) = iprot.readFieldBegin()
22662 
      if ftype == TType.STOP:
22663 
        break
22664 
      if fid == 0:
22665 
        if ftype == TType.STRUCT:
22666 
          self.success = PaymentSettlement()
22667 
          self.success.read(iprot)
22668 
        else:
22669 
          iprot.skip(ftype)
22670 
      elif fid == 1:
22671 
        if ftype == TType.STRUCT:
22672 
          self.ex = TransactionServiceException()
22673 
          self.ex.read(iprot)
22674 
        else:
22675 
          iprot.skip(ftype)
22676 
      else:
22677 
        iprot.skip(ftype)
22678 
      iprot.readFieldEnd()
22679 
    iprot.readStructEnd()
22680 
 
22681 
  def write(self, oprot):
22682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22684 
      return
22685 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22686 
    if self.success is not None:
22687 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22688 
      self.success.write(oprot)
22689 
      oprot.writeFieldEnd()
22690 
    if self.ex is not None:
22691 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22692 
      self.ex.write(oprot)
22693 
      oprot.writeFieldEnd()
22694 
    oprot.writeFieldStop()
22695 
    oprot.writeStructEnd()
22696 
 
22697 
  def validate(self):
22698 
    return
22699 
 
22700 
 
22701 
  def __repr__(self):
22702 
    L = ['%s=%r' % (key, value)
22703 
      for key, value in self.__dict__.iteritems()]
22704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22705 
 
22706 
  def __eq__(self, other):
22707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22708 
 
22709 
  def __ne__(self, other):
22710 
    return not (self == other)
22711 
 
22712 
class getSettlementForCod_args:
22713 
  """
22714 
  Attributes:
22715 
   - orderId
22716 
   - isRefund
22717 
  """
22718 
 
22719 
  thrift_spec = (
22720 
    None, # 0
22721 
    (1, TType.I64, 'orderId', None, None, ), # 1
22722 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22723 
  )
22724 
 
22725 
  def __init__(self, orderId=None, isRefund=None,):
22726 
    self.orderId = orderId
22727 
    self.isRefund = isRefund
22728 
 
22729 
  def read(self, iprot):
22730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22732 
      return
22733 
    iprot.readStructBegin()
22734 
    while True:
22735 
      (fname, ftype, fid) = iprot.readFieldBegin()
22736 
      if ftype == TType.STOP:
22737 
        break
22738 
      if fid == 1:
22739 
        if ftype == TType.I64:
22740 
          self.orderId = iprot.readI64();
22741 
        else:
22742 
          iprot.skip(ftype)
22743 
      elif fid == 2:
22744 
        if ftype == TType.BOOL:
22745 
          self.isRefund = iprot.readBool();
22746 
        else:
22747 
          iprot.skip(ftype)
22748 
      else:
22749 
        iprot.skip(ftype)
22750 
      iprot.readFieldEnd()
22751 
    iprot.readStructEnd()
22752 
 
22753 
  def write(self, oprot):
22754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22756 
      return
22757 
    oprot.writeStructBegin('getSettlementForCod_args')
22758 
    if self.orderId is not None:
22759 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22760 
      oprot.writeI64(self.orderId)
22761 
      oprot.writeFieldEnd()
5189 varun.gupt 22762 
    if self.isRefund is not None:
5386 phani.kuma 22763 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22764 
      oprot.writeBool(self.isRefund)
22765 
      oprot.writeFieldEnd()
4600 varun.gupt 22766 
    oprot.writeFieldStop()
22767 
    oprot.writeStructEnd()
22768 
 
22769 
  def validate(self):
22770 
    return
22771 
 
22772 
 
22773 
  def __repr__(self):
22774 
    L = ['%s=%r' % (key, value)
22775 
      for key, value in self.__dict__.iteritems()]
22776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22777 
 
22778 
  def __eq__(self, other):
22779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22780 
 
22781 
  def __ne__(self, other):
22782 
    return not (self == other)
22783 
 
5386 phani.kuma 22784 
class getSettlementForCod_result:
4600 varun.gupt 22785 
  """
22786 
  Attributes:
22787 
   - success
22788 
   - ex
22789 
  """
22790 
 
22791 
  thrift_spec = (
22792 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22794 
  )
22795 
 
22796 
  def __init__(self, success=None, ex=None,):
22797 
    self.success = success
22798 
    self.ex = ex
22799 
 
22800 
  def read(self, iprot):
22801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22803 
      return
22804 
    iprot.readStructBegin()
22805 
    while True:
22806 
      (fname, ftype, fid) = iprot.readFieldBegin()
22807 
      if ftype == TType.STOP:
22808 
        break
22809 
      if fid == 0:
22810 
        if ftype == TType.STRUCT:
22811 
          self.success = PaymentSettlement()
22812 
          self.success.read(iprot)
22813 
        else:
22814 
          iprot.skip(ftype)
22815 
      elif fid == 1:
22816 
        if ftype == TType.STRUCT:
22817 
          self.ex = TransactionServiceException()
22818 
          self.ex.read(iprot)
22819 
        else:
22820 
          iprot.skip(ftype)
22821 
      else:
22822 
        iprot.skip(ftype)
22823 
      iprot.readFieldEnd()
22824 
    iprot.readStructEnd()
22825 
 
22826 
  def write(self, oprot):
22827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22829 
      return
5386 phani.kuma 22830 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22831 
    if self.success is not None:
22832 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22833 
      self.success.write(oprot)
22834 
      oprot.writeFieldEnd()
22835 
    if self.ex is not None:
22836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22837 
      self.ex.write(oprot)
22838 
      oprot.writeFieldEnd()
22839 
    oprot.writeFieldStop()
22840 
    oprot.writeStructEnd()
22841 
 
22842 
  def validate(self):
22843 
    return
22844 
 
22845 
 
22846 
  def __repr__(self):
22847 
    L = ['%s=%r' % (key, value)
22848 
      for key, value in self.__dict__.iteritems()]
22849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22850 
 
22851 
  def __eq__(self, other):
22852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22853 
 
22854 
  def __ne__(self, other):
22855 
    return not (self == other)
22856 
 
22857 
class getEBSSettlementSummaries_args:
22858 
 
22859 
  thrift_spec = (
22860 
  )
22861 
 
22862 
  def read(self, iprot):
22863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22865 
      return
22866 
    iprot.readStructBegin()
22867 
    while True:
22868 
      (fname, ftype, fid) = iprot.readFieldBegin()
22869 
      if ftype == TType.STOP:
22870 
        break
22871 
      else:
22872 
        iprot.skip(ftype)
22873 
      iprot.readFieldEnd()
22874 
    iprot.readStructEnd()
22875 
 
22876 
  def write(self, oprot):
22877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22879 
      return
22880 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22881 
    oprot.writeFieldStop()
22882 
    oprot.writeStructEnd()
22883 
 
22884 
  def validate(self):
22885 
    return
22886 
 
22887 
 
22888 
  def __repr__(self):
22889 
    L = ['%s=%r' % (key, value)
22890 
      for key, value in self.__dict__.iteritems()]
22891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22892 
 
22893 
  def __eq__(self, other):
22894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22895 
 
22896 
  def __ne__(self, other):
22897 
    return not (self == other)
22898 
 
22899 
class getEBSSettlementSummaries_result:
22900 
  """
22901 
  Attributes:
22902 
   - success
22903 
   - ex
22904 
  """
22905 
 
22906 
  thrift_spec = (
22907 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22909 
  )
22910 
 
22911 
  def __init__(self, success=None, ex=None,):
22912 
    self.success = success
22913 
    self.ex = ex
22914 
 
22915 
  def read(self, iprot):
22916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22918 
      return
22919 
    iprot.readStructBegin()
22920 
    while True:
22921 
      (fname, ftype, fid) = iprot.readFieldBegin()
22922 
      if ftype == TType.STOP:
22923 
        break
22924 
      if fid == 0:
22925 
        if ftype == TType.MAP:
22926 
          self.success = {}
6031 rajveer 22927 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
22928 
          for _i515 in xrange(_size511):
22929 
            _key516 = iprot.readI64();
22930 
            _val517 = iprot.readString();
22931 
            self.success[_key516] = _val517
4600 varun.gupt 22932 
          iprot.readMapEnd()
22933 
        else:
22934 
          iprot.skip(ftype)
22935 
      elif fid == 1:
22936 
        if ftype == TType.STRUCT:
22937 
          self.ex = TransactionServiceException()
22938 
          self.ex.read(iprot)
22939 
        else:
22940 
          iprot.skip(ftype)
22941 
      else:
22942 
        iprot.skip(ftype)
22943 
      iprot.readFieldEnd()
22944 
    iprot.readStructEnd()
22945 
 
22946 
  def write(self, oprot):
22947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22949 
      return
22950 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22951 
    if self.success is not None:
22952 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22953 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 22954 
      for kiter518,viter519 in self.success.items():
22955 
        oprot.writeI64(kiter518)
22956 
        oprot.writeString(viter519)
4600 varun.gupt 22957 
      oprot.writeMapEnd()
22958 
      oprot.writeFieldEnd()
22959 
    if self.ex is not None:
22960 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22961 
      self.ex.write(oprot)
22962 
      oprot.writeFieldEnd()
22963 
    oprot.writeFieldStop()
22964 
    oprot.writeStructEnd()
22965 
 
22966 
  def validate(self):
22967 
    return
22968 
 
22969 
 
22970 
  def __repr__(self):
22971 
    L = ['%s=%r' % (key, value)
22972 
      for key, value in self.__dict__.iteritems()]
22973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22974 
 
22975 
  def __eq__(self, other):
22976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22977 
 
22978 
  def __ne__(self, other):
22979 
    return not (self == other)
22980 
 
22981 
class markEBSSettlementUploaded_args:
22982 
  """
22983 
  Attributes:
22984 
   - settlementId
22985 
  """
22986 
 
22987 
  thrift_spec = (
22988 
    None, # 0
22989 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22990 
  )
22991 
 
22992 
  def __init__(self, settlementId=None,):
22993 
    self.settlementId = settlementId
22994 
 
22995 
  def read(self, iprot):
22996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22998 
      return
22999 
    iprot.readStructBegin()
23000 
    while True:
23001 
      (fname, ftype, fid) = iprot.readFieldBegin()
23002 
      if ftype == TType.STOP:
23003 
        break
23004 
      if fid == 1:
23005 
        if ftype == TType.I64:
23006 
          self.settlementId = iprot.readI64();
23007 
        else:
23008 
          iprot.skip(ftype)
23009 
      else:
23010 
        iprot.skip(ftype)
23011 
      iprot.readFieldEnd()
23012 
    iprot.readStructEnd()
23013 
 
23014 
  def write(self, oprot):
23015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23017 
      return
23018 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23019 
    if self.settlementId is not None:
23020 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23021 
      oprot.writeI64(self.settlementId)
23022 
      oprot.writeFieldEnd()
23023 
    oprot.writeFieldStop()
23024 
    oprot.writeStructEnd()
23025 
 
23026 
  def validate(self):
23027 
    return
23028 
 
23029 
 
23030 
  def __repr__(self):
23031 
    L = ['%s=%r' % (key, value)
23032 
      for key, value in self.__dict__.iteritems()]
23033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23034 
 
23035 
  def __eq__(self, other):
23036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23037 
 
23038 
  def __ne__(self, other):
23039 
    return not (self == other)
23040 
 
23041 
class markEBSSettlementUploaded_result:
23042 
  """
23043 
  Attributes:
23044 
   - ex
23045 
  """
23046 
 
23047 
  thrift_spec = (
23048 
    None, # 0
23049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23050 
  )
23051 
 
23052 
  def __init__(self, ex=None,):
23053 
    self.ex = ex
23054 
 
23055 
  def read(self, iprot):
23056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23058 
      return
23059 
    iprot.readStructBegin()
23060 
    while True:
23061 
      (fname, ftype, fid) = iprot.readFieldBegin()
23062 
      if ftype == TType.STOP:
23063 
        break
23064 
      if fid == 1:
23065 
        if ftype == TType.STRUCT:
23066 
          self.ex = TransactionServiceException()
23067 
          self.ex.read(iprot)
23068 
        else:
23069 
          iprot.skip(ftype)
23070 
      else:
23071 
        iprot.skip(ftype)
23072 
      iprot.readFieldEnd()
23073 
    iprot.readStructEnd()
23074 
 
23075 
  def write(self, oprot):
23076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23078 
      return
23079 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23080 
    if self.ex is not None:
23081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23082 
      self.ex.write(oprot)
23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
23101 
 
23102 
class getEBSSettlementDate_args:
23103 
  """
23104 
  Attributes:
23105 
   - settlementId
23106 
  """
23107 
 
23108 
  thrift_spec = (
23109 
    None, # 0
23110 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23111 
  )
23112 
 
23113 
  def __init__(self, settlementId=None,):
23114 
    self.settlementId = settlementId
23115 
 
23116 
  def read(self, iprot):
23117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23119 
      return
23120 
    iprot.readStructBegin()
23121 
    while True:
23122 
      (fname, ftype, fid) = iprot.readFieldBegin()
23123 
      if ftype == TType.STOP:
23124 
        break
23125 
      if fid == 1:
23126 
        if ftype == TType.I64:
23127 
          self.settlementId = iprot.readI64();
23128 
        else:
23129 
          iprot.skip(ftype)
23130 
      else:
23131 
        iprot.skip(ftype)
23132 
      iprot.readFieldEnd()
23133 
    iprot.readStructEnd()
23134 
 
23135 
  def write(self, oprot):
23136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23138 
      return
23139 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23140 
    if self.settlementId is not None:
23141 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23142 
      oprot.writeI64(self.settlementId)
23143 
      oprot.writeFieldEnd()
23144 
    oprot.writeFieldStop()
23145 
    oprot.writeStructEnd()
23146 
 
23147 
  def validate(self):
23148 
    return
23149 
 
23150 
 
23151 
  def __repr__(self):
23152 
    L = ['%s=%r' % (key, value)
23153 
      for key, value in self.__dict__.iteritems()]
23154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23155 
 
23156 
  def __eq__(self, other):
23157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23158 
 
23159 
  def __ne__(self, other):
23160 
    return not (self == other)
23161 
 
23162 
class getEBSSettlementDate_result:
23163 
  """
23164 
  Attributes:
23165 
   - success
23166 
   - ex
23167 
  """
23168 
 
23169 
  thrift_spec = (
23170 
    (0, TType.I64, 'success', None, None, ), # 0
23171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23172 
  )
23173 
 
23174 
  def __init__(self, success=None, ex=None,):
23175 
    self.success = success
23176 
    self.ex = ex
23177 
 
23178 
  def read(self, iprot):
23179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23181 
      return
23182 
    iprot.readStructBegin()
23183 
    while True:
23184 
      (fname, ftype, fid) = iprot.readFieldBegin()
23185 
      if ftype == TType.STOP:
23186 
        break
23187 
      if fid == 0:
23188 
        if ftype == TType.I64:
23189 
          self.success = iprot.readI64();
23190 
        else:
23191 
          iprot.skip(ftype)
23192 
      elif fid == 1:
23193 
        if ftype == TType.STRUCT:
23194 
          self.ex = TransactionServiceException()
23195 
          self.ex.read(iprot)
23196 
        else:
23197 
          iprot.skip(ftype)
23198 
      else:
23199 
        iprot.skip(ftype)
23200 
      iprot.readFieldEnd()
23201 
    iprot.readStructEnd()
23202 
 
23203 
  def write(self, oprot):
23204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23206 
      return
23207 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23208 
    if self.success is not None:
23209 
      oprot.writeFieldBegin('success', TType.I64, 0)
23210 
      oprot.writeI64(self.success)
23211 
      oprot.writeFieldEnd()
23212 
    if self.ex is not None:
23213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23214 
      self.ex.write(oprot)
23215 
      oprot.writeFieldEnd()
23216 
    oprot.writeFieldStop()
23217 
    oprot.writeStructEnd()
23218 
 
23219 
  def validate(self):
23220 
    return
23221 
 
23222 
 
23223 
  def __repr__(self):
23224 
    L = ['%s=%r' % (key, value)
23225 
      for key, value in self.__dict__.iteritems()]
23226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23227 
 
23228 
  def __eq__(self, other):
23229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23230 
 
23231 
  def __ne__(self, other):
23232 
    return not (self == other)
4715 varun.gupt 23233 
 
23234 
class getSettlementsByDate_args:
23235 
  """
23236 
  Attributes:
23237 
   - settlementDateFrom
23238 
   - settlementDateTo
23239 
   - isRefund
23240 
  """
23241 
 
23242 
  thrift_spec = (
23243 
    None, # 0
23244 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23245 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23246 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23247 
  )
23248 
 
23249 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23250 
    self.settlementDateFrom = settlementDateFrom
23251 
    self.settlementDateTo = settlementDateTo
23252 
    self.isRefund = isRefund
23253 
 
23254 
  def read(self, iprot):
23255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23257 
      return
23258 
    iprot.readStructBegin()
23259 
    while True:
23260 
      (fname, ftype, fid) = iprot.readFieldBegin()
23261 
      if ftype == TType.STOP:
23262 
        break
23263 
      if fid == 1:
23264 
        if ftype == TType.I64:
23265 
          self.settlementDateFrom = iprot.readI64();
23266 
        else:
23267 
          iprot.skip(ftype)
23268 
      elif fid == 2:
23269 
        if ftype == TType.I64:
23270 
          self.settlementDateTo = iprot.readI64();
23271 
        else:
23272 
          iprot.skip(ftype)
23273 
      elif fid == 3:
23274 
        if ftype == TType.BOOL:
23275 
          self.isRefund = iprot.readBool();
23276 
        else:
23277 
          iprot.skip(ftype)
23278 
      else:
23279 
        iprot.skip(ftype)
23280 
      iprot.readFieldEnd()
23281 
    iprot.readStructEnd()
23282 
 
23283 
  def write(self, oprot):
23284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23286 
      return
23287 
    oprot.writeStructBegin('getSettlementsByDate_args')
23288 
    if self.settlementDateFrom is not None:
23289 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23290 
      oprot.writeI64(self.settlementDateFrom)
23291 
      oprot.writeFieldEnd()
23292 
    if self.settlementDateTo is not None:
23293 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23294 
      oprot.writeI64(self.settlementDateTo)
23295 
      oprot.writeFieldEnd()
23296 
    if self.isRefund is not None:
23297 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23298 
      oprot.writeBool(self.isRefund)
23299 
      oprot.writeFieldEnd()
23300 
    oprot.writeFieldStop()
23301 
    oprot.writeStructEnd()
23302 
 
23303 
  def validate(self):
23304 
    return
23305 
 
23306 
 
23307 
  def __repr__(self):
23308 
    L = ['%s=%r' % (key, value)
23309 
      for key, value in self.__dict__.iteritems()]
23310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23311 
 
23312 
  def __eq__(self, other):
23313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23314 
 
23315 
  def __ne__(self, other):
23316 
    return not (self == other)
23317 
 
23318 
class getSettlementsByDate_result:
23319 
  """
23320 
  Attributes:
23321 
   - success
23322 
   - ex
23323 
  """
23324 
 
23325 
  thrift_spec = (
23326 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23328 
  )
23329 
 
23330 
  def __init__(self, success=None, ex=None,):
23331 
    self.success = success
23332 
    self.ex = ex
23333 
 
23334 
  def read(self, iprot):
23335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23337 
      return
23338 
    iprot.readStructBegin()
23339 
    while True:
23340 
      (fname, ftype, fid) = iprot.readFieldBegin()
23341 
      if ftype == TType.STOP:
23342 
        break
23343 
      if fid == 0:
23344 
        if ftype == TType.LIST:
23345 
          self.success = []
6031 rajveer 23346 
          (_etype523, _size520) = iprot.readListBegin()
23347 
          for _i524 in xrange(_size520):
23348 
            _elem525 = PaymentSettlement()
23349 
            _elem525.read(iprot)
23350 
            self.success.append(_elem525)
4715 varun.gupt 23351 
          iprot.readListEnd()
23352 
        else:
23353 
          iprot.skip(ftype)
23354 
      elif fid == 1:
23355 
        if ftype == TType.STRUCT:
23356 
          self.ex = TransactionServiceException()
23357 
          self.ex.read(iprot)
23358 
        else:
23359 
          iprot.skip(ftype)
23360 
      else:
23361 
        iprot.skip(ftype)
23362 
      iprot.readFieldEnd()
23363 
    iprot.readStructEnd()
23364 
 
23365 
  def write(self, oprot):
23366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23368 
      return
23369 
    oprot.writeStructBegin('getSettlementsByDate_result')
23370 
    if self.success is not None:
23371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23373 
      for iter526 in self.success:
23374 
        iter526.write(oprot)
4715 varun.gupt 23375 
      oprot.writeListEnd()
23376 
      oprot.writeFieldEnd()
23377 
    if self.ex is not None:
23378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23379 
      self.ex.write(oprot)
23380 
      oprot.writeFieldEnd()
23381 
    oprot.writeFieldStop()
23382 
    oprot.writeStructEnd()
23383 
 
23384 
  def validate(self):
23385 
    return
23386 
 
23387 
 
23388 
  def __repr__(self):
23389 
    L = ['%s=%r' % (key, value)
23390 
      for key, value in self.__dict__.iteritems()]
23391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23392 
 
23393 
  def __eq__(self, other):
23394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23395 
 
23396 
  def __ne__(self, other):
23397 
    return not (self == other)
23398 
 
23399 
class getReshippedOrderIds_args:
23400 
  """
23401 
  Attributes:
23402 
   - orderIds
23403 
  """
23404 
 
23405 
  thrift_spec = (
23406 
    None, # 0
23407 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23408 
  )
23409 
 
23410 
  def __init__(self, orderIds=None,):
23411 
    self.orderIds = orderIds
23412 
 
23413 
  def read(self, iprot):
23414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23416 
      return
23417 
    iprot.readStructBegin()
23418 
    while True:
23419 
      (fname, ftype, fid) = iprot.readFieldBegin()
23420 
      if ftype == TType.STOP:
23421 
        break
23422 
      if fid == 1:
23423 
        if ftype == TType.LIST:
23424 
          self.orderIds = []
6031 rajveer 23425 
          (_etype530, _size527) = iprot.readListBegin()
23426 
          for _i531 in xrange(_size527):
23427 
            _elem532 = iprot.readI64();
23428 
            self.orderIds.append(_elem532)
4715 varun.gupt 23429 
          iprot.readListEnd()
23430 
        else:
23431 
          iprot.skip(ftype)
23432 
      else:
23433 
        iprot.skip(ftype)
23434 
      iprot.readFieldEnd()
23435 
    iprot.readStructEnd()
23436 
 
23437 
  def write(self, oprot):
23438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23440 
      return
23441 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23442 
    if self.orderIds is not None:
23443 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23444 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23445 
      for iter533 in self.orderIds:
23446 
        oprot.writeI64(iter533)
4715 varun.gupt 23447 
      oprot.writeListEnd()
23448 
      oprot.writeFieldEnd()
23449 
    oprot.writeFieldStop()
23450 
    oprot.writeStructEnd()
23451 
 
23452 
  def validate(self):
23453 
    return
23454 
 
23455 
 
23456 
  def __repr__(self):
23457 
    L = ['%s=%r' % (key, value)
23458 
      for key, value in self.__dict__.iteritems()]
23459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23460 
 
23461 
  def __eq__(self, other):
23462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23463 
 
23464 
  def __ne__(self, other):
23465 
    return not (self == other)
23466 
 
23467 
class getReshippedOrderIds_result:
23468 
  """
23469 
  Attributes:
23470 
   - success
23471 
   - ex
23472 
  """
23473 
 
23474 
  thrift_spec = (
23475 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23477 
  )
23478 
 
23479 
  def __init__(self, success=None, ex=None,):
23480 
    self.success = success
23481 
    self.ex = ex
23482 
 
23483 
  def read(self, iprot):
23484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23486 
      return
23487 
    iprot.readStructBegin()
23488 
    while True:
23489 
      (fname, ftype, fid) = iprot.readFieldBegin()
23490 
      if ftype == TType.STOP:
23491 
        break
23492 
      if fid == 0:
23493 
        if ftype == TType.LIST:
23494 
          self.success = []
6031 rajveer 23495 
          (_etype537, _size534) = iprot.readListBegin()
23496 
          for _i538 in xrange(_size534):
23497 
            _elem539 = iprot.readI64();
23498 
            self.success.append(_elem539)
4715 varun.gupt 23499 
          iprot.readListEnd()
23500 
        else:
23501 
          iprot.skip(ftype)
23502 
      elif fid == 1:
23503 
        if ftype == TType.STRUCT:
23504 
          self.ex = TransactionServiceException()
23505 
          self.ex.read(iprot)
23506 
        else:
23507 
          iprot.skip(ftype)
23508 
      else:
23509 
        iprot.skip(ftype)
23510 
      iprot.readFieldEnd()
23511 
    iprot.readStructEnd()
23512 
 
23513 
  def write(self, oprot):
23514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23516 
      return
23517 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23518 
    if self.success is not None:
23519 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23520 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23521 
      for iter540 in self.success:
23522 
        oprot.writeI64(iter540)
4715 varun.gupt 23523 
      oprot.writeListEnd()
23524 
      oprot.writeFieldEnd()
23525 
    if self.ex is not None:
23526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23527 
      self.ex.write(oprot)
23528 
      oprot.writeFieldEnd()
23529 
    oprot.writeFieldStop()
23530 
    oprot.writeStructEnd()
23531 
 
23532 
  def validate(self):
23533 
    return
23534 
 
23535 
 
23536 
  def __repr__(self):
23537 
    L = ['%s=%r' % (key, value)
23538 
      for key, value in self.__dict__.iteritems()]
23539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23540 
 
23541 
  def __eq__(self, other):
23542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23543 
 
23544 
  def __ne__(self, other):
23545 
    return not (self == other)
4757 mandeep.dh 23546 
 
5481 phani.kuma 23547 
class getBilledOrders_args:
4875 varun.gupt 23548 
  """
23549 
  Attributes:
23550 
   - vendorId
5481 phani.kuma 23551 
   - onlyVendorNotPaid
23552 
   - billingDateFrom
23553 
   - billingDateTo
4875 varun.gupt 23554 
  """
23555 
 
23556 
  thrift_spec = (
23557 
    None, # 0
23558 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23559 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23560 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23561 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23562 
  )
23563 
 
5481 phani.kuma 23564 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23565 
    self.vendorId = vendorId
5481 phani.kuma 23566 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23567 
    self.billingDateFrom = billingDateFrom
23568 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23569 
 
23570 
  def read(self, iprot):
23571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23573 
      return
23574 
    iprot.readStructBegin()
23575 
    while True:
23576 
      (fname, ftype, fid) = iprot.readFieldBegin()
23577 
      if ftype == TType.STOP:
23578 
        break
23579 
      if fid == 1:
23580 
        if ftype == TType.I64:
23581 
          self.vendorId = iprot.readI64();
23582 
        else:
23583 
          iprot.skip(ftype)
5481 phani.kuma 23584 
      elif fid == 2:
23585 
        if ftype == TType.BOOL:
23586 
          self.onlyVendorNotPaid = iprot.readBool();
23587 
        else:
23588 
          iprot.skip(ftype)
23589 
      elif fid == 3:
23590 
        if ftype == TType.I64:
23591 
          self.billingDateFrom = iprot.readI64();
23592 
        else:
23593 
          iprot.skip(ftype)
23594 
      elif fid == 4:
23595 
        if ftype == TType.I64:
23596 
          self.billingDateTo = iprot.readI64();
23597 
        else:
23598 
          iprot.skip(ftype)
4875 varun.gupt 23599 
      else:
23600 
        iprot.skip(ftype)
23601 
      iprot.readFieldEnd()
23602 
    iprot.readStructEnd()
23603 
 
23604 
  def write(self, oprot):
23605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23607 
      return
5481 phani.kuma 23608 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23609 
    if self.vendorId is not None:
23610 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23611 
      oprot.writeI64(self.vendorId)
23612 
      oprot.writeFieldEnd()
5481 phani.kuma 23613 
    if self.onlyVendorNotPaid is not None:
23614 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23615 
      oprot.writeBool(self.onlyVendorNotPaid)
23616 
      oprot.writeFieldEnd()
23617 
    if self.billingDateFrom is not None:
23618 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23619 
      oprot.writeI64(self.billingDateFrom)
23620 
      oprot.writeFieldEnd()
23621 
    if self.billingDateTo is not None:
23622 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23623 
      oprot.writeI64(self.billingDateTo)
23624 
      oprot.writeFieldEnd()
4875 varun.gupt 23625 
    oprot.writeFieldStop()
23626 
    oprot.writeStructEnd()
23627 
 
23628 
  def validate(self):
23629 
    return
23630 
 
23631 
 
23632 
  def __repr__(self):
23633 
    L = ['%s=%r' % (key, value)
23634 
      for key, value in self.__dict__.iteritems()]
23635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23636 
 
23637 
  def __eq__(self, other):
23638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23639 
 
23640 
  def __ne__(self, other):
23641 
    return not (self == other)
23642 
 
5481 phani.kuma 23643 
class getBilledOrders_result:
4875 varun.gupt 23644 
  """
23645 
  Attributes:
23646 
   - success
23647 
   - ex
23648 
  """
23649 
 
23650 
  thrift_spec = (
23651 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23653 
  )
23654 
 
23655 
  def __init__(self, success=None, ex=None,):
23656 
    self.success = success
23657 
    self.ex = ex
23658 
 
23659 
  def read(self, iprot):
23660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23662 
      return
23663 
    iprot.readStructBegin()
23664 
    while True:
23665 
      (fname, ftype, fid) = iprot.readFieldBegin()
23666 
      if ftype == TType.STOP:
23667 
        break
23668 
      if fid == 0:
23669 
        if ftype == TType.LIST:
23670 
          self.success = []
6031 rajveer 23671 
          (_etype544, _size541) = iprot.readListBegin()
23672 
          for _i545 in xrange(_size541):
23673 
            _elem546 = Order()
23674 
            _elem546.read(iprot)
23675 
            self.success.append(_elem546)
4875 varun.gupt 23676 
          iprot.readListEnd()
23677 
        else:
23678 
          iprot.skip(ftype)
23679 
      elif fid == 1:
23680 
        if ftype == TType.STRUCT:
23681 
          self.ex = TransactionServiceException()
23682 
          self.ex.read(iprot)
23683 
        else:
23684 
          iprot.skip(ftype)
23685 
      else:
23686 
        iprot.skip(ftype)
23687 
      iprot.readFieldEnd()
23688 
    iprot.readStructEnd()
23689 
 
23690 
  def write(self, oprot):
23691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23693 
      return
5481 phani.kuma 23694 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23695 
    if self.success is not None:
23696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23698 
      for iter547 in self.success:
23699 
        iter547.write(oprot)
4875 varun.gupt 23700 
      oprot.writeListEnd()
23701 
      oprot.writeFieldEnd()
23702 
    if self.ex is not None:
23703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23704 
      self.ex.write(oprot)
23705 
      oprot.writeFieldEnd()
23706 
    oprot.writeFieldStop()
23707 
    oprot.writeStructEnd()
23708 
 
23709 
  def validate(self):
23710 
    return
23711 
 
23712 
 
23713 
  def __repr__(self):
23714 
    L = ['%s=%r' % (key, value)
23715 
      for key, value in self.__dict__.iteritems()]
23716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23717 
 
23718 
  def __eq__(self, other):
23719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23720 
 
23721 
  def __ne__(self, other):
23722 
    return not (self == other)
5031 varun.gupt 23723 
 
23724 
class getStatusDistributionOfOrders_args:
23725 
  """
23726 
  Attributes:
23727 
   - startDate
23728 
   - endDate
23729 
  """
23730 
 
23731 
  thrift_spec = (
23732 
    None, # 0
23733 
    (1, TType.I64, 'startDate', None, None, ), # 1
23734 
    (2, TType.I64, 'endDate', None, None, ), # 2
23735 
  )
23736 
 
23737 
  def __init__(self, startDate=None, endDate=None,):
23738 
    self.startDate = startDate
23739 
    self.endDate = endDate
23740 
 
23741 
  def read(self, iprot):
23742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23744 
      return
23745 
    iprot.readStructBegin()
23746 
    while True:
23747 
      (fname, ftype, fid) = iprot.readFieldBegin()
23748 
      if ftype == TType.STOP:
23749 
        break
23750 
      if fid == 1:
23751 
        if ftype == TType.I64:
23752 
          self.startDate = iprot.readI64();
23753 
        else:
23754 
          iprot.skip(ftype)
23755 
      elif fid == 2:
23756 
        if ftype == TType.I64:
23757 
          self.endDate = iprot.readI64();
23758 
        else:
23759 
          iprot.skip(ftype)
23760 
      else:
23761 
        iprot.skip(ftype)
23762 
      iprot.readFieldEnd()
23763 
    iprot.readStructEnd()
23764 
 
23765 
  def write(self, oprot):
23766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23768 
      return
23769 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23770 
    if self.startDate is not None:
23771 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23772 
      oprot.writeI64(self.startDate)
23773 
      oprot.writeFieldEnd()
23774 
    if self.endDate is not None:
23775 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23776 
      oprot.writeI64(self.endDate)
23777 
      oprot.writeFieldEnd()
23778 
    oprot.writeFieldStop()
23779 
    oprot.writeStructEnd()
23780 
 
23781 
  def validate(self):
23782 
    return
23783 
 
23784 
 
23785 
  def __repr__(self):
23786 
    L = ['%s=%r' % (key, value)
23787 
      for key, value in self.__dict__.iteritems()]
23788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23789 
 
23790 
  def __eq__(self, other):
23791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23792 
 
23793 
  def __ne__(self, other):
23794 
    return not (self == other)
23795 
 
23796 
class getStatusDistributionOfOrders_result:
23797 
  """
23798 
  Attributes:
23799 
   - success
23800 
   - ex
23801 
  """
23802 
 
23803 
  thrift_spec = (
23804 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23806 
  )
23807 
 
23808 
  def __init__(self, success=None, ex=None,):
23809 
    self.success = success
23810 
    self.ex = ex
23811 
 
23812 
  def read(self, iprot):
23813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23815 
      return
23816 
    iprot.readStructBegin()
23817 
    while True:
23818 
      (fname, ftype, fid) = iprot.readFieldBegin()
23819 
      if ftype == TType.STOP:
23820 
        break
23821 
      if fid == 0:
23822 
        if ftype == TType.MAP:
23823 
          self.success = {}
6031 rajveer 23824 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23825 
          for _i552 in xrange(_size548):
23826 
            _key553 = iprot.readI64();
23827 
            _val554 = iprot.readI64();
23828 
            self.success[_key553] = _val554
5031 varun.gupt 23829 
          iprot.readMapEnd()
23830 
        else:
23831 
          iprot.skip(ftype)
23832 
      elif fid == 1:
23833 
        if ftype == TType.STRUCT:
23834 
          self.ex = TransactionServiceException()
23835 
          self.ex.read(iprot)
23836 
        else:
23837 
          iprot.skip(ftype)
23838 
      else:
23839 
        iprot.skip(ftype)
23840 
      iprot.readFieldEnd()
23841 
    iprot.readStructEnd()
23842 
 
23843 
  def write(self, oprot):
23844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23846 
      return
23847 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23848 
    if self.success is not None:
23849 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23850 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 23851 
      for kiter555,viter556 in self.success.items():
23852 
        oprot.writeI64(kiter555)
23853 
        oprot.writeI64(viter556)
5031 varun.gupt 23854 
      oprot.writeMapEnd()
23855 
      oprot.writeFieldEnd()
23856 
    if self.ex is not None:
23857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23858 
      self.ex.write(oprot)
23859 
      oprot.writeFieldEnd()
23860 
    oprot.writeFieldStop()
23861 
    oprot.writeStructEnd()
23862 
 
23863 
  def validate(self):
23864 
    return
23865 
 
23866 
 
23867 
  def __repr__(self):
23868 
    L = ['%s=%r' % (key, value)
23869 
      for key, value in self.__dict__.iteritems()]
23870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23871 
 
23872 
  def __eq__(self, other):
23873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23874 
 
23875 
  def __ne__(self, other):
23876 
    return not (self == other)
5067 varun.gupt 23877 
 
23878 
class getOrderIdsForStatus_args:
23879 
  """
23880 
  Attributes:
23881 
   - status
23882 
   - startDatetime
23883 
   - endDatetime
23884 
  """
23885 
 
23886 
  thrift_spec = (
23887 
    None, # 0
23888 
    (1, TType.I64, 'status', None, None, ), # 1
23889 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23890 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23891 
  )
23892 
 
23893 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23894 
    self.status = status
23895 
    self.startDatetime = startDatetime
23896 
    self.endDatetime = endDatetime
23897 
 
23898 
  def read(self, iprot):
23899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23901 
      return
23902 
    iprot.readStructBegin()
23903 
    while True:
23904 
      (fname, ftype, fid) = iprot.readFieldBegin()
23905 
      if ftype == TType.STOP:
23906 
        break
23907 
      if fid == 1:
23908 
        if ftype == TType.I64:
23909 
          self.status = iprot.readI64();
23910 
        else:
23911 
          iprot.skip(ftype)
23912 
      elif fid == 2:
23913 
        if ftype == TType.I64:
23914 
          self.startDatetime = iprot.readI64();
23915 
        else:
23916 
          iprot.skip(ftype)
23917 
      elif fid == 3:
23918 
        if ftype == TType.I64:
23919 
          self.endDatetime = iprot.readI64();
23920 
        else:
23921 
          iprot.skip(ftype)
23922 
      else:
23923 
        iprot.skip(ftype)
23924 
      iprot.readFieldEnd()
23925 
    iprot.readStructEnd()
23926 
 
23927 
  def write(self, oprot):
23928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23930 
      return
23931 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23932 
    if self.status is not None:
23933 
      oprot.writeFieldBegin('status', TType.I64, 1)
23934 
      oprot.writeI64(self.status)
23935 
      oprot.writeFieldEnd()
23936 
    if self.startDatetime is not None:
23937 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23938 
      oprot.writeI64(self.startDatetime)
23939 
      oprot.writeFieldEnd()
23940 
    if self.endDatetime is not None:
23941 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23942 
      oprot.writeI64(self.endDatetime)
23943 
      oprot.writeFieldEnd()
23944 
    oprot.writeFieldStop()
23945 
    oprot.writeStructEnd()
23946 
 
23947 
  def validate(self):
23948 
    return
23949 
 
23950 
 
23951 
  def __repr__(self):
23952 
    L = ['%s=%r' % (key, value)
23953 
      for key, value in self.__dict__.iteritems()]
23954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23955 
 
23956 
  def __eq__(self, other):
23957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23958 
 
23959 
  def __ne__(self, other):
23960 
    return not (self == other)
23961 
 
23962 
class getOrderIdsForStatus_result:
23963 
  """
23964 
  Attributes:
23965 
   - success
23966 
   - ex
23967 
  """
23968 
 
23969 
  thrift_spec = (
23970 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23971 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23972 
  )
23973 
 
23974 
  def __init__(self, success=None, ex=None,):
23975 
    self.success = success
23976 
    self.ex = ex
23977 
 
23978 
  def read(self, iprot):
23979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23981 
      return
23982 
    iprot.readStructBegin()
23983 
    while True:
23984 
      (fname, ftype, fid) = iprot.readFieldBegin()
23985 
      if ftype == TType.STOP:
23986 
        break
23987 
      if fid == 0:
23988 
        if ftype == TType.LIST:
23989 
          self.success = []
6031 rajveer 23990 
          (_etype560, _size557) = iprot.readListBegin()
23991 
          for _i561 in xrange(_size557):
23992 
            _elem562 = iprot.readI64();
23993 
            self.success.append(_elem562)
5067 varun.gupt 23994 
          iprot.readListEnd()
23995 
        else:
23996 
          iprot.skip(ftype)
23997 
      elif fid == 1:
23998 
        if ftype == TType.STRUCT:
23999 
          self.ex = TransactionServiceException()
24000 
          self.ex.read(iprot)
24001 
        else:
24002 
          iprot.skip(ftype)
24003 
      else:
24004 
        iprot.skip(ftype)
24005 
      iprot.readFieldEnd()
24006 
    iprot.readStructEnd()
24007 
 
24008 
  def write(self, oprot):
24009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24011 
      return
24012 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24013 
    if self.success is not None:
24014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24015 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24016 
      for iter563 in self.success:
24017 
        oprot.writeI64(iter563)
5067 varun.gupt 24018 
      oprot.writeListEnd()
24019 
      oprot.writeFieldEnd()
24020 
    if self.ex is not None:
24021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24022 
      self.ex.write(oprot)
24023 
      oprot.writeFieldEnd()
24024 
    oprot.writeFieldStop()
24025 
    oprot.writeStructEnd()
24026 
 
24027 
  def validate(self):
24028 
    return
24029 
 
24030 
 
24031 
  def __repr__(self):
24032 
    L = ['%s=%r' % (key, value)
24033 
      for key, value in self.__dict__.iteritems()]
24034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24035 
 
24036 
  def __eq__(self, other):
24037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24038 
 
24039 
  def __ne__(self, other):
24040 
    return not (self == other)
5099 varun.gupt 24041 
 
5348 anupam.sin 24042 
class updateCODAgent_args:
24043 
  """
24044 
  Attributes:
24045 
   - agent
24046 
   - orderId
24047 
  """
24048 
 
24049 
  thrift_spec = (
24050 
    None, # 0
24051 
    (1, TType.STRING, 'agent', None, None, ), # 1
24052 
    (2, TType.I64, 'orderId', None, None, ), # 2
24053 
  )
24054 
 
24055 
  def __init__(self, agent=None, orderId=None,):
24056 
    self.agent = agent
24057 
    self.orderId = orderId
24058 
 
24059 
  def read(self, iprot):
24060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24062 
      return
24063 
    iprot.readStructBegin()
24064 
    while True:
24065 
      (fname, ftype, fid) = iprot.readFieldBegin()
24066 
      if ftype == TType.STOP:
24067 
        break
24068 
      if fid == 1:
24069 
        if ftype == TType.STRING:
24070 
          self.agent = iprot.readString();
24071 
        else:
24072 
          iprot.skip(ftype)
24073 
      elif fid == 2:
24074 
        if ftype == TType.I64:
24075 
          self.orderId = iprot.readI64();
24076 
        else:
24077 
          iprot.skip(ftype)
24078 
      else:
24079 
        iprot.skip(ftype)
24080 
      iprot.readFieldEnd()
24081 
    iprot.readStructEnd()
24082 
 
24083 
  def write(self, oprot):
24084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24086 
      return
24087 
    oprot.writeStructBegin('updateCODAgent_args')
24088 
    if self.agent is not None:
24089 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24090 
      oprot.writeString(self.agent)
24091 
      oprot.writeFieldEnd()
24092 
    if self.orderId is not None:
24093 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24094 
      oprot.writeI64(self.orderId)
24095 
      oprot.writeFieldEnd()
24096 
    oprot.writeFieldStop()
24097 
    oprot.writeStructEnd()
24098 
 
24099 
  def validate(self):
24100 
    return
24101 
 
24102 
 
24103 
  def __repr__(self):
24104 
    L = ['%s=%r' % (key, value)
24105 
      for key, value in self.__dict__.iteritems()]
24106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24107 
 
24108 
  def __eq__(self, other):
24109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24110 
 
24111 
  def __ne__(self, other):
24112 
    return not (self == other)
24113 
 
24114 
class updateCODAgent_result:
24115 
  """
24116 
  Attributes:
24117 
   - ex
24118 
  """
24119 
 
24120 
  thrift_spec = (
24121 
    None, # 0
24122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24123 
  )
24124 
 
24125 
  def __init__(self, ex=None,):
24126 
    self.ex = ex
24127 
 
24128 
  def read(self, iprot):
24129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24131 
      return
24132 
    iprot.readStructBegin()
24133 
    while True:
24134 
      (fname, ftype, fid) = iprot.readFieldBegin()
24135 
      if ftype == TType.STOP:
24136 
        break
24137 
      if fid == 1:
24138 
        if ftype == TType.STRUCT:
24139 
          self.ex = TransactionServiceException()
24140 
          self.ex.read(iprot)
24141 
        else:
24142 
          iprot.skip(ftype)
24143 
      else:
24144 
        iprot.skip(ftype)
24145 
      iprot.readFieldEnd()
24146 
    iprot.readStructEnd()
24147 
 
24148 
  def write(self, oprot):
24149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24151 
      return
24152 
    oprot.writeStructBegin('updateCODAgent_result')
24153 
    if self.ex is not None:
24154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24155 
      self.ex.write(oprot)
24156 
      oprot.writeFieldEnd()
24157 
    oprot.writeFieldStop()
24158 
    oprot.writeStructEnd()
24159 
 
24160 
  def validate(self):
24161 
    return
24162 
 
24163 
 
24164 
  def __repr__(self):
24165 
    L = ['%s=%r' % (key, value)
24166 
      for key, value in self.__dict__.iteritems()]
24167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24168 
 
24169 
  def __eq__(self, other):
24170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24171 
 
24172 
  def __ne__(self, other):
24173 
    return not (self == other)
24174 
 
5099 varun.gupt 24175 
class updateOrderAsPaidToVendor_args:
24176 
  """
24177 
  Attributes:
24178 
   - orderId
24179 
  """
24180 
 
24181 
  thrift_spec = (
24182 
    None, # 0
24183 
    (1, TType.I64, 'orderId', None, None, ), # 1
24184 
  )
24185 
 
24186 
  def __init__(self, orderId=None,):
24187 
    self.orderId = orderId
24188 
 
24189 
  def read(self, iprot):
24190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24192 
      return
24193 
    iprot.readStructBegin()
24194 
    while True:
24195 
      (fname, ftype, fid) = iprot.readFieldBegin()
24196 
      if ftype == TType.STOP:
24197 
        break
24198 
      if fid == 1:
24199 
        if ftype == TType.I64:
24200 
          self.orderId = iprot.readI64();
24201 
        else:
24202 
          iprot.skip(ftype)
24203 
      else:
24204 
        iprot.skip(ftype)
24205 
      iprot.readFieldEnd()
24206 
    iprot.readStructEnd()
24207 
 
24208 
  def write(self, oprot):
24209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24211 
      return
24212 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24213 
    if self.orderId is not None:
24214 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24215 
      oprot.writeI64(self.orderId)
24216 
      oprot.writeFieldEnd()
24217 
    oprot.writeFieldStop()
24218 
    oprot.writeStructEnd()
24219 
 
24220 
  def validate(self):
24221 
    return
24222 
 
24223 
 
24224 
  def __repr__(self):
24225 
    L = ['%s=%r' % (key, value)
24226 
      for key, value in self.__dict__.iteritems()]
24227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24228 
 
24229 
  def __eq__(self, other):
24230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24231 
 
24232 
  def __ne__(self, other):
24233 
    return not (self == other)
24234 
 
24235 
class updateOrderAsPaidToVendor_result:
24236 
  """
24237 
  Attributes:
24238 
   - ex
24239 
  """
24240 
 
24241 
  thrift_spec = (
24242 
    None, # 0
24243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24244 
  )
24245 
 
24246 
  def __init__(self, ex=None,):
24247 
    self.ex = ex
24248 
 
24249 
  def read(self, iprot):
24250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24252 
      return
24253 
    iprot.readStructBegin()
24254 
    while True:
24255 
      (fname, ftype, fid) = iprot.readFieldBegin()
24256 
      if ftype == TType.STOP:
24257 
        break
24258 
      if fid == 1:
24259 
        if ftype == TType.STRUCT:
24260 
          self.ex = TransactionServiceException()
24261 
          self.ex.read(iprot)
24262 
        else:
24263 
          iprot.skip(ftype)
24264 
      else:
24265 
        iprot.skip(ftype)
24266 
      iprot.readFieldEnd()
24267 
    iprot.readStructEnd()
24268 
 
24269 
  def write(self, oprot):
24270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24272 
      return
24273 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24274 
    if self.ex is not None:
24275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24276 
      self.ex.write(oprot)
24277 
      oprot.writeFieldEnd()
24278 
    oprot.writeFieldStop()
24279 
    oprot.writeStructEnd()
24280 
 
24281 
  def validate(self):
24282 
    return
24283 
 
24284 
 
24285 
  def __repr__(self):
24286 
    L = ['%s=%r' % (key, value)
24287 
      for key, value in self.__dict__.iteritems()]
24288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24289 
 
24290 
  def __eq__(self, other):
24291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24292 
 
24293 
  def __ne__(self, other):
24294 
    return not (self == other)
5208 varun.gupt 24295 
 
5386 phani.kuma 24296 
class updateOrderOnlyAsPaidToVendor_args:
24297 
  """
24298 
  Attributes:
24299 
   - orderId
24300 
  """
24301 
 
24302 
  thrift_spec = (
24303 
    None, # 0
24304 
    (1, TType.I64, 'orderId', None, None, ), # 1
24305 
  )
24306 
 
24307 
  def __init__(self, orderId=None,):
24308 
    self.orderId = orderId
24309 
 
24310 
  def read(self, iprot):
24311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24313 
      return
24314 
    iprot.readStructBegin()
24315 
    while True:
24316 
      (fname, ftype, fid) = iprot.readFieldBegin()
24317 
      if ftype == TType.STOP:
24318 
        break
24319 
      if fid == 1:
24320 
        if ftype == TType.I64:
24321 
          self.orderId = iprot.readI64();
24322 
        else:
24323 
          iprot.skip(ftype)
24324 
      else:
24325 
        iprot.skip(ftype)
24326 
      iprot.readFieldEnd()
24327 
    iprot.readStructEnd()
24328 
 
24329 
  def write(self, oprot):
24330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24332 
      return
24333 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24334 
    if self.orderId is not None:
24335 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24336 
      oprot.writeI64(self.orderId)
24337 
      oprot.writeFieldEnd()
24338 
    oprot.writeFieldStop()
24339 
    oprot.writeStructEnd()
24340 
 
24341 
  def validate(self):
24342 
    return
24343 
 
24344 
 
24345 
  def __repr__(self):
24346 
    L = ['%s=%r' % (key, value)
24347 
      for key, value in self.__dict__.iteritems()]
24348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24349 
 
24350 
  def __eq__(self, other):
24351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24352 
 
24353 
  def __ne__(self, other):
24354 
    return not (self == other)
24355 
 
24356 
class updateOrderOnlyAsPaidToVendor_result:
24357 
  """
24358 
  Attributes:
24359 
   - ex
24360 
  """
24361 
 
24362 
  thrift_spec = (
24363 
    None, # 0
24364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24365 
  )
24366 
 
24367 
  def __init__(self, ex=None,):
24368 
    self.ex = ex
24369 
 
24370 
  def read(self, iprot):
24371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24373 
      return
24374 
    iprot.readStructBegin()
24375 
    while True:
24376 
      (fname, ftype, fid) = iprot.readFieldBegin()
24377 
      if ftype == TType.STOP:
24378 
        break
24379 
      if fid == 1:
24380 
        if ftype == TType.STRUCT:
24381 
          self.ex = TransactionServiceException()
24382 
          self.ex.read(iprot)
24383 
        else:
24384 
          iprot.skip(ftype)
24385 
      else:
24386 
        iprot.skip(ftype)
24387 
      iprot.readFieldEnd()
24388 
    iprot.readStructEnd()
24389 
 
24390 
  def write(self, oprot):
24391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24393 
      return
24394 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24395 
    if self.ex is not None:
24396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24397 
      self.ex.write(oprot)
24398 
      oprot.writeFieldEnd()
24399 
    oprot.writeFieldStop()
24400 
    oprot.writeStructEnd()
24401 
 
24402 
  def validate(self):
24403 
    return
24404 
 
24405 
 
24406 
  def __repr__(self):
24407 
    L = ['%s=%r' % (key, value)
24408 
      for key, value in self.__dict__.iteritems()]
24409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24410 
 
24411 
  def __eq__(self, other):
24412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24413 
 
24414 
  def __ne__(self, other):
24415 
    return not (self == other)
24416 
 
5208 varun.gupt 24417 
class getRefundedOrdersMarkedPaid_args:
24418 
 
24419 
  thrift_spec = (
24420 
  )
24421 
 
24422 
  def read(self, iprot):
24423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24425 
      return
24426 
    iprot.readStructBegin()
24427 
    while True:
24428 
      (fname, ftype, fid) = iprot.readFieldBegin()
24429 
      if ftype == TType.STOP:
24430 
        break
24431 
      else:
24432 
        iprot.skip(ftype)
24433 
      iprot.readFieldEnd()
24434 
    iprot.readStructEnd()
24435 
 
24436 
  def write(self, oprot):
24437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24439 
      return
24440 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24441 
    oprot.writeFieldStop()
24442 
    oprot.writeStructEnd()
24443 
 
24444 
  def validate(self):
24445 
    return
24446 
 
24447 
 
24448 
  def __repr__(self):
24449 
    L = ['%s=%r' % (key, value)
24450 
      for key, value in self.__dict__.iteritems()]
24451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24452 
 
24453 
  def __eq__(self, other):
24454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24455 
 
24456 
  def __ne__(self, other):
24457 
    return not (self == other)
24458 
 
24459 
class getRefundedOrdersMarkedPaid_result:
24460 
  """
24461 
  Attributes:
24462 
   - success
24463 
   - ex
24464 
  """
24465 
 
24466 
  thrift_spec = (
24467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24469 
  )
24470 
 
24471 
  def __init__(self, success=None, ex=None,):
24472 
    self.success = success
24473 
    self.ex = ex
24474 
 
24475 
  def read(self, iprot):
24476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24478 
      return
24479 
    iprot.readStructBegin()
24480 
    while True:
24481 
      (fname, ftype, fid) = iprot.readFieldBegin()
24482 
      if ftype == TType.STOP:
24483 
        break
24484 
      if fid == 0:
24485 
        if ftype == TType.LIST:
24486 
          self.success = []
6031 rajveer 24487 
          (_etype567, _size564) = iprot.readListBegin()
24488 
          for _i568 in xrange(_size564):
24489 
            _elem569 = Order()
24490 
            _elem569.read(iprot)
24491 
            self.success.append(_elem569)
5208 varun.gupt 24492 
          iprot.readListEnd()
24493 
        else:
24494 
          iprot.skip(ftype)
24495 
      elif fid == 1:
24496 
        if ftype == TType.STRUCT:
24497 
          self.ex = TransactionServiceException()
24498 
          self.ex.read(iprot)
24499 
        else:
24500 
          iprot.skip(ftype)
24501 
      else:
24502 
        iprot.skip(ftype)
24503 
      iprot.readFieldEnd()
24504 
    iprot.readStructEnd()
24505 
 
24506 
  def write(self, oprot):
24507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24509 
      return
24510 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24511 
    if self.success is not None:
24512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24513 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24514 
      for iter570 in self.success:
24515 
        iter570.write(oprot)
5208 varun.gupt 24516 
      oprot.writeListEnd()
24517 
      oprot.writeFieldEnd()
24518 
    if self.ex is not None:
24519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24520 
      self.ex.write(oprot)
24521 
      oprot.writeFieldEnd()
24522 
    oprot.writeFieldStop()
24523 
    oprot.writeStructEnd()
24524 
 
24525 
  def validate(self):
24526 
    return
24527 
 
24528 
 
24529 
  def __repr__(self):
24530 
    L = ['%s=%r' % (key, value)
24531 
      for key, value in self.__dict__.iteritems()]
24532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24533 
 
24534 
  def __eq__(self, other):
24535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24536 
 
24537 
  def __ne__(self, other):
24538 
    return not (self == other)
5447 anupam.sin 24539 
 
24540 
class getAllVerificationAgents_args:
24541 
  """
24542 
  Attributes:
24543 
   - minOrderId
24544 
   - maxOrderId
24545 
  """
24546 
 
24547 
  thrift_spec = (
24548 
    None, # 0
24549 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24550 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24551 
  )
24552 
 
24553 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24554 
    self.minOrderId = minOrderId
24555 
    self.maxOrderId = maxOrderId
24556 
 
24557 
  def read(self, iprot):
24558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24560 
      return
24561 
    iprot.readStructBegin()
24562 
    while True:
24563 
      (fname, ftype, fid) = iprot.readFieldBegin()
24564 
      if ftype == TType.STOP:
24565 
        break
24566 
      if fid == 1:
24567 
        if ftype == TType.I64:
24568 
          self.minOrderId = iprot.readI64();
24569 
        else:
24570 
          iprot.skip(ftype)
24571 
      elif fid == 2:
24572 
        if ftype == TType.I64:
24573 
          self.maxOrderId = iprot.readI64();
24574 
        else:
24575 
          iprot.skip(ftype)
24576 
      else:
24577 
        iprot.skip(ftype)
24578 
      iprot.readFieldEnd()
24579 
    iprot.readStructEnd()
24580 
 
24581 
  def write(self, oprot):
24582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24584 
      return
24585 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24586 
    if self.minOrderId is not None:
24587 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24588 
      oprot.writeI64(self.minOrderId)
24589 
      oprot.writeFieldEnd()
24590 
    if self.maxOrderId is not None:
24591 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24592 
      oprot.writeI64(self.maxOrderId)
24593 
      oprot.writeFieldEnd()
24594 
    oprot.writeFieldStop()
24595 
    oprot.writeStructEnd()
24596 
 
24597 
  def validate(self):
24598 
    return
24599 
 
24600 
 
24601 
  def __repr__(self):
24602 
    L = ['%s=%r' % (key, value)
24603 
      for key, value in self.__dict__.iteritems()]
24604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24605 
 
24606 
  def __eq__(self, other):
24607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24608 
 
24609 
  def __ne__(self, other):
24610 
    return not (self == other)
24611 
 
24612 
class getAllVerificationAgents_result:
24613 
  """
24614 
  Attributes:
24615 
   - success
24616 
  """
24617 
 
24618 
  thrift_spec = (
24619 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24620 
  )
24621 
 
24622 
  def __init__(self, success=None,):
24623 
    self.success = success
24624 
 
24625 
  def read(self, iprot):
24626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24628 
      return
24629 
    iprot.readStructBegin()
24630 
    while True:
24631 
      (fname, ftype, fid) = iprot.readFieldBegin()
24632 
      if ftype == TType.STOP:
24633 
        break
24634 
      if fid == 0:
24635 
        if ftype == TType.LIST:
24636 
          self.success = []
6031 rajveer 24637 
          (_etype574, _size571) = iprot.readListBegin()
24638 
          for _i575 in xrange(_size571):
24639 
            _elem576 = CODVerificationAgent()
24640 
            _elem576.read(iprot)
24641 
            self.success.append(_elem576)
5447 anupam.sin 24642 
          iprot.readListEnd()
24643 
        else:
24644 
          iprot.skip(ftype)
24645 
      else:
24646 
        iprot.skip(ftype)
24647 
      iprot.readFieldEnd()
24648 
    iprot.readStructEnd()
24649 
 
24650 
  def write(self, oprot):
24651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24653 
      return
24654 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24655 
    if self.success is not None:
24656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24658 
      for iter577 in self.success:
24659 
        iter577.write(oprot)
5447 anupam.sin 24660 
      oprot.writeListEnd()
24661 
      oprot.writeFieldEnd()
24662 
    oprot.writeFieldStop()
24663 
    oprot.writeStructEnd()
24664 
 
24665 
  def validate(self):
24666 
    return
24667 
 
24668 
 
24669 
  def __repr__(self):
24670 
    L = ['%s=%r' % (key, value)
24671 
      for key, value in self.__dict__.iteritems()]
24672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24673 
 
24674 
  def __eq__(self, other):
24675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24676 
 
24677 
  def __ne__(self, other):
24678 
    return not (self == other)
5527 anupam.sin 24679 
 
24680 
class getAllAttributesForOrderId_args:
24681 
  """
24682 
  Attributes:
24683 
   - orderId
24684 
  """
24685 
 
24686 
  thrift_spec = (
24687 
    None, # 0
24688 
    (1, TType.I64, 'orderId', None, None, ), # 1
24689 
  )
24690 
 
24691 
  def __init__(self, orderId=None,):
24692 
    self.orderId = orderId
24693 
 
24694 
  def read(self, iprot):
24695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24697 
      return
24698 
    iprot.readStructBegin()
24699 
    while True:
24700 
      (fname, ftype, fid) = iprot.readFieldBegin()
24701 
      if ftype == TType.STOP:
24702 
        break
24703 
      if fid == 1:
24704 
        if ftype == TType.I64:
24705 
          self.orderId = iprot.readI64();
24706 
        else:
24707 
          iprot.skip(ftype)
24708 
      else:
24709 
        iprot.skip(ftype)
24710 
      iprot.readFieldEnd()
24711 
    iprot.readStructEnd()
24712 
 
24713 
  def write(self, oprot):
24714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24716 
      return
24717 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24718 
    if self.orderId is not None:
24719 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24720 
      oprot.writeI64(self.orderId)
24721 
      oprot.writeFieldEnd()
24722 
    oprot.writeFieldStop()
24723 
    oprot.writeStructEnd()
24724 
 
24725 
  def validate(self):
24726 
    return
24727 
 
24728 
 
24729 
  def __repr__(self):
24730 
    L = ['%s=%r' % (key, value)
24731 
      for key, value in self.__dict__.iteritems()]
24732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24733 
 
24734 
  def __eq__(self, other):
24735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24736 
 
24737 
  def __ne__(self, other):
24738 
    return not (self == other)
24739 
 
24740 
class getAllAttributesForOrderId_result:
24741 
  """
24742 
  Attributes:
24743 
   - success
24744 
  """
24745 
 
24746 
  thrift_spec = (
24747 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24748 
  )
24749 
 
24750 
  def __init__(self, success=None,):
24751 
    self.success = success
24752 
 
24753 
  def read(self, iprot):
24754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24756 
      return
24757 
    iprot.readStructBegin()
24758 
    while True:
24759 
      (fname, ftype, fid) = iprot.readFieldBegin()
24760 
      if ftype == TType.STOP:
24761 
        break
24762 
      if fid == 0:
24763 
        if ftype == TType.LIST:
24764 
          self.success = []
6031 rajveer 24765 
          (_etype581, _size578) = iprot.readListBegin()
24766 
          for _i582 in xrange(_size578):
24767 
            _elem583 = Attribute()
24768 
            _elem583.read(iprot)
24769 
            self.success.append(_elem583)
5527 anupam.sin 24770 
          iprot.readListEnd()
24771 
        else:
24772 
          iprot.skip(ftype)
24773 
      else:
24774 
        iprot.skip(ftype)
24775 
      iprot.readFieldEnd()
24776 
    iprot.readStructEnd()
24777 
 
24778 
  def write(self, oprot):
24779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24781 
      return
24782 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24783 
    if self.success is not None:
24784 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24785 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24786 
      for iter584 in self.success:
24787 
        iter584.write(oprot)
5527 anupam.sin 24788 
      oprot.writeListEnd()
24789 
      oprot.writeFieldEnd()
24790 
    oprot.writeFieldStop()
24791 
    oprot.writeStructEnd()
24792 
 
24793 
  def validate(self):
24794 
    return
24795 
 
24796 
 
24797 
  def __repr__(self):
24798 
    L = ['%s=%r' % (key, value)
24799 
      for key, value in self.__dict__.iteritems()]
24800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24801 
 
24802 
  def __eq__(self, other):
24803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24804 
 
24805 
  def __ne__(self, other):
24806 
    return not (self == other)
24807 
 
5676 rajveer 24808 
class setOrderAttributes_args:
24809 
  """
24810 
  Attributes:
24811 
   - orderId
24812 
   - attributes
24813 
  """
24814 
 
24815 
  thrift_spec = None
24816 
  def __init__(self, orderId=None, attributes=None,):
24817 
    self.orderId = orderId
24818 
    self.attributes = attributes
24819 
 
24820 
  def read(self, iprot):
24821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24823 
      return
24824 
    iprot.readStructBegin()
24825 
    while True:
24826 
      (fname, ftype, fid) = iprot.readFieldBegin()
24827 
      if ftype == TType.STOP:
24828 
        break
24829 
      if fid == 1:
24830 
        if ftype == TType.I64:
24831 
          self.orderId = iprot.readI64();
24832 
        else:
24833 
          iprot.skip(ftype)
24834 
      elif fid == -1:
24835 
        if ftype == TType.LIST:
24836 
          self.attributes = []
6031 rajveer 24837 
          (_etype588, _size585) = iprot.readListBegin()
24838 
          for _i589 in xrange(_size585):
24839 
            _elem590 = Attribute()
24840 
            _elem590.read(iprot)
24841 
            self.attributes.append(_elem590)
5676 rajveer 24842 
          iprot.readListEnd()
24843 
        else:
24844 
          iprot.skip(ftype)
24845 
      else:
24846 
        iprot.skip(ftype)
24847 
      iprot.readFieldEnd()
24848 
    iprot.readStructEnd()
24849 
 
24850 
  def write(self, oprot):
24851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24853 
      return
24854 
    oprot.writeStructBegin('setOrderAttributes_args')
24855 
    if self.attributes is not None:
24856 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24857 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 24858 
      for iter591 in self.attributes:
24859 
        iter591.write(oprot)
5676 rajveer 24860 
      oprot.writeListEnd()
24861 
      oprot.writeFieldEnd()
24862 
    if self.orderId is not None:
24863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24864 
      oprot.writeI64(self.orderId)
24865 
      oprot.writeFieldEnd()
24866 
    oprot.writeFieldStop()
24867 
    oprot.writeStructEnd()
24868 
 
24869 
  def validate(self):
24870 
    return
24871 
 
24872 
 
24873 
  def __repr__(self):
24874 
    L = ['%s=%r' % (key, value)
24875 
      for key, value in self.__dict__.iteritems()]
24876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24877 
 
24878 
  def __eq__(self, other):
24879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24880 
 
24881 
  def __ne__(self, other):
24882 
    return not (self == other)
24883 
 
24884 
class setOrderAttributes_result:
24885 
 
24886 
  thrift_spec = (
24887 
  )
24888 
 
24889 
  def read(self, iprot):
24890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24892 
      return
24893 
    iprot.readStructBegin()
24894 
    while True:
24895 
      (fname, ftype, fid) = iprot.readFieldBegin()
24896 
      if ftype == TType.STOP:
24897 
        break
24898 
      else:
24899 
        iprot.skip(ftype)
24900 
      iprot.readFieldEnd()
24901 
    iprot.readStructEnd()
24902 
 
24903 
  def write(self, oprot):
24904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24906 
      return
24907 
    oprot.writeStructBegin('setOrderAttributes_result')
24908 
    oprot.writeFieldStop()
24909 
    oprot.writeStructEnd()
24910 
 
24911 
  def validate(self):
24912 
    return
24913 
 
24914 
 
24915 
  def __repr__(self):
24916 
    L = ['%s=%r' % (key, value)
24917 
      for key, value in self.__dict__.iteritems()]
24918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24919 
 
24920 
  def __eq__(self, other):
24921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24922 
 
24923 
  def __ne__(self, other):
24924 
    return not (self == other)
24925 
 
5527 anupam.sin 24926 
class setOrderAttributeForTransaction_args:
24927 
  """
24928 
  Attributes:
24929 
   - transactionId
24930 
   - attribute
24931 
  """
24932 
 
24933 
  thrift_spec = None
24934 
  def __init__(self, transactionId=None, attribute=None,):
24935 
    self.transactionId = transactionId
24936 
    self.attribute = attribute
24937 
 
24938 
  def read(self, iprot):
24939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24941 
      return
24942 
    iprot.readStructBegin()
24943 
    while True:
24944 
      (fname, ftype, fid) = iprot.readFieldBegin()
24945 
      if ftype == TType.STOP:
24946 
        break
24947 
      if fid == 1:
24948 
        if ftype == TType.I64:
24949 
          self.transactionId = iprot.readI64();
24950 
        else:
24951 
          iprot.skip(ftype)
24952 
      elif fid == -1:
24953 
        if ftype == TType.STRUCT:
24954 
          self.attribute = Attribute()
24955 
          self.attribute.read(iprot)
24956 
        else:
24957 
          iprot.skip(ftype)
24958 
      else:
24959 
        iprot.skip(ftype)
24960 
      iprot.readFieldEnd()
24961 
    iprot.readStructEnd()
24962 
 
24963 
  def write(self, oprot):
24964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24966 
      return
24967 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24968 
    if self.attribute is not None:
24969 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24970 
      self.attribute.write(oprot)
24971 
      oprot.writeFieldEnd()
24972 
    if self.transactionId is not None:
24973 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24974 
      oprot.writeI64(self.transactionId)
24975 
      oprot.writeFieldEnd()
24976 
    oprot.writeFieldStop()
24977 
    oprot.writeStructEnd()
24978 
 
24979 
  def validate(self):
24980 
    return
24981 
 
24982 
 
24983 
  def __repr__(self):
24984 
    L = ['%s=%r' % (key, value)
24985 
      for key, value in self.__dict__.iteritems()]
24986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24987 
 
24988 
  def __eq__(self, other):
24989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24990 
 
24991 
  def __ne__(self, other):
24992 
    return not (self == other)
24993 
 
24994 
class setOrderAttributeForTransaction_result:
24995 
 
24996 
  thrift_spec = (
24997 
  )
24998 
 
24999 
  def read(self, iprot):
25000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25002 
      return
25003 
    iprot.readStructBegin()
25004 
    while True:
25005 
      (fname, ftype, fid) = iprot.readFieldBegin()
25006 
      if ftype == TType.STOP:
25007 
        break
25008 
      else:
25009 
        iprot.skip(ftype)
25010 
      iprot.readFieldEnd()
25011 
    iprot.readStructEnd()
25012 
 
25013 
  def write(self, oprot):
25014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25016 
      return
25017 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25018 
    oprot.writeFieldStop()
25019 
    oprot.writeStructEnd()
25020 
 
25021 
  def validate(self):
25022 
    return
25023 
 
25024 
 
25025 
  def __repr__(self):
25026 
    L = ['%s=%r' % (key, value)
25027 
      for key, value in self.__dict__.iteritems()]
25028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25029 
 
25030 
  def __eq__(self, other):
25031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25032 
 
25033 
  def __ne__(self, other):
25034 
    return not (self == other)
5553 rajveer 25035 
 
25036 
class getReceivePendingOrders_args:
25037 
  """
25038 
  Attributes:
25039 
   - storeId
25040 
  """
25041 
 
25042 
  thrift_spec = (
25043 
    None, # 0
25044 
    (1, TType.I64, 'storeId', None, None, ), # 1
25045 
  )
25046 
 
25047 
  def __init__(self, storeId=None,):
25048 
    self.storeId = storeId
25049 
 
25050 
  def read(self, iprot):
25051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25053 
      return
25054 
    iprot.readStructBegin()
25055 
    while True:
25056 
      (fname, ftype, fid) = iprot.readFieldBegin()
25057 
      if ftype == TType.STOP:
25058 
        break
25059 
      if fid == 1:
25060 
        if ftype == TType.I64:
25061 
          self.storeId = iprot.readI64();
25062 
        else:
25063 
          iprot.skip(ftype)
25064 
      else:
25065 
        iprot.skip(ftype)
25066 
      iprot.readFieldEnd()
25067 
    iprot.readStructEnd()
25068 
 
25069 
  def write(self, oprot):
25070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25072 
      return
25073 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25074 
    if self.storeId is not None:
25075 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25076 
      oprot.writeI64(self.storeId)
25077 
      oprot.writeFieldEnd()
25078 
    oprot.writeFieldStop()
25079 
    oprot.writeStructEnd()
25080 
 
25081 
  def validate(self):
25082 
    return
25083 
 
25084 
 
25085 
  def __repr__(self):
25086 
    L = ['%s=%r' % (key, value)
25087 
      for key, value in self.__dict__.iteritems()]
25088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25089 
 
25090 
  def __eq__(self, other):
25091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25092 
 
25093 
  def __ne__(self, other):
25094 
    return not (self == other)
25095 
 
25096 
class getReceivePendingOrders_result:
25097 
  """
25098 
  Attributes:
25099 
   - success
25100 
  """
25101 
 
25102 
  thrift_spec = (
25103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25104 
  )
25105 
 
25106 
  def __init__(self, success=None,):
25107 
    self.success = success
25108 
 
25109 
  def read(self, iprot):
25110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25112 
      return
25113 
    iprot.readStructBegin()
25114 
    while True:
25115 
      (fname, ftype, fid) = iprot.readFieldBegin()
25116 
      if ftype == TType.STOP:
25117 
        break
25118 
      if fid == 0:
25119 
        if ftype == TType.LIST:
25120 
          self.success = []
6031 rajveer 25121 
          (_etype595, _size592) = iprot.readListBegin()
25122 
          for _i596 in xrange(_size592):
25123 
            _elem597 = Order()
25124 
            _elem597.read(iprot)
25125 
            self.success.append(_elem597)
5553 rajveer 25126 
          iprot.readListEnd()
25127 
        else:
25128 
          iprot.skip(ftype)
25129 
      else:
25130 
        iprot.skip(ftype)
25131 
      iprot.readFieldEnd()
25132 
    iprot.readStructEnd()
25133 
 
25134 
  def write(self, oprot):
25135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25137 
      return
25138 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25139 
    if self.success is not None:
25140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25142 
      for iter598 in self.success:
25143 
        iter598.write(oprot)
5553 rajveer 25144 
      oprot.writeListEnd()
25145 
      oprot.writeFieldEnd()
25146 
    oprot.writeFieldStop()
25147 
    oprot.writeStructEnd()
25148 
 
25149 
  def validate(self):
25150 
    return
25151 
 
25152 
 
25153 
  def __repr__(self):
25154 
    L = ['%s=%r' % (key, value)
25155 
      for key, value in self.__dict__.iteritems()]
25156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25157 
 
25158 
  def __eq__(self, other):
25159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25160 
 
25161 
  def __ne__(self, other):
25162 
    return not (self == other)
25163 
 
25164 
class getReceivedAtStoreOrders_args:
25165 
  """
25166 
  Attributes:
25167 
   - storeId
25168 
  """
25169 
 
25170 
  thrift_spec = (
25171 
    None, # 0
25172 
    (1, TType.I64, 'storeId', None, None, ), # 1
25173 
  )
25174 
 
25175 
  def __init__(self, storeId=None,):
25176 
    self.storeId = storeId
25177 
 
25178 
  def read(self, iprot):
25179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25181 
      return
25182 
    iprot.readStructBegin()
25183 
    while True:
25184 
      (fname, ftype, fid) = iprot.readFieldBegin()
25185 
      if ftype == TType.STOP:
25186 
        break
25187 
      if fid == 1:
25188 
        if ftype == TType.I64:
25189 
          self.storeId = iprot.readI64();
25190 
        else:
25191 
          iprot.skip(ftype)
25192 
      else:
25193 
        iprot.skip(ftype)
25194 
      iprot.readFieldEnd()
25195 
    iprot.readStructEnd()
25196 
 
25197 
  def write(self, oprot):
25198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25200 
      return
25201 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25202 
    if self.storeId is not None:
25203 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25204 
      oprot.writeI64(self.storeId)
25205 
      oprot.writeFieldEnd()
25206 
    oprot.writeFieldStop()
25207 
    oprot.writeStructEnd()
25208 
 
25209 
  def validate(self):
25210 
    return
25211 
 
25212 
 
25213 
  def __repr__(self):
25214 
    L = ['%s=%r' % (key, value)
25215 
      for key, value in self.__dict__.iteritems()]
25216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25217 
 
25218 
  def __eq__(self, other):
25219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25220 
 
25221 
  def __ne__(self, other):
25222 
    return not (self == other)
25223 
 
25224 
class getReceivedAtStoreOrders_result:
25225 
  """
25226 
  Attributes:
25227 
   - success
25228 
  """
25229 
 
25230 
  thrift_spec = (
25231 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25232 
  )
25233 
 
25234 
  def __init__(self, success=None,):
25235 
    self.success = success
25236 
 
25237 
  def read(self, iprot):
25238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25240 
      return
25241 
    iprot.readStructBegin()
25242 
    while True:
25243 
      (fname, ftype, fid) = iprot.readFieldBegin()
25244 
      if ftype == TType.STOP:
25245 
        break
25246 
      if fid == 0:
25247 
        if ftype == TType.LIST:
25248 
          self.success = []
6031 rajveer 25249 
          (_etype602, _size599) = iprot.readListBegin()
25250 
          for _i603 in xrange(_size599):
25251 
            _elem604 = Order()
25252 
            _elem604.read(iprot)
25253 
            self.success.append(_elem604)
5553 rajveer 25254 
          iprot.readListEnd()
25255 
        else:
25256 
          iprot.skip(ftype)
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('getReceivedAtStoreOrders_result')
25267 
    if self.success is not None:
25268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25269 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25270 
      for iter605 in self.success:
25271 
        iter605.write(oprot)
5553 rajveer 25272 
      oprot.writeListEnd()
25273 
      oprot.writeFieldEnd()
25274 
    oprot.writeFieldStop()
25275 
    oprot.writeStructEnd()
25276 
 
25277 
  def validate(self):
25278 
    return
25279 
 
25280 
 
25281 
  def __repr__(self):
25282 
    L = ['%s=%r' % (key, value)
25283 
      for key, value in self.__dict__.iteritems()]
25284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25285 
 
25286 
  def __eq__(self, other):
25287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25288 
 
25289 
  def __ne__(self, other):
25290 
    return not (self == other)
5593 mandeep.dh 25291 
 
5713 rajveer 25292 
class getOrdersCollectionAtStore_args:
25293 
  """
25294 
  Attributes:
25295 
   - storeId
25296 
   - fromDate
25297 
   - toDate
25298 
   - onlyCod
25299 
  """
25300 
 
25301 
  thrift_spec = (
25302 
    None, # 0
25303 
    (1, TType.I64, 'storeId', None, None, ), # 1
25304 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25305 
    (3, TType.I64, 'toDate', None, None, ), # 3
25306 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25307 
  )
25308 
 
25309 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25310 
    self.storeId = storeId
25311 
    self.fromDate = fromDate
25312 
    self.toDate = toDate
25313 
    self.onlyCod = onlyCod
25314 
 
25315 
  def read(self, iprot):
25316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25318 
      return
25319 
    iprot.readStructBegin()
25320 
    while True:
25321 
      (fname, ftype, fid) = iprot.readFieldBegin()
25322 
      if ftype == TType.STOP:
25323 
        break
25324 
      if fid == 1:
25325 
        if ftype == TType.I64:
25326 
          self.storeId = iprot.readI64();
25327 
        else:
25328 
          iprot.skip(ftype)
25329 
      elif fid == 2:
25330 
        if ftype == TType.I64:
25331 
          self.fromDate = iprot.readI64();
25332 
        else:
25333 
          iprot.skip(ftype)
25334 
      elif fid == 3:
25335 
        if ftype == TType.I64:
25336 
          self.toDate = iprot.readI64();
25337 
        else:
25338 
          iprot.skip(ftype)
25339 
      elif fid == 4:
25340 
        if ftype == TType.BOOL:
25341 
          self.onlyCod = iprot.readBool();
25342 
        else:
25343 
          iprot.skip(ftype)
25344 
      else:
25345 
        iprot.skip(ftype)
25346 
      iprot.readFieldEnd()
25347 
    iprot.readStructEnd()
25348 
 
25349 
  def write(self, oprot):
25350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25352 
      return
25353 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25354 
    if self.storeId is not None:
25355 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25356 
      oprot.writeI64(self.storeId)
25357 
      oprot.writeFieldEnd()
25358 
    if self.fromDate is not None:
25359 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25360 
      oprot.writeI64(self.fromDate)
25361 
      oprot.writeFieldEnd()
25362 
    if self.toDate is not None:
25363 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25364 
      oprot.writeI64(self.toDate)
25365 
      oprot.writeFieldEnd()
25366 
    if self.onlyCod is not None:
25367 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25368 
      oprot.writeBool(self.onlyCod)
25369 
      oprot.writeFieldEnd()
25370 
    oprot.writeFieldStop()
25371 
    oprot.writeStructEnd()
25372 
 
25373 
  def validate(self):
25374 
    return
25375 
 
25376 
 
25377 
  def __repr__(self):
25378 
    L = ['%s=%r' % (key, value)
25379 
      for key, value in self.__dict__.iteritems()]
25380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25381 
 
25382 
  def __eq__(self, other):
25383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25384 
 
25385 
  def __ne__(self, other):
25386 
    return not (self == other)
25387 
 
25388 
class getOrdersCollectionAtStore_result:
25389 
  """
25390 
  Attributes:
25391 
   - success
25392 
  """
25393 
 
25394 
  thrift_spec = (
25395 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25396 
  )
25397 
 
25398 
  def __init__(self, success=None,):
25399 
    self.success = success
25400 
 
25401 
  def read(self, iprot):
25402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25404 
      return
25405 
    iprot.readStructBegin()
25406 
    while True:
25407 
      (fname, ftype, fid) = iprot.readFieldBegin()
25408 
      if ftype == TType.STOP:
25409 
        break
25410 
      if fid == 0:
25411 
        if ftype == TType.LIST:
25412 
          self.success = []
6031 rajveer 25413 
          (_etype609, _size606) = iprot.readListBegin()
25414 
          for _i610 in xrange(_size606):
25415 
            _elem611 = Order()
25416 
            _elem611.read(iprot)
25417 
            self.success.append(_elem611)
5713 rajveer 25418 
          iprot.readListEnd()
25419 
        else:
25420 
          iprot.skip(ftype)
25421 
      else:
25422 
        iprot.skip(ftype)
25423 
      iprot.readFieldEnd()
25424 
    iprot.readStructEnd()
25425 
 
25426 
  def write(self, oprot):
25427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25429 
      return
25430 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25431 
    if self.success is not None:
25432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25434 
      for iter612 in self.success:
25435 
        iter612.write(oprot)
5713 rajveer 25436 
      oprot.writeListEnd()
25437 
      oprot.writeFieldEnd()
25438 
    oprot.writeFieldStop()
25439 
    oprot.writeStructEnd()
25440 
 
25441 
  def validate(self):
25442 
    return
25443 
 
25444 
 
25445 
  def __repr__(self):
25446 
    L = ['%s=%r' % (key, value)
25447 
      for key, value in self.__dict__.iteritems()]
25448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25449 
 
25450 
  def __eq__(self, other):
25451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25452 
 
25453 
  def __ne__(self, other):
25454 
    return not (self == other)
25455 
 
5833 rajveer 25456 
class getOrderAttributeValue_args:
25457 
  """
25458 
  Attributes:
25459 
   - orderId
25460 
   - attributeName
25461 
  """
25462 
 
25463 
  thrift_spec = None
25464 
  def __init__(self, orderId=None, attributeName=None,):
25465 
    self.orderId = orderId
25466 
    self.attributeName = attributeName
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 == 1:
25478 
        if ftype == TType.I64:
25479 
          self.orderId = iprot.readI64();
25480 
        else:
25481 
          iprot.skip(ftype)
25482 
      elif fid == -1:
25483 
        if ftype == TType.STRING:
25484 
          self.attributeName = iprot.readString();
25485 
        else:
25486 
          iprot.skip(ftype)
25487 
      else:
25488 
        iprot.skip(ftype)
25489 
      iprot.readFieldEnd()
25490 
    iprot.readStructEnd()
25491 
 
25492 
  def write(self, oprot):
25493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25495 
      return
25496 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25497 
    if self.attributeName is not None:
25498 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25499 
      oprot.writeString(self.attributeName)
25500 
      oprot.writeFieldEnd()
25501 
    if self.orderId is not None:
25502 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25503 
      oprot.writeI64(self.orderId)
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 getOrderAttributeValue_result:
25524 
  """
25525 
  Attributes:
25526 
   - success
25527 
  """
25528 
 
25529 
  thrift_spec = (
25530 
    (0, TType.STRING, 'success', None, None, ), # 0
25531 
  )
25532 
 
25533 
  def __init__(self, success=None,):
25534 
    self.success = success
25535 
 
25536 
  def read(self, iprot):
25537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25539 
      return
25540 
    iprot.readStructBegin()
25541 
    while True:
25542 
      (fname, ftype, fid) = iprot.readFieldBegin()
25543 
      if ftype == TType.STOP:
25544 
        break
25545 
      if fid == 0:
25546 
        if ftype == TType.STRING:
25547 
          self.success = iprot.readString();
25548 
        else:
25549 
          iprot.skip(ftype)
25550 
      else:
25551 
        iprot.skip(ftype)
25552 
      iprot.readFieldEnd()
25553 
    iprot.readStructEnd()
25554 
 
25555 
  def write(self, oprot):
25556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25558 
      return
25559 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25560 
    if self.success is not None:
25561 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25562 
      oprot.writeString(self.success)
25563 
      oprot.writeFieldEnd()
25564 
    oprot.writeFieldStop()
25565 
    oprot.writeStructEnd()
25566 
 
25567 
  def validate(self):
25568 
    return
25569 
 
25570 
 
25571 
  def __repr__(self):
25572 
    L = ['%s=%r' % (key, value)
25573 
      for key, value in self.__dict__.iteritems()]
25574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25575 
 
25576 
  def __eq__(self, other):
25577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25578 
 
25579 
  def __ne__(self, other):
25580 
    return not (self == other)
25581 
 
6019 rajveer 25582 
class changeJacketNumber_args:
25583 
  """
25584 
  Attributes:
25585 
   - orderId
25586 
   - jacketNumber
25587 
  """
25588 
 
25589 
  thrift_spec = (
25590 
    None, # 0
25591 
    (1, TType.I64, 'orderId', None, None, ), # 1
25592 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25593 
  )
25594 
 
25595 
  def __init__(self, orderId=None, jacketNumber=None,):
25596 
    self.orderId = orderId
25597 
    self.jacketNumber = jacketNumber
25598 
 
25599 
  def read(self, iprot):
25600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25602 
      return
25603 
    iprot.readStructBegin()
25604 
    while True:
25605 
      (fname, ftype, fid) = iprot.readFieldBegin()
25606 
      if ftype == TType.STOP:
25607 
        break
25608 
      if fid == 1:
25609 
        if ftype == TType.I64:
25610 
          self.orderId = iprot.readI64();
25611 
        else:
25612 
          iprot.skip(ftype)
25613 
      elif fid == 2:
25614 
        if ftype == TType.I64:
25615 
          self.jacketNumber = iprot.readI64();
25616 
        else:
25617 
          iprot.skip(ftype)
25618 
      else:
25619 
        iprot.skip(ftype)
25620 
      iprot.readFieldEnd()
25621 
    iprot.readStructEnd()
25622 
 
25623 
  def write(self, oprot):
25624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25626 
      return
25627 
    oprot.writeStructBegin('changeJacketNumber_args')
25628 
    if self.orderId is not None:
25629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25630 
      oprot.writeI64(self.orderId)
25631 
      oprot.writeFieldEnd()
25632 
    if self.jacketNumber is not None:
25633 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25634 
      oprot.writeI64(self.jacketNumber)
25635 
      oprot.writeFieldEnd()
25636 
    oprot.writeFieldStop()
25637 
    oprot.writeStructEnd()
25638 
 
25639 
  def validate(self):
25640 
    return
25641 
 
25642 
 
25643 
  def __repr__(self):
25644 
    L = ['%s=%r' % (key, value)
25645 
      for key, value in self.__dict__.iteritems()]
25646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25647 
 
25648 
  def __eq__(self, other):
25649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25650 
 
25651 
  def __ne__(self, other):
25652 
    return not (self == other)
25653 
 
25654 
class changeJacketNumber_result:
25655 
  """
25656 
  Attributes:
25657 
   - success
25658 
  """
25659 
 
25660 
  thrift_spec = (
25661 
    (0, TType.BOOL, 'success', None, None, ), # 0
25662 
  )
25663 
 
25664 
  def __init__(self, success=None,):
25665 
    self.success = success
25666 
 
25667 
  def read(self, iprot):
25668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25670 
      return
25671 
    iprot.readStructBegin()
25672 
    while True:
25673 
      (fname, ftype, fid) = iprot.readFieldBegin()
25674 
      if ftype == TType.STOP:
25675 
        break
25676 
      if fid == 0:
25677 
        if ftype == TType.BOOL:
25678 
          self.success = iprot.readBool();
25679 
        else:
25680 
          iprot.skip(ftype)
25681 
      else:
25682 
        iprot.skip(ftype)
25683 
      iprot.readFieldEnd()
25684 
    iprot.readStructEnd()
25685 
 
25686 
  def write(self, oprot):
25687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25689 
      return
25690 
    oprot.writeStructBegin('changeJacketNumber_result')
25691 
    if self.success is not None:
25692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25693 
      oprot.writeBool(self.success)
25694 
      oprot.writeFieldEnd()
25695 
    oprot.writeFieldStop()
25696 
    oprot.writeStructEnd()
25697 
 
25698 
  def validate(self):
25699 
    return
25700 
 
25701 
 
25702 
  def __repr__(self):
25703 
    L = ['%s=%r' % (key, value)
25704 
      for key, value in self.__dict__.iteritems()]
25705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25706 
 
25707 
  def __eq__(self, other):
25708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25709 
 
25710 
  def __ne__(self, other):
25711 
    return not (self == other)
25712 
 
25713 
class markOrderAsRtoInTransit_args:
25714 
  """
25715 
  Attributes:
25716 
   - orderId
25717 
  """
25718 
 
25719 
  thrift_spec = (
25720 
    None, # 0
25721 
    (1, TType.I64, 'orderId', None, None, ), # 1
25722 
  )
25723 
 
25724 
  def __init__(self, orderId=None,):
25725 
    self.orderId = orderId
25726 
 
25727 
  def read(self, iprot):
25728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25730 
      return
25731 
    iprot.readStructBegin()
25732 
    while True:
25733 
      (fname, ftype, fid) = iprot.readFieldBegin()
25734 
      if ftype == TType.STOP:
25735 
        break
25736 
      if fid == 1:
25737 
        if ftype == TType.I64:
25738 
          self.orderId = iprot.readI64();
25739 
        else:
25740 
          iprot.skip(ftype)
25741 
      else:
25742 
        iprot.skip(ftype)
25743 
      iprot.readFieldEnd()
25744 
    iprot.readStructEnd()
25745 
 
25746 
  def write(self, oprot):
25747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25749 
      return
25750 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
25751 
    if self.orderId is not None:
25752 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25753 
      oprot.writeI64(self.orderId)
25754 
      oprot.writeFieldEnd()
25755 
    oprot.writeFieldStop()
25756 
    oprot.writeStructEnd()
25757 
 
25758 
  def validate(self):
25759 
    return
25760 
 
25761 
 
25762 
  def __repr__(self):
25763 
    L = ['%s=%r' % (key, value)
25764 
      for key, value in self.__dict__.iteritems()]
25765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25766 
 
25767 
  def __eq__(self, other):
25768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25769 
 
25770 
  def __ne__(self, other):
25771 
    return not (self == other)
25772 
 
25773 
class markOrderAsRtoInTransit_result:
25774 
  """
25775 
  Attributes:
25776 
   - success
25777 
  """
25778 
 
25779 
  thrift_spec = (
25780 
    (0, TType.BOOL, 'success', None, None, ), # 0
25781 
  )
25782 
 
25783 
  def __init__(self, success=None,):
25784 
    self.success = success
25785 
 
25786 
  def read(self, iprot):
25787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25789 
      return
25790 
    iprot.readStructBegin()
25791 
    while True:
25792 
      (fname, ftype, fid) = iprot.readFieldBegin()
25793 
      if ftype == TType.STOP:
25794 
        break
25795 
      if fid == 0:
25796 
        if ftype == TType.BOOL:
25797 
          self.success = iprot.readBool();
25798 
        else:
25799 
          iprot.skip(ftype)
25800 
      else:
25801 
        iprot.skip(ftype)
25802 
      iprot.readFieldEnd()
25803 
    iprot.readStructEnd()
25804 
 
25805 
  def write(self, oprot):
25806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25808 
      return
25809 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
25810 
    if self.success is not None:
25811 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25812 
      oprot.writeBool(self.success)
25813 
      oprot.writeFieldEnd()
25814 
    oprot.writeFieldStop()
25815 
    oprot.writeStructEnd()
25816 
 
25817 
  def validate(self):
25818 
    return
25819 
 
25820 
 
25821 
  def __repr__(self):
25822 
    L = ['%s=%r' % (key, value)
25823 
      for key, value in self.__dict__.iteritems()]
25824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25825 
 
25826 
  def __eq__(self, other):
25827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25828 
 
25829 
  def __ne__(self, other):
25830 
    return not (self == other)
25831 
 
5593 mandeep.dh 25832 
class acceptOrderForItem_args:
25833 
  """
25834 
  Attributes:
25835 
   - itemId
25836 
   - quantity
25837 
   - fulfilmentWarehouseId
25838 
   - billingWarehouseId
25839 
  """
25840 
 
25841 
  thrift_spec = (
25842 
    None, # 0
25843 
    (1, TType.I64, 'itemId', None, None, ), # 1
25844 
    (2, TType.I64, 'quantity', None, None, ), # 2
25845 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25846 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25847 
  )
25848 
 
25849 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25850 
    self.itemId = itemId
25851 
    self.quantity = quantity
25852 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25853 
    self.billingWarehouseId = billingWarehouseId
25854 
 
25855 
  def read(self, iprot):
25856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25858 
      return
25859 
    iprot.readStructBegin()
25860 
    while True:
25861 
      (fname, ftype, fid) = iprot.readFieldBegin()
25862 
      if ftype == TType.STOP:
25863 
        break
25864 
      if fid == 1:
25865 
        if ftype == TType.I64:
25866 
          self.itemId = iprot.readI64();
25867 
        else:
25868 
          iprot.skip(ftype)
25869 
      elif fid == 2:
25870 
        if ftype == TType.I64:
25871 
          self.quantity = iprot.readI64();
25872 
        else:
25873 
          iprot.skip(ftype)
25874 
      elif fid == 3:
25875 
        if ftype == TType.I64:
25876 
          self.fulfilmentWarehouseId = iprot.readI64();
25877 
        else:
25878 
          iprot.skip(ftype)
25879 
      elif fid == 4:
25880 
        if ftype == TType.I64:
25881 
          self.billingWarehouseId = iprot.readI64();
25882 
        else:
25883 
          iprot.skip(ftype)
25884 
      else:
25885 
        iprot.skip(ftype)
25886 
      iprot.readFieldEnd()
25887 
    iprot.readStructEnd()
25888 
 
25889 
  def write(self, oprot):
25890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25892 
      return
25893 
    oprot.writeStructBegin('acceptOrderForItem_args')
25894 
    if self.itemId is not None:
25895 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25896 
      oprot.writeI64(self.itemId)
25897 
      oprot.writeFieldEnd()
25898 
    if self.quantity is not None:
25899 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25900 
      oprot.writeI64(self.quantity)
25901 
      oprot.writeFieldEnd()
25902 
    if self.fulfilmentWarehouseId is not None:
25903 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
25904 
      oprot.writeI64(self.fulfilmentWarehouseId)
25905 
      oprot.writeFieldEnd()
25906 
    if self.billingWarehouseId is not None:
25907 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
25908 
      oprot.writeI64(self.billingWarehouseId)
25909 
      oprot.writeFieldEnd()
25910 
    oprot.writeFieldStop()
25911 
    oprot.writeStructEnd()
25912 
 
25913 
  def validate(self):
25914 
    return
25915 
 
25916 
 
25917 
  def __repr__(self):
25918 
    L = ['%s=%r' % (key, value)
25919 
      for key, value in self.__dict__.iteritems()]
25920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25921 
 
25922 
  def __eq__(self, other):
25923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25924 
 
25925 
  def __ne__(self, other):
25926 
    return not (self == other)
25927 
 
25928 
class acceptOrderForItem_result:
25929 
 
25930 
  thrift_spec = (
25931 
  )
25932 
 
25933 
  def read(self, iprot):
25934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25936 
      return
25937 
    iprot.readStructBegin()
25938 
    while True:
25939 
      (fname, ftype, fid) = iprot.readFieldBegin()
25940 
      if ftype == TType.STOP:
25941 
        break
25942 
      else:
25943 
        iprot.skip(ftype)
25944 
      iprot.readFieldEnd()
25945 
    iprot.readStructEnd()
25946 
 
25947 
  def write(self, oprot):
25948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25950 
      return
25951 
    oprot.writeStructBegin('acceptOrderForItem_result')
25952 
    oprot.writeFieldStop()
25953 
    oprot.writeStructEnd()
25954 
 
25955 
  def validate(self):
25956 
    return
25957 
 
25958 
 
25959 
  def __repr__(self):
25960 
    L = ['%s=%r' % (key, value)
25961 
      for key, value in self.__dict__.iteritems()]
25962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25963 
 
25964 
  def __eq__(self, other):
25965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25966 
 
25967 
  def __ne__(self, other):
25968 
    return not (self == other)
6000 mandeep.dh 25969 
 
25970 
class createRechargeOrder_args:
25971 
  """
25972 
  Attributes:
25973 
   - rechargeOrder
25974 
  """
25975 
 
25976 
  thrift_spec = (
25977 
    None, # 0
25978 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
25979 
  )
25980 
 
25981 
  def __init__(self, rechargeOrder=None,):
25982 
    self.rechargeOrder = rechargeOrder
25983 
 
25984 
  def read(self, iprot):
25985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25987 
      return
25988 
    iprot.readStructBegin()
25989 
    while True:
25990 
      (fname, ftype, fid) = iprot.readFieldBegin()
25991 
      if ftype == TType.STOP:
25992 
        break
25993 
      if fid == 1:
25994 
        if ftype == TType.STRUCT:
25995 
          self.rechargeOrder = RechargeOrder()
25996 
          self.rechargeOrder.read(iprot)
25997 
        else:
25998 
          iprot.skip(ftype)
25999 
      else:
26000 
        iprot.skip(ftype)
26001 
      iprot.readFieldEnd()
26002 
    iprot.readStructEnd()
26003 
 
26004 
  def write(self, oprot):
26005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26007 
      return
26008 
    oprot.writeStructBegin('createRechargeOrder_args')
26009 
    if self.rechargeOrder is not None:
26010 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26011 
      self.rechargeOrder.write(oprot)
26012 
      oprot.writeFieldEnd()
26013 
    oprot.writeFieldStop()
26014 
    oprot.writeStructEnd()
26015 
 
26016 
  def validate(self):
26017 
    return
26018 
 
26019 
 
26020 
  def __repr__(self):
26021 
    L = ['%s=%r' % (key, value)
26022 
      for key, value in self.__dict__.iteritems()]
26023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26024 
 
26025 
  def __eq__(self, other):
26026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26027 
 
26028 
  def __ne__(self, other):
26029 
    return not (self == other)
26030 
 
26031 
class createRechargeOrder_result:
26032 
  """
26033 
  Attributes:
26034 
   - success
26035 
   - ex
26036 
  """
26037 
 
26038 
  thrift_spec = (
26039 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26040 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26041 
  )
26042 
 
26043 
  def __init__(self, success=None, ex=None,):
26044 
    self.success = success
26045 
    self.ex = ex
26046 
 
26047 
  def read(self, iprot):
26048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26050 
      return
26051 
    iprot.readStructBegin()
26052 
    while True:
26053 
      (fname, ftype, fid) = iprot.readFieldBegin()
26054 
      if ftype == TType.STOP:
26055 
        break
26056 
      if fid == 0:
26057 
        if ftype == TType.STRUCT:
26058 
          self.success = RechargeOrder()
26059 
          self.success.read(iprot)
26060 
        else:
26061 
          iprot.skip(ftype)
26062 
      elif fid == 1:
26063 
        if ftype == TType.STRUCT:
26064 
          self.ex = TransactionServiceException()
26065 
          self.ex.read(iprot)
26066 
        else:
26067 
          iprot.skip(ftype)
26068 
      else:
26069 
        iprot.skip(ftype)
26070 
      iprot.readFieldEnd()
26071 
    iprot.readStructEnd()
26072 
 
26073 
  def write(self, oprot):
26074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26076 
      return
26077 
    oprot.writeStructBegin('createRechargeOrder_result')
26078 
    if self.success is not None:
26079 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26080 
      self.success.write(oprot)
26081 
      oprot.writeFieldEnd()
26082 
    if self.ex is not None:
26083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26084 
      self.ex.write(oprot)
26085 
      oprot.writeFieldEnd()
26086 
    oprot.writeFieldStop()
26087 
    oprot.writeStructEnd()
26088 
 
26089 
  def validate(self):
26090 
    return
26091 
 
26092 
 
26093 
  def __repr__(self):
26094 
    L = ['%s=%r' % (key, value)
26095 
      for key, value in self.__dict__.iteritems()]
26096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26097 
 
26098 
  def __eq__(self, other):
26099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26100 
 
26101 
  def __ne__(self, other):
26102 
    return not (self == other)
26103 
 
6031 rajveer 26104 
class getRechargeOrder_args:
26105 
  """
26106 
  Attributes:
26107 
   - rechargeRrderId
26108 
  """
26109 
 
26110 
  thrift_spec = (
26111 
    None, # 0
26112 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26113 
  )
26114 
 
26115 
  def __init__(self, rechargeRrderId=None,):
26116 
    self.rechargeRrderId = rechargeRrderId
26117 
 
26118 
  def read(self, iprot):
26119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26121 
      return
26122 
    iprot.readStructBegin()
26123 
    while True:
26124 
      (fname, ftype, fid) = iprot.readFieldBegin()
26125 
      if ftype == TType.STOP:
26126 
        break
26127 
      if fid == 1:
26128 
        if ftype == TType.I64:
26129 
          self.rechargeRrderId = iprot.readI64();
26130 
        else:
26131 
          iprot.skip(ftype)
26132 
      else:
26133 
        iprot.skip(ftype)
26134 
      iprot.readFieldEnd()
26135 
    iprot.readStructEnd()
26136 
 
26137 
  def write(self, oprot):
26138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26140 
      return
26141 
    oprot.writeStructBegin('getRechargeOrder_args')
26142 
    if self.rechargeRrderId is not None:
26143 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26144 
      oprot.writeI64(self.rechargeRrderId)
26145 
      oprot.writeFieldEnd()
26146 
    oprot.writeFieldStop()
26147 
    oprot.writeStructEnd()
26148 
 
26149 
  def validate(self):
26150 
    return
26151 
 
26152 
 
26153 
  def __repr__(self):
26154 
    L = ['%s=%r' % (key, value)
26155 
      for key, value in self.__dict__.iteritems()]
26156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26157 
 
26158 
  def __eq__(self, other):
26159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26160 
 
26161 
  def __ne__(self, other):
26162 
    return not (self == other)
26163 
 
26164 
class getRechargeOrder_result:
26165 
  """
26166 
  Attributes:
26167 
   - success
26168 
   - ex
26169 
  """
26170 
 
26171 
  thrift_spec = (
26172 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26174 
  )
26175 
 
26176 
  def __init__(self, success=None, ex=None,):
26177 
    self.success = success
26178 
    self.ex = ex
26179 
 
26180 
  def read(self, iprot):
26181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26183 
      return
26184 
    iprot.readStructBegin()
26185 
    while True:
26186 
      (fname, ftype, fid) = iprot.readFieldBegin()
26187 
      if ftype == TType.STOP:
26188 
        break
26189 
      if fid == 0:
26190 
        if ftype == TType.STRUCT:
26191 
          self.success = RechargeOrder()
26192 
          self.success.read(iprot)
26193 
        else:
26194 
          iprot.skip(ftype)
26195 
      elif fid == 1:
26196 
        if ftype == TType.STRUCT:
26197 
          self.ex = TransactionServiceException()
26198 
          self.ex.read(iprot)
26199 
        else:
26200 
          iprot.skip(ftype)
26201 
      else:
26202 
        iprot.skip(ftype)
26203 
      iprot.readFieldEnd()
26204 
    iprot.readStructEnd()
26205 
 
26206 
  def write(self, oprot):
26207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26209 
      return
26210 
    oprot.writeStructBegin('getRechargeOrder_result')
26211 
    if self.success is not None:
26212 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26213 
      self.success.write(oprot)
26214 
      oprot.writeFieldEnd()
26215 
    if self.ex is not None:
26216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26217 
      self.ex.write(oprot)
26218 
      oprot.writeFieldEnd()
26219 
    oprot.writeFieldStop()
26220 
    oprot.writeStructEnd()
26221 
 
26222 
  def validate(self):
26223 
    return
26224 
 
26225 
 
26226 
  def __repr__(self):
26227 
    L = ['%s=%r' % (key, value)
26228 
      for key, value in self.__dict__.iteritems()]
26229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26230 
 
26231 
  def __eq__(self, other):
26232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26233 
 
26234 
  def __ne__(self, other):
26235 
    return not (self == other)
26236 
 
26237 
class getRechargeOrders_args:
26238 
  """
26239 
  Attributes:
26240 
   - userId
26241 
  """
26242 
 
26243 
  thrift_spec = (
26244 
    None, # 0
26245 
    (1, TType.I64, 'userId', None, None, ), # 1
26246 
  )
26247 
 
26248 
  def __init__(self, userId=None,):
26249 
    self.userId = userId
26250 
 
26251 
  def read(self, iprot):
26252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26254 
      return
26255 
    iprot.readStructBegin()
26256 
    while True:
26257 
      (fname, ftype, fid) = iprot.readFieldBegin()
26258 
      if ftype == TType.STOP:
26259 
        break
26260 
      if fid == 1:
26261 
        if ftype == TType.I64:
26262 
          self.userId = iprot.readI64();
26263 
        else:
26264 
          iprot.skip(ftype)
26265 
      else:
26266 
        iprot.skip(ftype)
26267 
      iprot.readFieldEnd()
26268 
    iprot.readStructEnd()
26269 
 
26270 
  def write(self, oprot):
26271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26273 
      return
26274 
    oprot.writeStructBegin('getRechargeOrders_args')
26275 
    if self.userId is not None:
26276 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26277 
      oprot.writeI64(self.userId)
26278 
      oprot.writeFieldEnd()
26279 
    oprot.writeFieldStop()
26280 
    oprot.writeStructEnd()
26281 
 
26282 
  def validate(self):
26283 
    return
26284 
 
26285 
 
26286 
  def __repr__(self):
26287 
    L = ['%s=%r' % (key, value)
26288 
      for key, value in self.__dict__.iteritems()]
26289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26290 
 
26291 
  def __eq__(self, other):
26292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26293 
 
26294 
  def __ne__(self, other):
26295 
    return not (self == other)
26296 
 
26297 
class getRechargeOrders_result:
26298 
  """
26299 
  Attributes:
26300 
   - success
26301 
  """
26302 
 
26303 
  thrift_spec = (
26304 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26305 
  )
26306 
 
26307 
  def __init__(self, success=None,):
26308 
    self.success = success
26309 
 
26310 
  def read(self, iprot):
26311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26313 
      return
26314 
    iprot.readStructBegin()
26315 
    while True:
26316 
      (fname, ftype, fid) = iprot.readFieldBegin()
26317 
      if ftype == TType.STOP:
26318 
        break
26319 
      if fid == 0:
26320 
        if ftype == TType.LIST:
26321 
          self.success = []
26322 
          (_etype616, _size613) = iprot.readListBegin()
26323 
          for _i617 in xrange(_size613):
26324 
            _elem618 = RechargeOrder()
26325 
            _elem618.read(iprot)
26326 
            self.success.append(_elem618)
26327 
          iprot.readListEnd()
26328 
        else:
26329 
          iprot.skip(ftype)
26330 
      else:
26331 
        iprot.skip(ftype)
26332 
      iprot.readFieldEnd()
26333 
    iprot.readStructEnd()
26334 
 
26335 
  def write(self, oprot):
26336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26338 
      return
26339 
    oprot.writeStructBegin('getRechargeOrders_result')
26340 
    if self.success is not None:
26341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26342 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26343 
      for iter619 in self.success:
26344 
        iter619.write(oprot)
26345 
      oprot.writeListEnd()
26346 
      oprot.writeFieldEnd()
26347 
    oprot.writeFieldStop()
26348 
    oprot.writeStructEnd()
26349 
 
26350 
  def validate(self):
26351 
    return
26352 
 
26353 
 
26354 
  def __repr__(self):
26355 
    L = ['%s=%r' % (key, value)
26356 
      for key, value in self.__dict__.iteritems()]
26357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26358 
 
26359 
  def __eq__(self, other):
26360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26361 
 
26362 
  def __ne__(self, other):
26363 
    return not (self == other)
26364 
 
6000 mandeep.dh 26365 
class updateRechargeOrderStatus_args:
26366 
  """
26367 
  Attributes:
26368 
   - rechargeOrderId
26369 
   - rechargeOrderStatus
26370 
  """
26371 
 
26372 
  thrift_spec = (
26373 
    None, # 0
26374 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26375 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26376 
  )
26377 
 
26378 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26379 
    self.rechargeOrderId = rechargeOrderId
26380 
    self.rechargeOrderStatus = rechargeOrderStatus
26381 
 
26382 
  def read(self, iprot):
26383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26385 
      return
26386 
    iprot.readStructBegin()
26387 
    while True:
26388 
      (fname, ftype, fid) = iprot.readFieldBegin()
26389 
      if ftype == TType.STOP:
26390 
        break
26391 
      if fid == 1:
26392 
        if ftype == TType.I64:
26393 
          self.rechargeOrderId = iprot.readI64();
26394 
        else:
26395 
          iprot.skip(ftype)
26396 
      elif fid == 2:
26397 
        if ftype == TType.I32:
26398 
          self.rechargeOrderStatus = iprot.readI32();
26399 
        else:
26400 
          iprot.skip(ftype)
26401 
      else:
26402 
        iprot.skip(ftype)
26403 
      iprot.readFieldEnd()
26404 
    iprot.readStructEnd()
26405 
 
26406 
  def write(self, oprot):
26407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26409 
      return
26410 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26411 
    if self.rechargeOrderId is not None:
26412 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26413 
      oprot.writeI64(self.rechargeOrderId)
26414 
      oprot.writeFieldEnd()
26415 
    if self.rechargeOrderStatus is not None:
26416 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26417 
      oprot.writeI32(self.rechargeOrderStatus)
26418 
      oprot.writeFieldEnd()
26419 
    oprot.writeFieldStop()
26420 
    oprot.writeStructEnd()
26421 
 
26422 
  def validate(self):
26423 
    return
26424 
 
26425 
 
26426 
  def __repr__(self):
26427 
    L = ['%s=%r' % (key, value)
26428 
      for key, value in self.__dict__.iteritems()]
26429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26430 
 
26431 
  def __eq__(self, other):
26432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26433 
 
26434 
  def __ne__(self, other):
26435 
    return not (self == other)
26436 
 
26437 
class updateRechargeOrderStatus_result:
26438 
  """
26439 
  Attributes:
6031 rajveer 26440 
   - success
6000 mandeep.dh 26441 
   - ex
26442 
  """
26443 
 
26444 
  thrift_spec = (
6031 rajveer 26445 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26447 
  )
26448 
 
6031 rajveer 26449 
  def __init__(self, success=None, ex=None,):
26450 
    self.success = success
6000 mandeep.dh 26451 
    self.ex = ex
26452 
 
26453 
  def read(self, iprot):
26454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26456 
      return
26457 
    iprot.readStructBegin()
26458 
    while True:
26459 
      (fname, ftype, fid) = iprot.readFieldBegin()
26460 
      if ftype == TType.STOP:
26461 
        break
6031 rajveer 26462 
      if fid == 0:
26463 
        if ftype == TType.BOOL:
26464 
          self.success = iprot.readBool();
26465 
        else:
26466 
          iprot.skip(ftype)
26467 
      elif fid == 1:
6000 mandeep.dh 26468 
        if ftype == TType.STRUCT:
26469 
          self.ex = TransactionServiceException()
26470 
          self.ex.read(iprot)
26471 
        else:
26472 
          iprot.skip(ftype)
26473 
      else:
26474 
        iprot.skip(ftype)
26475 
      iprot.readFieldEnd()
26476 
    iprot.readStructEnd()
26477 
 
26478 
  def write(self, oprot):
26479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26481 
      return
26482 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26483 
    if self.success is not None:
26484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26485 
      oprot.writeBool(self.success)
26486 
      oprot.writeFieldEnd()
6000 mandeep.dh 26487 
    if self.ex is not None:
26488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26489 
      self.ex.write(oprot)
26490 
      oprot.writeFieldEnd()
26491 
    oprot.writeFieldStop()
26492 
    oprot.writeStructEnd()
26493 
 
26494 
  def validate(self):
26495 
    return
26496 
 
26497 
 
26498 
  def __repr__(self):
26499 
    L = ['%s=%r' % (key, value)
26500 
      for key, value in self.__dict__.iteritems()]
26501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26502 
 
26503 
  def __eq__(self, other):
26504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26505 
 
26506 
  def __ne__(self, other):
26507 
    return not (self == other)
26508 
 
26509 
class activateRechargeTxn_args:
26510 
  """
26511 
  Attributes:
6031 rajveer 26512 
   - rechargeOrderId
6000 mandeep.dh 26513 
  """
26514 
 
26515 
  thrift_spec = (
26516 
    None, # 0
6031 rajveer 26517 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26518 
  )
26519 
 
6031 rajveer 26520 
  def __init__(self, rechargeOrderId=None,):
26521 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26522 
 
26523 
  def read(self, iprot):
26524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26526 
      return
26527 
    iprot.readStructBegin()
26528 
    while True:
26529 
      (fname, ftype, fid) = iprot.readFieldBegin()
26530 
      if ftype == TType.STOP:
26531 
        break
26532 
      if fid == 1:
6031 rajveer 26533 
        if ftype == TType.I64:
26534 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26535 
        else:
26536 
          iprot.skip(ftype)
26537 
      else:
26538 
        iprot.skip(ftype)
26539 
      iprot.readFieldEnd()
26540 
    iprot.readStructEnd()
26541 
 
26542 
  def write(self, oprot):
26543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26545 
      return
26546 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26547 
    if self.rechargeOrderId is not None:
26548 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26549 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26550 
      oprot.writeFieldEnd()
26551 
    oprot.writeFieldStop()
26552 
    oprot.writeStructEnd()
26553 
 
26554 
  def validate(self):
26555 
    return
26556 
 
26557 
 
26558 
  def __repr__(self):
26559 
    L = ['%s=%r' % (key, value)
26560 
      for key, value in self.__dict__.iteritems()]
26561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26562 
 
26563 
  def __eq__(self, other):
26564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26565 
 
26566 
  def __ne__(self, other):
26567 
    return not (self == other)
26568 
 
26569 
class activateRechargeTxn_result:
26570 
  """
26571 
  Attributes:
26572 
   - success
26573 
   - ex
26574 
  """
26575 
 
26576 
  thrift_spec = (
6031 rajveer 26577 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26579 
  )
26580 
 
26581 
  def __init__(self, success=None, ex=None,):
26582 
    self.success = success
26583 
    self.ex = ex
26584 
 
26585 
  def read(self, iprot):
26586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26588 
      return
26589 
    iprot.readStructBegin()
26590 
    while True:
26591 
      (fname, ftype, fid) = iprot.readFieldBegin()
26592 
      if ftype == TType.STOP:
26593 
        break
26594 
      if fid == 0:
6031 rajveer 26595 
        if ftype == TType.BOOL:
26596 
          self.success = iprot.readBool();
6000 mandeep.dh 26597 
        else:
26598 
          iprot.skip(ftype)
26599 
      elif fid == 1:
26600 
        if ftype == TType.STRUCT:
26601 
          self.ex = TransactionServiceException()
26602 
          self.ex.read(iprot)
26603 
        else:
26604 
          iprot.skip(ftype)
26605 
      else:
26606 
        iprot.skip(ftype)
26607 
      iprot.readFieldEnd()
26608 
    iprot.readStructEnd()
26609 
 
26610 
  def write(self, oprot):
26611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26613 
      return
26614 
    oprot.writeStructBegin('activateRechargeTxn_result')
26615 
    if self.success is not None:
6031 rajveer 26616 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26617 
      oprot.writeBool(self.success)
6000 mandeep.dh 26618 
      oprot.writeFieldEnd()
26619 
    if self.ex is not None:
26620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26621 
      self.ex.write(oprot)
26622 
      oprot.writeFieldEnd()
26623 
    oprot.writeFieldStop()
26624 
    oprot.writeStructEnd()
26625 
 
26626 
  def validate(self):
26627 
    return
26628 
 
26629 
 
26630 
  def __repr__(self):
26631 
    L = ['%s=%r' % (key, value)
26632 
      for key, value in self.__dict__.iteritems()]
26633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26634 
 
26635 
  def __eq__(self, other):
26636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26637 
 
26638 
  def __ne__(self, other):
26639 
    return not (self == other)
26640 
 
6031 rajveer 26641 
class getUserWallet_args:
6000 mandeep.dh 26642 
  """
26643 
  Attributes:
6031 rajveer 26644 
   - userId
6000 mandeep.dh 26645 
  """
26646 
 
26647 
  thrift_spec = (
26648 
    None, # 0
6031 rajveer 26649 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26650 
  )
26651 
 
6031 rajveer 26652 
  def __init__(self, userId=None,):
26653 
    self.userId = userId
6000 mandeep.dh 26654 
 
26655 
  def read(self, iprot):
26656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26658 
      return
26659 
    iprot.readStructBegin()
26660 
    while True:
26661 
      (fname, ftype, fid) = iprot.readFieldBegin()
26662 
      if ftype == TType.STOP:
26663 
        break
26664 
      if fid == 1:
26665 
        if ftype == TType.I64:
6031 rajveer 26666 
          self.userId = iprot.readI64();
6000 mandeep.dh 26667 
        else:
26668 
          iprot.skip(ftype)
26669 
      else:
26670 
        iprot.skip(ftype)
26671 
      iprot.readFieldEnd()
26672 
    iprot.readStructEnd()
26673 
 
26674 
  def write(self, oprot):
26675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26677 
      return
6031 rajveer 26678 
    oprot.writeStructBegin('getUserWallet_args')
26679 
    if self.userId is not None:
26680 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26681 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26682 
      oprot.writeFieldEnd()
26683 
    oprot.writeFieldStop()
26684 
    oprot.writeStructEnd()
26685 
 
26686 
  def validate(self):
26687 
    return
26688 
 
26689 
 
26690 
  def __repr__(self):
26691 
    L = ['%s=%r' % (key, value)
26692 
      for key, value in self.__dict__.iteritems()]
26693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26694 
 
26695 
  def __eq__(self, other):
26696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26697 
 
26698 
  def __ne__(self, other):
26699 
    return not (self == other)
26700 
 
6031 rajveer 26701 
class getUserWallet_result:
6000 mandeep.dh 26702 
  """
26703 
  Attributes:
26704 
   - success
26705 
  """
26706 
 
26707 
  thrift_spec = (
6031 rajveer 26708 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 26709 
  )
26710 
 
26711 
  def __init__(self, success=None,):
26712 
    self.success = success
26713 
 
26714 
  def read(self, iprot):
26715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26717 
      return
26718 
    iprot.readStructBegin()
26719 
    while True:
26720 
      (fname, ftype, fid) = iprot.readFieldBegin()
26721 
      if ftype == TType.STOP:
26722 
        break
26723 
      if fid == 0:
6031 rajveer 26724 
        if ftype == TType.STRUCT:
26725 
          self.success = UserWallet()
26726 
          self.success.read(iprot)
6000 mandeep.dh 26727 
        else:
26728 
          iprot.skip(ftype)
26729 
      else:
26730 
        iprot.skip(ftype)
26731 
      iprot.readFieldEnd()
26732 
    iprot.readStructEnd()
26733 
 
26734 
  def write(self, oprot):
26735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26737 
      return
6031 rajveer 26738 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 26739 
    if self.success is not None:
6031 rajveer 26740 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26741 
      self.success.write(oprot)
6000 mandeep.dh 26742 
      oprot.writeFieldEnd()
26743 
    oprot.writeFieldStop()
26744 
    oprot.writeStructEnd()
26745 
 
26746 
  def validate(self):
26747 
    return
26748 
 
26749 
 
26750 
  def __repr__(self):
26751 
    L = ['%s=%r' % (key, value)
26752 
      for key, value in self.__dict__.iteritems()]
26753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26754 
 
26755 
  def __eq__(self, other):
26756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26757 
 
26758 
  def __ne__(self, other):
26759 
    return not (self == other)
26760 
 
6031 rajveer 26761 
class getUserWalletHistory_args:
6000 mandeep.dh 26762 
  """
26763 
  Attributes:
6031 rajveer 26764 
   - userId
6000 mandeep.dh 26765 
  """
26766 
 
26767 
  thrift_spec = (
26768 
    None, # 0
6031 rajveer 26769 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26770 
  )
26771 
 
6031 rajveer 26772 
  def __init__(self, userId=None,):
26773 
    self.userId = userId
6000 mandeep.dh 26774 
 
26775 
  def read(self, iprot):
26776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26778 
      return
26779 
    iprot.readStructBegin()
26780 
    while True:
26781 
      (fname, ftype, fid) = iprot.readFieldBegin()
26782 
      if ftype == TType.STOP:
26783 
        break
26784 
      if fid == 1:
26785 
        if ftype == TType.I64:
6031 rajveer 26786 
          self.userId = iprot.readI64();
6000 mandeep.dh 26787 
        else:
26788 
          iprot.skip(ftype)
26789 
      else:
26790 
        iprot.skip(ftype)
26791 
      iprot.readFieldEnd()
26792 
    iprot.readStructEnd()
26793 
 
26794 
  def write(self, oprot):
26795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26797 
      return
6031 rajveer 26798 
    oprot.writeStructBegin('getUserWalletHistory_args')
26799 
    if self.userId is not None:
26800 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26801 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26802 
      oprot.writeFieldEnd()
26803 
    oprot.writeFieldStop()
26804 
    oprot.writeStructEnd()
26805 
 
26806 
  def validate(self):
26807 
    return
26808 
 
26809 
 
26810 
  def __repr__(self):
26811 
    L = ['%s=%r' % (key, value)
26812 
      for key, value in self.__dict__.iteritems()]
26813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26814 
 
26815 
  def __eq__(self, other):
26816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26817 
 
26818 
  def __ne__(self, other):
26819 
    return not (self == other)
26820 
 
6031 rajveer 26821 
class getUserWalletHistory_result:
6000 mandeep.dh 26822 
  """
26823 
  Attributes:
26824 
   - success
26825 
  """
26826 
 
26827 
  thrift_spec = (
6031 rajveer 26828 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 26829 
  )
26830 
 
26831 
  def __init__(self, success=None,):
26832 
    self.success = success
26833 
 
26834 
  def read(self, iprot):
26835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26837 
      return
26838 
    iprot.readStructBegin()
26839 
    while True:
26840 
      (fname, ftype, fid) = iprot.readFieldBegin()
26841 
      if ftype == TType.STOP:
26842 
        break
26843 
      if fid == 0:
26844 
        if ftype == TType.LIST:
26845 
          self.success = []
6031 rajveer 26846 
          (_etype623, _size620) = iprot.readListBegin()
26847 
          for _i624 in xrange(_size620):
26848 
            _elem625 = UserWalletHistory()
26849 
            _elem625.read(iprot)
26850 
            self.success.append(_elem625)
6000 mandeep.dh 26851 
          iprot.readListEnd()
26852 
        else:
26853 
          iprot.skip(ftype)
26854 
      else:
26855 
        iprot.skip(ftype)
26856 
      iprot.readFieldEnd()
26857 
    iprot.readStructEnd()
26858 
 
26859 
  def write(self, oprot):
26860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26862 
      return
6031 rajveer 26863 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 26864 
    if self.success is not None:
26865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 26867 
      for iter626 in self.success:
26868 
        iter626.write(oprot)
6000 mandeep.dh 26869 
      oprot.writeListEnd()
26870 
      oprot.writeFieldEnd()
26871 
    oprot.writeFieldStop()
26872 
    oprot.writeStructEnd()
26873 
 
26874 
  def validate(self):
26875 
    return
26876 
 
26877 
 
26878 
  def __repr__(self):
26879 
    L = ['%s=%r' % (key, value)
26880 
      for key, value in self.__dict__.iteritems()]
26881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26882 
 
26883 
  def __eq__(self, other):
26884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26885 
 
26886 
  def __ne__(self, other):
26887 
    return not (self == other)