Subversion Repositories SmartDukaan

Rev

Rev 6031 | Rev 6049 | 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 
 
6048 rajveer 1340 
  def getServiceProviders(self, rechargeType):
1341 
    """
1342 
    Parameters:
1343 
     - rechargeType
1344 
    """
1345 
    pass
6000 mandeep.dh 1346 
 
6048 rajveer 1347 
  def getServiceProviderForDevice(self, deviceNumber):
1348 
    """
1349 
    Parameters:
1350 
     - deviceNumber
1351 
    """
1352 
    pass
1353 
 
1354 
 
3376 rajveer 1355 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1356 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1357 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1358 
 
1359 
  def createTransaction(self, transaction):
1360 
    """
1361 
    Parameters:
1362 
     - transaction
1363 
    """
1364 
    self.send_createTransaction(transaction)
132 ashish 1365 
    return self.recv_createTransaction()
94 ashish 1366 
 
1367 
  def send_createTransaction(self, transaction):
1368 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1369 
    args = createTransaction_args()
1370 
    args.transaction = transaction
1371 
    args.write(self._oprot)
1372 
    self._oprot.writeMessageEnd()
1373 
    self._oprot.trans.flush()
1374 
 
1375 
  def recv_createTransaction(self, ):
1376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1377 
    if mtype == TMessageType.EXCEPTION:
1378 
      x = TApplicationException()
1379 
      x.read(self._iprot)
1380 
      self._iprot.readMessageEnd()
1381 
      raise x
1382 
    result = createTransaction_result()
1383 
    result.read(self._iprot)
1384 
    self._iprot.readMessageEnd()
3431 rajveer 1385 
    if result.success is not None:
132 ashish 1386 
      return result.success
3431 rajveer 1387 
    if result.ex is not None:
94 ashish 1388 
      raise result.ex
132 ashish 1389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1390 
 
1391 
  def getTransaction(self, id):
1392 
    """
1393 
    Parameters:
1394 
     - id
1395 
    """
1396 
    self.send_getTransaction(id)
1397 
    return self.recv_getTransaction()
1398 
 
1399 
  def send_getTransaction(self, id):
1400 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1401 
    args = getTransaction_args()
1402 
    args.id = id
1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
1407 
  def recv_getTransaction(self, ):
1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
1414 
    result = getTransaction_result()
1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
3431 rajveer 1417 
    if result.success is not None:
94 ashish 1418 
      return result.success
3431 rajveer 1419 
    if result.ex is not None:
94 ashish 1420 
      raise result.ex
1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1422 
 
1423 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1424 
    """
1425 
    Parameters:
1426 
     - customerId
1427 
     - from_date
1428 
     - to_date
1429 
     - status
1430 
    """
1431 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1432 
    return self.recv_getTransactionsForCustomer()
1433 
 
1434 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1435 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1436 
    args = getTransactionsForCustomer_args()
1437 
    args.customerId = customerId
1438 
    args.from_date = from_date
1439 
    args.to_date = to_date
1440 
    args.status = status
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getTransactionsForCustomer(self, ):
1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
1452 
    result = getTransactionsForCustomer_result()
1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
3431 rajveer 1455 
    if result.success is not None:
94 ashish 1456 
      return result.success
3431 rajveer 1457 
    if result.ex is not None:
94 ashish 1458 
      raise result.ex
1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1460 
 
132 ashish 1461 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1462 
    """
1463 
    Parameters:
1464 
     - shoppingCartId
1465 
    """
1466 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1467 
    return self.recv_getTransactionsForShoppingCartId()
1468 
 
1469 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1470 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1471 
    args = getTransactionsForShoppingCartId_args()
1472 
    args.shoppingCartId = shoppingCartId
1473 
    args.write(self._oprot)
1474 
    self._oprot.writeMessageEnd()
1475 
    self._oprot.trans.flush()
1476 
 
1477 
  def recv_getTransactionsForShoppingCartId(self, ):
1478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1479 
    if mtype == TMessageType.EXCEPTION:
1480 
      x = TApplicationException()
1481 
      x.read(self._iprot)
1482 
      self._iprot.readMessageEnd()
1483 
      raise x
1484 
    result = getTransactionsForShoppingCartId_result()
1485 
    result.read(self._iprot)
1486 
    self._iprot.readMessageEnd()
3431 rajveer 1487 
    if result.success is not None:
132 ashish 1488 
      return result.success
3431 rajveer 1489 
    if result.ex is not None:
132 ashish 1490 
      raise result.ex
1491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1492 
 
94 ashish 1493 
  def getTransactionStatus(self, transactionId):
1494 
    """
1495 
    Parameters:
1496 
     - transactionId
1497 
    """
1498 
    self.send_getTransactionStatus(transactionId)
1499 
    return self.recv_getTransactionStatus()
1500 
 
1501 
  def send_getTransactionStatus(self, transactionId):
1502 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1503 
    args = getTransactionStatus_args()
1504 
    args.transactionId = transactionId
1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
1509 
  def recv_getTransactionStatus(self, ):
1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
1516 
    result = getTransactionStatus_result()
1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
94 ashish 1520 
      return result.success
3431 rajveer 1521 
    if result.ex is not None:
94 ashish 1522 
      raise result.ex
1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1524 
 
5527 anupam.sin 1525 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1526 
    """
1527 
    Parameters:
1528 
     - transactionId
1529 
     - status
1530 
     - description
5527 anupam.sin 1531 
     - pickUp
1532 
     - orderType
94 ashish 1533 
    """
5527 anupam.sin 1534 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1535 
    return self.recv_changeTransactionStatus()
1536 
 
5527 anupam.sin 1537 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1538 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1539 
    args = changeTransactionStatus_args()
1540 
    args.transactionId = transactionId
1541 
    args.status = status
1542 
    args.description = description
5527 anupam.sin 1543 
    args.pickUp = pickUp
1544 
    args.orderType = orderType
94 ashish 1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_changeTransactionStatus(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = changeTransactionStatus_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
3431 rajveer 1559 
    if result.success is not None:
94 ashish 1560 
      return result.success
3431 rajveer 1561 
    if result.ex is not None:
94 ashish 1562 
      raise result.ex
1563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1564 
 
1398 varun.gupt 1565 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1566 
    """
1567 
    Parameters:
1568 
     - transactionId
1569 
    """
1398 varun.gupt 1570 
    self.send_enqueueTransactionInfoEmail(transactionId)
1571 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1572 
 
1398 varun.gupt 1573 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1574 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1575 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1576 
    args.transactionId = transactionId
1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
1398 varun.gupt 1581 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
1398 varun.gupt 1588 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
3431 rajveer 1591 
    if result.success is not None:
1382 varun.gupt 1592 
      return result.success
3431 rajveer 1593 
    if result.ex is not None:
1382 varun.gupt 1594 
      raise result.ex
1398 varun.gupt 1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1596 
 
4801 anupam.sin 1597 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1598 
    """
1599 
    Parameters:
4801 anupam.sin 1600 
     - statuses
483 rajveer 1601 
     - from_date
1602 
     - to_date
1603 
     - warehouse_id
94 ashish 1604 
    """
4801 anupam.sin 1605 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1606 
    return self.recv_getAllOrders()
94 ashish 1607 
 
4801 anupam.sin 1608 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1609 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1610 
    args = getAllOrders_args()
4801 anupam.sin 1611 
    args.statuses = statuses
483 rajveer 1612 
    args.from_date = from_date
1613 
    args.to_date = to_date
1614 
    args.warehouse_id = warehouse_id
94 ashish 1615 
    args.write(self._oprot)
1616 
    self._oprot.writeMessageEnd()
1617 
    self._oprot.trans.flush()
1618 
 
483 rajveer 1619 
  def recv_getAllOrders(self, ):
94 ashish 1620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1621 
    if mtype == TMessageType.EXCEPTION:
1622 
      x = TApplicationException()
1623 
      x.read(self._iprot)
1624 
      self._iprot.readMessageEnd()
1625 
      raise x
483 rajveer 1626 
    result = getAllOrders_result()
94 ashish 1627 
    result.read(self._iprot)
1628 
    self._iprot.readMessageEnd()
3431 rajveer 1629 
    if result.success is not None:
94 ashish 1630 
      return result.success
3431 rajveer 1631 
    if result.ex is not None:
94 ashish 1632 
      raise result.ex
483 rajveer 1633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1634 
 
4133 chandransh 1635 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1636 
    """
1637 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1638 
    Pass the status as null and the limit as 0 to ignore them.
1639 
 
1640 
    Parameters:
1641 
     - statuses
1642 
     - offset
1643 
     - limit
1644 
     - warehouse_id
1645 
    """
1646 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1647 
    return self.recv_getOrdersInBatch()
1648 
 
1649 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1650 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1651 
    args = getOrdersInBatch_args()
1652 
    args.statuses = statuses
1653 
    args.offset = offset
1654 
    args.limit = limit
1655 
    args.warehouse_id = warehouse_id
1656 
    args.write(self._oprot)
1657 
    self._oprot.writeMessageEnd()
1658 
    self._oprot.trans.flush()
1659 
 
1660 
  def recv_getOrdersInBatch(self, ):
1661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1662 
    if mtype == TMessageType.EXCEPTION:
1663 
      x = TApplicationException()
1664 
      x.read(self._iprot)
1665 
      self._iprot.readMessageEnd()
1666 
      raise x
1667 
    result = getOrdersInBatch_result()
1668 
    result.read(self._iprot)
1669 
    self._iprot.readMessageEnd()
1670 
    if result.success is not None:
1671 
      return result.success
1672 
    if result.ex is not None:
1673 
      raise result.ex
1674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1675 
 
1676 
  def getOrderCount(self, statuses, warehouseId):
1677 
    """
1678 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1679 
 
1680 
    Parameters:
1681 
     - statuses
1682 
     - warehouseId
1683 
    """
1684 
    self.send_getOrderCount(statuses, warehouseId)
1685 
    return self.recv_getOrderCount()
1686 
 
1687 
  def send_getOrderCount(self, statuses, warehouseId):
1688 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1689 
    args = getOrderCount_args()
1690 
    args.statuses = statuses
1691 
    args.warehouseId = warehouseId
1692 
    args.write(self._oprot)
1693 
    self._oprot.writeMessageEnd()
1694 
    self._oprot.trans.flush()
1695 
 
1696 
  def recv_getOrderCount(self, ):
1697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1698 
    if mtype == TMessageType.EXCEPTION:
1699 
      x = TApplicationException()
1700 
      x.read(self._iprot)
1701 
      self._iprot.readMessageEnd()
1702 
      raise x
1703 
    result = getOrderCount_result()
1704 
    result.read(self._iprot)
1705 
    self._iprot.readMessageEnd()
1706 
    if result.success is not None:
1707 
      return result.success
1708 
    if result.ex is not None:
1709 
      raise result.ex
1710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1711 
 
999 varun.gupt 1712 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1713 
    """
1132 chandransh 1714 
    Returns orders within a range of their billing dates
3431 rajveer 1715 
 
999 varun.gupt 1716 
    Parameters:
1717 
     - status
1718 
     - start_billing_date
1719 
     - end_billing_date
1720 
     - warehouse_id
1721 
    """
1722 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1723 
    return self.recv_getOrdersByBillingDate()
1724 
 
1725 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1726 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1727 
    args = getOrdersByBillingDate_args()
1728 
    args.status = status
1729 
    args.start_billing_date = start_billing_date
1730 
    args.end_billing_date = end_billing_date
1731 
    args.warehouse_id = warehouse_id
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getOrdersByBillingDate(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getOrdersByBillingDate_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
3431 rajveer 1746 
    if result.success is not None:
999 varun.gupt 1747 
      return result.success
3431 rajveer 1748 
    if result.ex is not None:
999 varun.gupt 1749 
      raise result.ex
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1751 
 
3451 chandransh 1752 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1753 
    """
1754 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1755 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1756 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1757 
 
3427 chandransh 1758 
    Parameters:
1759 
     - fromShippingDate
1760 
     - toShippingDate
1761 
     - providerId
1762 
     - warehouseId
3451 chandransh 1763 
     - cod
3427 chandransh 1764 
    """
3451 chandransh 1765 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1766 
    return self.recv_getOrdersByShippingDate()
1767 
 
3451 chandransh 1768 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1769 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1770 
    args = getOrdersByShippingDate_args()
1771 
    args.fromShippingDate = fromShippingDate
1772 
    args.toShippingDate = toShippingDate
1773 
    args.providerId = providerId
1774 
    args.warehouseId = warehouseId
3451 chandransh 1775 
    args.cod = cod
3427 chandransh 1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_getOrdersByShippingDate(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = getOrdersByShippingDate_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
3431 rajveer 1790 
    if result.success is not None:
3427 chandransh 1791 
      return result.success
3431 rajveer 1792 
    if result.ex is not None:
3427 chandransh 1793 
      raise result.ex
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1795 
 
1382 varun.gupt 1796 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1797 
    """
1798 
    Returns order ids for orders which can be returned
3431 rajveer 1799 
 
1382 varun.gupt 1800 
    Parameters:
1801 
     - customer_id
1802 
     - limit
1803 
    """
1804 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1805 
    return self.recv_getReturnableOrdersForCustomer()
1806 
 
1807 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1808 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1809 
    args = getReturnableOrdersForCustomer_args()
1810 
    args.customer_id = customer_id
1811 
    args.limit = limit
1812 
    args.write(self._oprot)
1813 
    self._oprot.writeMessageEnd()
1814 
    self._oprot.trans.flush()
1815 
 
1816 
  def recv_getReturnableOrdersForCustomer(self, ):
1817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1818 
    if mtype == TMessageType.EXCEPTION:
1819 
      x = TApplicationException()
1820 
      x.read(self._iprot)
1821 
      self._iprot.readMessageEnd()
1822 
      raise x
1823 
    result = getReturnableOrdersForCustomer_result()
1824 
    result.read(self._iprot)
1825 
    self._iprot.readMessageEnd()
3431 rajveer 1826 
    if result.success is not None:
1382 varun.gupt 1827 
      return result.success
3431 rajveer 1828 
    if result.ex is not None:
1382 varun.gupt 1829 
      raise result.ex
1830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1831 
 
1832 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1833 
    """
1834 
    Returns order ids for orders which can be cancelled
3431 rajveer 1835 
 
1382 varun.gupt 1836 
    Parameters:
1837 
     - customer_id
1838 
     - limit
1839 
    """
1840 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1841 
    return self.recv_getCancellableOrdersForCustomer()
1842 
 
1843 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1844 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1845 
    args = getCancellableOrdersForCustomer_args()
1846 
    args.customer_id = customer_id
1847 
    args.limit = limit
1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getCancellableOrdersForCustomer(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getCancellableOrdersForCustomer_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
3431 rajveer 1862 
    if result.success is not None:
1382 varun.gupt 1863 
      return result.success
3431 rajveer 1864 
    if result.ex is not None:
1382 varun.gupt 1865 
      raise result.ex
1866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1867 
 
483 rajveer 1868 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1869 
    """
1870 
    Parameters:
483 rajveer 1871 
     - orderId
1872 
     - status
1873 
     - description
94 ashish 1874 
    """
483 rajveer 1875 
    self.send_changeOrderStatus(orderId, status, description)
1876 
    return self.recv_changeOrderStatus()
94 ashish 1877 
 
483 rajveer 1878 
  def send_changeOrderStatus(self, orderId, status, description):
1879 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1880 
    args = changeOrderStatus_args()
1881 
    args.orderId = orderId
1882 
    args.status = status
1883 
    args.description = description
94 ashish 1884 
    args.write(self._oprot)
1885 
    self._oprot.writeMessageEnd()
1886 
    self._oprot.trans.flush()
1887 
 
483 rajveer 1888 
  def recv_changeOrderStatus(self, ):
94 ashish 1889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1890 
    if mtype == TMessageType.EXCEPTION:
1891 
      x = TApplicationException()
1892 
      x.read(self._iprot)
1893 
      self._iprot.readMessageEnd()
1894 
      raise x
483 rajveer 1895 
    result = changeOrderStatus_result()
94 ashish 1896 
    result.read(self._iprot)
1897 
    self._iprot.readMessageEnd()
3431 rajveer 1898 
    if result.success is not None:
94 ashish 1899 
      return result.success
3431 rajveer 1900 
    if result.ex is not None:
94 ashish 1901 
      raise result.ex
483 rajveer 1902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1903 
 
1528 ankur.sing 1904 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1905 
    """
1528 ankur.sing 1906 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1907 
    only user who owns the transaction can view its order details.
3431 rajveer 1908 
 
94 ashish 1909 
    Parameters:
1910 
     - transactionId
1528 ankur.sing 1911 
     - customerId
94 ashish 1912 
    """
1528 ankur.sing 1913 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1914 
    return self.recv_getOrdersForTransaction()
94 ashish 1915 
 
1528 ankur.sing 1916 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1917 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1918 
    args = getOrdersForTransaction_args()
94 ashish 1919 
    args.transactionId = transactionId
1528 ankur.sing 1920 
    args.customerId = customerId
94 ashish 1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
483 rajveer 1925 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
483 rajveer 1932 
    result = getOrdersForTransaction_result()
94 ashish 1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
3431 rajveer 1935 
    if result.success is not None:
94 ashish 1936 
      return result.success
3431 rajveer 1937 
    if result.ex is not None:
94 ashish 1938 
      raise result.ex
483 rajveer 1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1940 
 
3014 chandransh 1941 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1942 
    """
3014 chandransh 1943 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1944 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1945 
 
94 ashish 1946 
    Parameters:
483 rajveer 1947 
     - customerId
1948 
     - from_date
1949 
     - to_date
3014 chandransh 1950 
     - statuses
94 ashish 1951 
    """
3014 chandransh 1952 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1953 
    return self.recv_getOrdersForCustomer()
94 ashish 1954 
 
3014 chandransh 1955 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1956 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1957 
    args = getOrdersForCustomer_args()
1958 
    args.customerId = customerId
1959 
    args.from_date = from_date
1960 
    args.to_date = to_date
3014 chandransh 1961 
    args.statuses = statuses
94 ashish 1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
483 rajveer 1966 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
483 rajveer 1973 
    result = getOrdersForCustomer_result()
94 ashish 1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
3431 rajveer 1976 
    if result.success is not None:
94 ashish 1977 
      return result.success
3431 rajveer 1978 
    if result.ex is not None:
94 ashish 1979 
      raise result.ex
483 rajveer 1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1981 
 
483 rajveer 1982 
  def createOrder(self, order):
94 ashish 1983 
    """
1984 
    Parameters:
483 rajveer 1985 
     - order
94 ashish 1986 
    """
483 rajveer 1987 
    self.send_createOrder(order)
1988 
    return self.recv_createOrder()
94 ashish 1989 
 
483 rajveer 1990 
  def send_createOrder(self, order):
1991 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1992 
    args = createOrder_args()
1993 
    args.order = order
94 ashish 1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
483 rajveer 1998 
  def recv_createOrder(self, ):
94 ashish 1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
483 rajveer 2005 
    result = createOrder_result()
94 ashish 2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
3431 rajveer 2008 
    if result.success is not None:
94 ashish 2009 
      return result.success
3431 rajveer 2010 
    if result.ex is not None:
94 ashish 2011 
      raise result.ex
483 rajveer 2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2013 
 
483 rajveer 2014 
  def getOrder(self, id):
94 ashish 2015 
    """
2016 
    Parameters:
483 rajveer 2017 
     - id
94 ashish 2018 
    """
483 rajveer 2019 
    self.send_getOrder(id)
2020 
    return self.recv_getOrder()
94 ashish 2021 
 
483 rajveer 2022 
  def send_getOrder(self, id):
2023 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2024 
    args = getOrder_args()
2025 
    args.id = id
94 ashish 2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
483 rajveer 2030 
  def recv_getOrder(self, ):
94 ashish 2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
483 rajveer 2037 
    result = getOrder_result()
94 ashish 2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
3431 rajveer 2040 
    if result.success is not None:
94 ashish 2041 
      return result.success
3431 rajveer 2042 
    if result.ex is not None:
94 ashish 2043 
      raise result.ex
483 rajveer 2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2045 
 
483 rajveer 2046 
  def getLineItemsForOrder(self, orderId):
94 ashish 2047 
    """
2048 
    Parameters:
483 rajveer 2049 
     - orderId
94 ashish 2050 
    """
483 rajveer 2051 
    self.send_getLineItemsForOrder(orderId)
2052 
    return self.recv_getLineItemsForOrder()
94 ashish 2053 
 
483 rajveer 2054 
  def send_getLineItemsForOrder(self, orderId):
2055 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2056 
    args = getLineItemsForOrder_args()
2057 
    args.orderId = orderId
94 ashish 2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
483 rajveer 2062 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
483 rajveer 2069 
    result = getLineItemsForOrder_result()
94 ashish 2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
3431 rajveer 2072 
    if result.success is not None:
94 ashish 2073 
      return result.success
3431 rajveer 2074 
    if result.ex is not None:
94 ashish 2075 
      raise result.ex
483 rajveer 2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2077 
 
4999 phani.kuma 2078 
  def getOrderList(self, order_ids):
2079 
    """
2080 
    Parameters:
2081 
     - order_ids
2082 
    """
2083 
    self.send_getOrderList(order_ids)
2084 
    return self.recv_getOrderList()
2085 
 
2086 
  def send_getOrderList(self, order_ids):
2087 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2088 
    args = getOrderList_args()
2089 
    args.order_ids = order_ids
2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
2094 
  def recv_getOrderList(self, ):
2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
2101 
    result = getOrderList_result()
2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
2104 
    if result.success is not None:
2105 
      return result.success
2106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2107 
 
5386 phani.kuma 2108 
  def getOrderListForVendor(self, order_ids, vendorId):
2109 
    """
2110 
    Parameters:
2111 
     - order_ids
2112 
     - vendorId
2113 
    """
2114 
    self.send_getOrderListForVendor(order_ids, vendorId)
2115 
    return self.recv_getOrderListForVendor()
2116 
 
2117 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2118 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2119 
    args = getOrderListForVendor_args()
2120 
    args.order_ids = order_ids
2121 
    args.vendorId = vendorId
2122 
    args.write(self._oprot)
2123 
    self._oprot.writeMessageEnd()
2124 
    self._oprot.trans.flush()
2125 
 
2126 
  def recv_getOrderListForVendor(self, ):
2127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2128 
    if mtype == TMessageType.EXCEPTION:
2129 
      x = TApplicationException()
2130 
      x.read(self._iprot)
2131 
      self._iprot.readMessageEnd()
2132 
      raise x
2133 
    result = getOrderListForVendor_result()
2134 
    result.read(self._iprot)
2135 
    self._iprot.readMessageEnd()
2136 
    if result.success is not None:
2137 
      return result.success
2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2139 
 
1528 ankur.sing 2140 
  def getOrderForCustomer(self, orderId, customerId):
2141 
    """
2142 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2143 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2144 
 
1528 ankur.sing 2145 
    Parameters:
2146 
     - orderId
2147 
     - customerId
2148 
    """
2149 
    self.send_getOrderForCustomer(orderId, customerId)
2150 
    return self.recv_getOrderForCustomer()
2151 
 
2152 
  def send_getOrderForCustomer(self, orderId, customerId):
2153 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2154 
    args = getOrderForCustomer_args()
2155 
    args.orderId = orderId
2156 
    args.customerId = customerId
2157 
    args.write(self._oprot)
2158 
    self._oprot.writeMessageEnd()
2159 
    self._oprot.trans.flush()
2160 
 
2161 
  def recv_getOrderForCustomer(self, ):
2162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2163 
    if mtype == TMessageType.EXCEPTION:
2164 
      x = TApplicationException()
2165 
      x.read(self._iprot)
2166 
      self._iprot.readMessageEnd()
2167 
      raise x
2168 
    result = getOrderForCustomer_result()
2169 
    result.read(self._iprot)
2170 
    self._iprot.readMessageEnd()
3431 rajveer 2171 
    if result.success is not None:
1528 ankur.sing 2172 
      return result.success
3431 rajveer 2173 
    if result.ex is not None:
1528 ankur.sing 2174 
      raise result.ex
2175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2176 
 
4444 rajveer 2177 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2178 
    """
2179 
    Parameters:
4394 rajveer 2180 
     - type
4444 rajveer 2181 
     - warehouseId
4394 rajveer 2182 
     - status
2183 
     - timestamp
3064 chandransh 2184 
    """
4444 rajveer 2185 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2186 
    return self.recv_getAlerts()
2187 
 
4444 rajveer 2188 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2189 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2190 
    args = getAlerts_args()
4394 rajveer 2191 
    args.type = type
4444 rajveer 2192 
    args.warehouseId = warehouseId
4394 rajveer 2193 
    args.status = status
2194 
    args.timestamp = timestamp
3064 chandransh 2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
2199 
  def recv_getAlerts(self, ):
2200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2201 
    if mtype == TMessageType.EXCEPTION:
2202 
      x = TApplicationException()
2203 
      x.read(self._iprot)
2204 
      self._iprot.readMessageEnd()
2205 
      raise x
2206 
    result = getAlerts_result()
2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
3431 rajveer 2209 
    if result.success is not None:
3064 chandransh 2210 
      return result.success
2211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2212 
 
4444 rajveer 2213 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2214 
    """
2215 
    Parameters:
2216 
     - type
4444 rajveer 2217 
     - warehouseId
4394 rajveer 2218 
     - description
3064 chandransh 2219 
    """
4444 rajveer 2220 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2221 
    self.recv_addAlert()
3064 chandransh 2222 
 
4444 rajveer 2223 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2224 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2225 
    args = addAlert_args()
3064 chandransh 2226 
    args.type = type
4444 rajveer 2227 
    args.warehouseId = warehouseId
4394 rajveer 2228 
    args.description = description
3064 chandransh 2229 
    args.write(self._oprot)
2230 
    self._oprot.writeMessageEnd()
2231 
    self._oprot.trans.flush()
2232 
 
4394 rajveer 2233 
  def recv_addAlert(self, ):
3064 chandransh 2234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2235 
    if mtype == TMessageType.EXCEPTION:
2236 
      x = TApplicationException()
2237 
      x.read(self._iprot)
2238 
      self._iprot.readMessageEnd()
2239 
      raise x
4394 rajveer 2240 
    result = addAlert_result()
3064 chandransh 2241 
    result.read(self._iprot)
2242 
    self._iprot.readMessageEnd()
2243 
    return
2244 
 
4444 rajveer 2245 
  def markAlertsAsSeen(self, warehouseId):
2246 
    """
2247 
    Parameters:
2248 
     - warehouseId
2249 
    """
2250 
    self.send_markAlertsAsSeen(warehouseId)
2251 
    self.recv_markAlertsAsSeen()
2252 
 
2253 
  def send_markAlertsAsSeen(self, warehouseId):
2254 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2255 
    args = markAlertsAsSeen_args()
2256 
    args.warehouseId = warehouseId
2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
2261 
  def recv_markAlertsAsSeen(self, ):
2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
2268 
    result = markAlertsAsSeen_result()
2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
2271 
    return
2272 
 
3064 chandransh 2273 
  def getValidOrderCount(self, ):
2274 
    """
2275 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2276 
    """
2277 
    self.send_getValidOrderCount()
2278 
    return self.recv_getValidOrderCount()
2279 
 
2280 
  def send_getValidOrderCount(self, ):
2281 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2282 
    args = getValidOrderCount_args()
2283 
    args.write(self._oprot)
2284 
    self._oprot.writeMessageEnd()
2285 
    self._oprot.trans.flush()
2286 
 
2287 
  def recv_getValidOrderCount(self, ):
2288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2289 
    if mtype == TMessageType.EXCEPTION:
2290 
      x = TApplicationException()
2291 
      x.read(self._iprot)
2292 
      self._iprot.readMessageEnd()
2293 
      raise x
2294 
    result = getValidOrderCount_result()
2295 
    result.read(self._iprot)
2296 
    self._iprot.readMessageEnd()
3431 rajveer 2297 
    if result.success is not None:
3064 chandransh 2298 
      return result.success
2299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2300 
 
2301 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2302 
    """
2303 
    Returns the number of distinct customers who have done successful transactions
2304 
    """
2305 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2306 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2307 
 
2308 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2309 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2310 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2315 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2322 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.success is not None:
3064 chandransh 2326 
      return result.success
2327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2328 
 
2329 
  def getValidOrdersAmountRange(self, ):
2330 
    """
2331 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2332 
    List contains two values, first minimum amount and second maximum amount.
2333 
    """
2334 
    self.send_getValidOrdersAmountRange()
2335 
    return self.recv_getValidOrdersAmountRange()
2336 
 
2337 
  def send_getValidOrdersAmountRange(self, ):
2338 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2339 
    args = getValidOrdersAmountRange_args()
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_getValidOrdersAmountRange(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = getValidOrdersAmountRange_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
3431 rajveer 2354 
    if result.success is not None:
3064 chandransh 2355 
      return result.success
2356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2357 
 
5874 rajveer 2358 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2359 
    """
2360 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2361 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2362 
 
3064 chandransh 2363 
    Parameters:
2364 
     - limit
5874 rajveer 2365 
     - onlyStore
3064 chandransh 2366 
    """
5874 rajveer 2367 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2368 
    return self.recv_getValidOrders()
2369 
 
5874 rajveer 2370 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2371 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2372 
    args = getValidOrders_args()
2373 
    args.limit = limit
5874 rajveer 2374 
    args.onlyStore = onlyStore
3064 chandransh 2375 
    args.write(self._oprot)
2376 
    self._oprot.writeMessageEnd()
2377 
    self._oprot.trans.flush()
2378 
 
2379 
  def recv_getValidOrders(self, ):
2380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2381 
    if mtype == TMessageType.EXCEPTION:
2382 
      x = TApplicationException()
2383 
      x.read(self._iprot)
2384 
      self._iprot.readMessageEnd()
2385 
      raise x
2386 
    result = getValidOrders_result()
2387 
    result.read(self._iprot)
2388 
    self._iprot.readMessageEnd()
3431 rajveer 2389 
    if result.success is not None:
3064 chandransh 2390 
      return result.success
2391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2392 
 
1220 chandransh 2393 
  def batchOrders(self, warehouseId):
2394 
    """
2395 
    Create a batch of all the pending orders for the given warehouse.
2396 
    The returned list is orderd by created_timestamp.
2397 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2398 
 
1220 chandransh 2399 
    Parameters:
2400 
     - warehouseId
2401 
    """
2402 
    self.send_batchOrders(warehouseId)
2403 
    return self.recv_batchOrders()
2404 
 
2405 
  def send_batchOrders(self, warehouseId):
2406 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2407 
    args = batchOrders_args()
2408 
    args.warehouseId = warehouseId
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_batchOrders(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = batchOrders_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
3431 rajveer 2423 
    if result.success is not None:
1220 chandransh 2424 
      return result.success
3431 rajveer 2425 
    if result.ex is not None:
1220 chandransh 2426 
      raise result.ex
2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2428 
 
1208 chandransh 2429 
  def markOrderAsOutOfStock(self, orderId):
2430 
    """
2431 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2432 
 
1208 chandransh 2433 
    Parameters:
2434 
     - orderId
2435 
    """
2436 
    self.send_markOrderAsOutOfStock(orderId)
2437 
    return self.recv_markOrderAsOutOfStock()
2438 
 
2439 
  def send_markOrderAsOutOfStock(self, orderId):
2440 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2441 
    args = markOrderAsOutOfStock_args()
2442 
    args.orderId = orderId
2443 
    args.write(self._oprot)
2444 
    self._oprot.writeMessageEnd()
2445 
    self._oprot.trans.flush()
2446 
 
2447 
  def recv_markOrderAsOutOfStock(self, ):
2448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2449 
    if mtype == TMessageType.EXCEPTION:
2450 
      x = TApplicationException()
2451 
      x.read(self._iprot)
2452 
      self._iprot.readMessageEnd()
2453 
      raise x
2454 
    result = markOrderAsOutOfStock_result()
2455 
    result.read(self._iprot)
2456 
    self._iprot.readMessageEnd()
3431 rajveer 2457 
    if result.success is not None:
1208 chandransh 2458 
      return result.success
3431 rajveer 2459 
    if result.ex is not None:
1208 chandransh 2460 
      raise result.ex
2461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2462 
 
3064 chandransh 2463 
  def verifyOrder(self, orderId):
759 chandransh 2464 
    """
3064 chandransh 2465 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2466 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2467 
    used for all other orders as well.
2468 
    Throws an exception if no such order exists.
3431 rajveer 2469 
 
759 chandransh 2470 
    Parameters:
3064 chandransh 2471 
     - orderId
759 chandransh 2472 
    """
3064 chandransh 2473 
    self.send_verifyOrder(orderId)
2474 
    return self.recv_verifyOrder()
759 chandransh 2475 
 
3064 chandransh 2476 
  def send_verifyOrder(self, orderId):
2477 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2478 
    args = verifyOrder_args()
2479 
    args.orderId = orderId
759 chandransh 2480 
    args.write(self._oprot)
2481 
    self._oprot.writeMessageEnd()
2482 
    self._oprot.trans.flush()
2483 
 
3064 chandransh 2484 
  def recv_verifyOrder(self, ):
759 chandransh 2485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2486 
    if mtype == TMessageType.EXCEPTION:
2487 
      x = TApplicationException()
2488 
      x.read(self._iprot)
2489 
      self._iprot.readMessageEnd()
2490 
      raise x
3064 chandransh 2491 
    result = verifyOrder_result()
759 chandransh 2492 
    result.read(self._iprot)
2493 
    self._iprot.readMessageEnd()
3431 rajveer 2494 
    if result.success is not None:
759 chandransh 2495 
      return result.success
3431 rajveer 2496 
    if result.ex is not None:
759 chandransh 2497 
      raise result.ex
3064 chandransh 2498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2499 
 
3064 chandransh 2500 
  def acceptOrder(self, orderId):
1113 chandransh 2501 
    """
3064 chandransh 2502 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2503 
    given order is not a COD order, it also captures the payment if the same has
2504 
    not been captured.
2505 
    Throws an exception if no such order exists.
3431 rajveer 2506 
 
1113 chandransh 2507 
    Parameters:
3064 chandransh 2508 
     - orderId
1113 chandransh 2509 
    """
3064 chandransh 2510 
    self.send_acceptOrder(orderId)
2511 
    return self.recv_acceptOrder()
1113 chandransh 2512 
 
3064 chandransh 2513 
  def send_acceptOrder(self, orderId):
2514 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2515 
    args = acceptOrder_args()
2516 
    args.orderId = orderId
1113 chandransh 2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
3064 chandransh 2521 
  def recv_acceptOrder(self, ):
1113 chandransh 2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
3064 chandransh 2528 
    result = acceptOrder_result()
1113 chandransh 2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
3431 rajveer 2531 
    if result.success is not None:
1113 chandransh 2532 
      return result.success
3431 rajveer 2533 
    if result.ex is not None:
1113 chandransh 2534 
      raise result.ex
3064 chandransh 2535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2536 
 
5110 mandeep.dh 2537 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2538 
    """
3064 chandransh 2539 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2540 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2541 
    the IMEI no. if a -1 is supplied.
2542 
    Also, it generates an invoice number for the order, marks the order as
2543 
    BILLED and sets the billing timestamp.
2544 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2545 
 
1135 chandransh 2546 
    Parameters:
3064 chandransh 2547 
     - orderId
2548 
     - invoice_number
4658 mandeep.dh 2549 
     - serialNumber
4283 anupam.sin 2550 
     - itemNumber
3064 chandransh 2551 
     - billed_by
4264 rajveer 2552 
     - jacketNumber
4283 anupam.sin 2553 
     - billingType
5110 mandeep.dh 2554 
     - fulfilmentWarehouseId
4763 rajveer 2555 
     - authorize
1135 chandransh 2556 
    """
5110 mandeep.dh 2557 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2558 
    return self.recv_addBillingDetails()
1135 chandransh 2559 
 
5110 mandeep.dh 2560 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2561 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2562 
    args = addBillingDetails_args()
2563 
    args.orderId = orderId
2564 
    args.invoice_number = invoice_number
4658 mandeep.dh 2565 
    args.serialNumber = serialNumber
4283 anupam.sin 2566 
    args.itemNumber = itemNumber
3064 chandransh 2567 
    args.billed_by = billed_by
4264 rajveer 2568 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2569 
    args.billingType = billingType
5110 mandeep.dh 2570 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2571 
    args.authorize = authorize
1135 chandransh 2572 
    args.write(self._oprot)
2573 
    self._oprot.writeMessageEnd()
2574 
    self._oprot.trans.flush()
2575 
 
3064 chandransh 2576 
  def recv_addBillingDetails(self, ):
1135 chandransh 2577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2578 
    if mtype == TMessageType.EXCEPTION:
2579 
      x = TApplicationException()
2580 
      x.read(self._iprot)
2581 
      self._iprot.readMessageEnd()
2582 
      raise x
3064 chandransh 2583 
    result = addBillingDetails_result()
1135 chandransh 2584 
    result.read(self._iprot)
2585 
    self._iprot.readMessageEnd()
3431 rajveer 2586 
    if result.success is not None:
3064 chandransh 2587 
      return result.success
3431 rajveer 2588 
    if result.ex is not None:
1135 chandransh 2589 
      raise result.ex
3064 chandransh 2590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2591 
 
4763 rajveer 2592 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2593 
    """
2594 
    Add the invoice number to the order.
2595 
 
2596 
    Parameters:
2597 
     - orderId
2598 
     - invoiceNumber
4763 rajveer 2599 
     - color
4579 rajveer 2600 
    """
4763 rajveer 2601 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2602 
    self.recv_addInvoiceNumber()
2603 
 
4763 rajveer 2604 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2605 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2606 
    args = addInvoiceNumber_args()
2607 
    args.orderId = orderId
2608 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2609 
    args.color = color
4579 rajveer 2610 
    args.write(self._oprot)
2611 
    self._oprot.writeMessageEnd()
2612 
    self._oprot.trans.flush()
2613 
 
2614 
  def recv_addInvoiceNumber(self, ):
2615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2616 
    if mtype == TMessageType.EXCEPTION:
2617 
      x = TApplicationException()
2618 
      x.read(self._iprot)
2619 
      self._iprot.readMessageEnd()
2620 
      raise x
2621 
    result = addInvoiceNumber_result()
2622 
    result.read(self._iprot)
2623 
    self._iprot.readMessageEnd()
2624 
    if result.ex is not None:
2625 
      raise result.ex
2626 
    return
2627 
 
4910 phani.kuma 2628 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2629 
    """
3064 chandransh 2630 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2631 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2632 
 
1408 ankur.sing 2633 
    Parameters:
3064 chandransh 2634 
     - warehouseId
1408 ankur.sing 2635 
     - providerId
3064 chandransh 2636 
     - cod
4910 phani.kuma 2637 
     - orderIds
1408 ankur.sing 2638 
    """
4910 phani.kuma 2639 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2640 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2641 
 
4910 phani.kuma 2642 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2643 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2644 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2645 
    args.warehouseId = warehouseId
1408 ankur.sing 2646 
    args.providerId = providerId
3064 chandransh 2647 
    args.cod = cod
4910 phani.kuma 2648 
    args.orderIds = orderIds
1408 ankur.sing 2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
4910 phani.kuma 2653 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
4910 phani.kuma 2660 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
3431 rajveer 2663 
    if result.success is not None:
1408 ankur.sing 2664 
      return result.success
3431 rajveer 2665 
    if result.ex is not None:
3064 chandransh 2666 
      raise result.ex
4910 phani.kuma 2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2668 
 
5713 rajveer 2669 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2670 
    """
2671 
    Parameters:
2672 
     - providerId
2673 
     - orderIds
5713 rajveer 2674 
     - awbs
5676 rajveer 2675 
    """
5713 rajveer 2676 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2677 
    return self.recv_markOrdersAsReturnedFromStore()
2678 
 
5713 rajveer 2679 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2680 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2681 
    args = markOrdersAsReturnedFromStore_args()
2682 
    args.providerId = providerId
2683 
    args.orderIds = orderIds
5713 rajveer 2684 
    args.awbs = awbs
5676 rajveer 2685 
    args.write(self._oprot)
2686 
    self._oprot.writeMessageEnd()
2687 
    self._oprot.trans.flush()
2688 
 
2689 
  def recv_markOrdersAsReturnedFromStore(self, ):
2690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2691 
    if mtype == TMessageType.EXCEPTION:
2692 
      x = TApplicationException()
2693 
      x.read(self._iprot)
2694 
      self._iprot.readMessageEnd()
2695 
      raise x
2696 
    result = markOrdersAsReturnedFromStore_result()
2697 
    result.read(self._iprot)
2698 
    self._iprot.readMessageEnd()
2699 
    if result.success is not None:
2700 
      return result.success
2701 
    if result.ex is not None:
2702 
      raise result.ex
2703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2704 
 
4910 phani.kuma 2705 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2706 
    """
4910 phani.kuma 2707 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2708 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2709 
 
2710 
    Parameters:
2711 
     - providerId
4910 phani.kuma 2712 
     - pickupDetails
4410 rajveer 2713 
    """
4910 phani.kuma 2714 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2715 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2716 
 
4910 phani.kuma 2717 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2718 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2719 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2720 
    args.providerId = providerId
4910 phani.kuma 2721 
    args.pickupDetails = pickupDetails
4410 rajveer 2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
4910 phani.kuma 2726 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
4910 phani.kuma 2733 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
2736 
    if result.ex is not None:
2737 
      raise result.ex
4910 phani.kuma 2738 
    return
4410 rajveer 2739 
 
4910 phani.kuma 2740 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2741 
    """
3064 chandransh 2742 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2743 
 
94 ashish 2744 
    Parameters:
3064 chandransh 2745 
     - providerId
304 ashish 2746 
    """
4910 phani.kuma 2747 
    self.send_getOrdersNotPickedUp(providerId)
2748 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2749 
 
4910 phani.kuma 2750 
  def send_getOrdersNotPickedUp(self, providerId):
2751 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2752 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2753 
    args.providerId = providerId
304 ashish 2754 
    args.write(self._oprot)
2755 
    self._oprot.writeMessageEnd()
2756 
    self._oprot.trans.flush()
2757 
 
4910 phani.kuma 2758 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2760 
    if mtype == TMessageType.EXCEPTION:
2761 
      x = TApplicationException()
2762 
      x.read(self._iprot)
2763 
      self._iprot.readMessageEnd()
2764 
      raise x
4910 phani.kuma 2765 
    result = getOrdersNotPickedUp_result()
304 ashish 2766 
    result.read(self._iprot)
2767 
    self._iprot.readMessageEnd()
3431 rajveer 2768 
    if result.success is not None:
304 ashish 2769 
      return result.success
4910 phani.kuma 2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2771 
 
3064 chandransh 2772 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2773 
    """
3064 chandransh 2774 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2775 
    the name of the receiver.
2776 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2777 
 
304 ashish 2778 
    Parameters:
3064 chandransh 2779 
     - providerId
2780 
     - deliveredOrders
304 ashish 2781 
    """
3064 chandransh 2782 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2783 
    self.recv_markOrdersAsDelivered()
304 ashish 2784 
 
3064 chandransh 2785 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2786 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2787 
    args = markOrdersAsDelivered_args()
2788 
    args.providerId = providerId
2789 
    args.deliveredOrders = deliveredOrders
304 ashish 2790 
    args.write(self._oprot)
2791 
    self._oprot.writeMessageEnd()
2792 
    self._oprot.trans.flush()
2793 
 
3064 chandransh 2794 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2796 
    if mtype == TMessageType.EXCEPTION:
2797 
      x = TApplicationException()
2798 
      x.read(self._iprot)
2799 
      self._iprot.readMessageEnd()
2800 
      raise x
3064 chandransh 2801 
    result = markOrdersAsDelivered_result()
304 ashish 2802 
    result.read(self._iprot)
2803 
    self._iprot.readMessageEnd()
3431 rajveer 2804 
    if result.ex is not None:
3064 chandransh 2805 
      raise result.ex
304 ashish 2806 
    return
2807 
 
4910 phani.kuma 2808 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2809 
    """
4910 phani.kuma 2810 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2811 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2812 
 
3064 chandransh 2813 
    Parameters:
2814 
     - providerId
2815 
     - returnedOrders
1596 ankur.sing 2816 
    """
4910 phani.kuma 2817 
    self.send_markAsRTOrders(providerId, returnedOrders)
2818 
    self.recv_markAsRTOrders()
304 ashish 2819 
 
4910 phani.kuma 2820 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2821 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2822 
    args = markAsRTOrders_args()
3064 chandransh 2823 
    args.providerId = providerId
2824 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2825 
    args.write(self._oprot)
2826 
    self._oprot.writeMessageEnd()
2827 
    self._oprot.trans.flush()
2828 
 
4910 phani.kuma 2829 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2831 
    if mtype == TMessageType.EXCEPTION:
2832 
      x = TApplicationException()
2833 
      x.read(self._iprot)
2834 
      self._iprot.readMessageEnd()
2835 
      raise x
4910 phani.kuma 2836 
    result = markAsRTOrders_result()
1596 ankur.sing 2837 
    result.read(self._iprot)
2838 
    self._iprot.readMessageEnd()
3431 rajveer 2839 
    if result.ex is not None:
3064 chandransh 2840 
      raise result.ex
2841 
    return
1596 ankur.sing 2842 
 
4910 phani.kuma 2843 
  def getRTOrders(self, providerId):
2844 
    """
2845 
    Returns a list of orders that were returned by courier.
2846 
 
2847 
    Parameters:
2848 
     - providerId
2849 
    """
2850 
    self.send_getRTOrders(providerId)
2851 
    return self.recv_getRTOrders()
2852 
 
2853 
  def send_getRTOrders(self, providerId):
2854 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2855 
    args = getRTOrders_args()
2856 
    args.providerId = providerId
2857 
    args.write(self._oprot)
2858 
    self._oprot.writeMessageEnd()
2859 
    self._oprot.trans.flush()
2860 
 
2861 
  def recv_getRTOrders(self, ):
2862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2863 
    if mtype == TMessageType.EXCEPTION:
2864 
      x = TApplicationException()
2865 
      x.read(self._iprot)
2866 
      self._iprot.readMessageEnd()
2867 
      raise x
2868 
    result = getRTOrders_result()
2869 
    result.read(self._iprot)
2870 
    self._iprot.readMessageEnd()
2871 
    if result.success is not None:
2872 
      return result.success
2873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2874 
 
3064 chandransh 2875 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2876 
    """
3064 chandransh 2877 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2878 
 
3064 chandransh 2879 
    Parameters:
2880 
     - providerId
2881 
     - undeliveredOrders
1627 ankur.sing 2882 
    """
3064 chandransh 2883 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2884 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2885 
 
3064 chandransh 2886 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2887 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2888 
    args = updateNonDeliveryReason_args()
2889 
    args.providerId = providerId
2890 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
3064 chandransh 2895 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
3064 chandransh 2902 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
4910 phani.kuma 2905 
    if result.ex is not None:
2906 
      raise result.ex
2907 
    return
2908 
 
2909 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2910 
    """
2911 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2912 
 
2913 
    Parameters:
2914 
     - providerId
2915 
    """
2916 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2917 
    return self.recv_getNonDeliveredOrdersbyCourier()
2918 
 
2919 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2920 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2921 
    args = getNonDeliveredOrdersbyCourier_args()
2922 
    args.providerId = providerId
2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
2926 
 
2927 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2929 
    if mtype == TMessageType.EXCEPTION:
2930 
      x = TApplicationException()
2931 
      x.read(self._iprot)
2932 
      self._iprot.readMessageEnd()
2933 
      raise x
2934 
    result = getNonDeliveredOrdersbyCourier_result()
2935 
    result.read(self._iprot)
2936 
    self._iprot.readMessageEnd()
4581 phani.kuma 2937 
    if result.success is not None:
2938 
      return result.success
4910 phani.kuma 2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2940 
 
2941 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2942 
    """
2943 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2944 
 
2945 
    Parameters:
2946 
     - providerId
2947 
     - local_connected_orders
2948 
    """
2949 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2950 
    self.recv_markOrdersAsLocalConnected()
2951 
 
2952 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2953 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2954 
    args = markOrdersAsLocalConnected_args()
2955 
    args.providerId = providerId
2956 
    args.local_connected_orders = local_connected_orders
2957 
    args.write(self._oprot)
2958 
    self._oprot.writeMessageEnd()
2959 
    self._oprot.trans.flush()
2960 
 
2961 
  def recv_markOrdersAsLocalConnected(self, ):
2962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2963 
    if mtype == TMessageType.EXCEPTION:
2964 
      x = TApplicationException()
2965 
      x.read(self._iprot)
2966 
      self._iprot.readMessageEnd()
2967 
      raise x
2968 
    result = markOrdersAsLocalConnected_result()
2969 
    result.read(self._iprot)
2970 
    self._iprot.readMessageEnd()
3431 rajveer 2971 
    if result.ex is not None:
3064 chandransh 2972 
      raise result.ex
4910 phani.kuma 2973 
    return
1627 ankur.sing 2974 
 
4910 phani.kuma 2975 
  def getOrdersNotLocalConnected(self, providerId):
2976 
    """
2977 
    Returns a list of orders that were picked up or shipped but pending local connection.
2978 
 
2979 
    Parameters:
2980 
     - providerId
2981 
    """
2982 
    self.send_getOrdersNotLocalConnected(providerId)
2983 
    return self.recv_getOrdersNotLocalConnected()
2984 
 
2985 
  def send_getOrdersNotLocalConnected(self, providerId):
2986 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2987 
    args = getOrdersNotLocalConnected_args()
2988 
    args.providerId = providerId
2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_getOrdersNotLocalConnected(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = getOrdersNotLocalConnected_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3006 
 
3007 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3008 
    """
3009 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3010 
 
3011 
    Parameters:
3012 
     - providerId
3013 
     - destination_city_reached_orders
3014 
    """
3015 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3016 
    self.recv_markOrdersAsDestinationCityReached()
3017 
 
3018 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3019 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3020 
    args = markOrdersAsDestinationCityReached_args()
3021 
    args.providerId = providerId
3022 
    args.destination_city_reached_orders = destination_city_reached_orders
3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3027 
  def recv_markOrdersAsDestinationCityReached(self, ):
3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3034 
    result = markOrdersAsDestinationCityReached_result()
3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    if result.ex is not None:
3038 
      raise result.ex
3039 
    return
3040 
 
3041 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3042 
    """
3043 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3044 
 
3045 
    Parameters:
3046 
     - providerId
3047 
     - first_atdl_orders
3048 
    """
3049 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3050 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3051 
 
3052 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3053 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3054 
    args = markOrdersAsFirstDeliveryAttempted_args()
3055 
    args.providerId = providerId
3056 
    args.first_atdl_orders = first_atdl_orders
3057 
    args.write(self._oprot)
3058 
    self._oprot.writeMessageEnd()
3059 
    self._oprot.trans.flush()
3060 
 
3061 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3063 
    if mtype == TMessageType.EXCEPTION:
3064 
      x = TApplicationException()
3065 
      x.read(self._iprot)
3066 
      self._iprot.readMessageEnd()
3067 
      raise x
3068 
    result = markOrdersAsFirstDeliveryAttempted_result()
3069 
    result.read(self._iprot)
3070 
    self._iprot.readMessageEnd()
3071 
    if result.ex is not None:
3072 
      raise result.ex
3073 
    return
3074 
 
3064 chandransh 3075 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3076 
    """
3064 chandransh 3077 
    Returns the list of orders whose delivery time has passed but have not been
3078 
    delivered yet for the given provider and warehouse. To get a complete list of
3079 
    undelivered orders, pass them as -1.
3080 
    Returns an empty list if no such orders exist.
3431 rajveer 3081 
 
1886 ankur.sing 3082 
    Parameters:
3064 chandransh 3083 
     - providerId
3084 
     - warehouseId
1886 ankur.sing 3085 
    """
3064 chandransh 3086 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3087 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3088 
 
3064 chandransh 3089 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3090 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3091 
    args = getUndeliveredOrders_args()
3092 
    args.providerId = providerId
3093 
    args.warehouseId = warehouseId
1886 ankur.sing 3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3064 chandransh 3098 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3064 chandransh 3105 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3431 rajveer 3108 
    if result.success is not None:
1886 ankur.sing 3109 
      return result.success
3064 chandransh 3110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3111 
 
4783 phani.kuma 3112 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3113 
    """
3114 
    Returns the list of orders whose expected delivery date has passed but have not been
3115 
    delivered yet.
3116 
    Returns an empty list if no such orders exist.
3117 
    """
3118 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3119 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3120 
 
3121 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3122 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3123 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3124 
    args.write(self._oprot)
3125 
    self._oprot.writeMessageEnd()
3126 
    self._oprot.trans.flush()
3127 
 
3128 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3130 
    if mtype == TMessageType.EXCEPTION:
3131 
      x = TApplicationException()
3132 
      x.read(self._iprot)
3133 
      self._iprot.readMessageEnd()
3134 
      raise x
3135 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3136 
    result.read(self._iprot)
3137 
    self._iprot.readMessageEnd()
3138 
    if result.success is not None:
3139 
      return result.success
3140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3141 
 
2536 chandransh 3142 
  def toggleDOAFlag(self, orderId):
3143 
    """
3144 
    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.
3145 
    Returns the final flag status.
3146 
    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 3147 
 
2536 chandransh 3148 
    Parameters:
3149 
     - orderId
3150 
    """
3151 
    self.send_toggleDOAFlag(orderId)
3152 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3153 
 
2536 chandransh 3154 
  def send_toggleDOAFlag(self, orderId):
3155 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3156 
    args = toggleDOAFlag_args()
3157 
    args.orderId = orderId
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_toggleDOAFlag(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = toggleDOAFlag_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3431 rajveer 3172 
    if result.success is not None:
2536 chandransh 3173 
      return result.success
3431 rajveer 3174 
    if result.ex is not None:
2536 chandransh 3175 
      raise result.ex
3176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3177 
 
4712 rajveer 3178 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3179 
    """
3180 
    Parameters:
3181 
     - orderId
3182 
     - deliveryTimestamp
3183 
     - receiver
3184 
    """
3185 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3186 
    self.recv_markOrderAsDelivered()
3187 
 
3188 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3189 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3190 
    args = markOrderAsDelivered_args()
3191 
    args.orderId = orderId
3192 
    args.deliveryTimestamp = deliveryTimestamp
3193 
    args.receiver = receiver
3194 
    args.write(self._oprot)
3195 
    self._oprot.writeMessageEnd()
3196 
    self._oprot.trans.flush()
3197 
 
3198 
  def recv_markOrderAsDelivered(self, ):
3199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3200 
    if mtype == TMessageType.EXCEPTION:
3201 
      x = TApplicationException()
3202 
      x.read(self._iprot)
3203 
      self._iprot.readMessageEnd()
3204 
      raise x
3205 
    result = markOrderAsDelivered_result()
3206 
    result.read(self._iprot)
3207 
    self._iprot.readMessageEnd()
3208 
    if result.ex is not None:
3209 
      raise result.ex
3210 
    return
3211 
 
5553 rajveer 3212 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3213 
    """
3214 
    Parameters:
3215 
     - orderId
3216 
     - deliveryTimestamp
3217 
    """
3218 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3219 
    self.recv_markOrderAsReceivedAtStore()
3220 
 
3221 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3222 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3223 
    args = markOrderAsReceivedAtStore_args()
3224 
    args.orderId = orderId
3225 
    args.deliveryTimestamp = deliveryTimestamp
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_markOrderAsReceivedAtStore(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = markOrderAsReceivedAtStore_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.ex is not None:
3241 
      raise result.ex
3242 
    return
3243 
 
4454 rajveer 3244 
  def markOrderDoaRequestReceived(self, orderId):
3245 
    """
3246 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3247 
 
3248 
    Parameters:
3249 
     - orderId
3250 
    """
3251 
    self.send_markOrderDoaRequestReceived(orderId)
3252 
    return self.recv_markOrderDoaRequestReceived()
3253 
 
3254 
  def send_markOrderDoaRequestReceived(self, orderId):
3255 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3256 
    args = markOrderDoaRequestReceived_args()
3257 
    args.orderId = orderId
3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_markOrderDoaRequestReceived(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = markOrderDoaRequestReceived_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3272 
    if result.success is not None:
3273 
      return result.success
3274 
    if result.ex is not None:
3275 
      raise result.ex
3276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3277 
 
3278 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3279 
    """
3280 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3281 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3282 
 
3283 
    Parameters:
3284 
     - orderId
3285 
     - isAuthorized
3286 
    """
3287 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3288 
    return self.recv_markOrderDoaRequestAuthorized()
3289 
 
3290 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3291 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3292 
    args = markOrderDoaRequestAuthorized_args()
3293 
    args.orderId = orderId
3294 
    args.isAuthorized = isAuthorized
3295 
    args.write(self._oprot)
3296 
    self._oprot.writeMessageEnd()
3297 
    self._oprot.trans.flush()
3298 
 
3299 
  def recv_markOrderDoaRequestAuthorized(self, ):
3300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3301 
    if mtype == TMessageType.EXCEPTION:
3302 
      x = TApplicationException()
3303 
      x.read(self._iprot)
3304 
      self._iprot.readMessageEnd()
3305 
      raise x
3306 
    result = markOrderDoaRequestAuthorized_result()
3307 
    result.read(self._iprot)
3308 
    self._iprot.readMessageEnd()
3309 
    if result.success is not None:
3310 
      return result.success
3311 
    if result.ex is not None:
3312 
      raise result.ex
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3314 
 
4488 rajveer 3315 
  def markOrderReturnRequestReceived(self, orderId):
3316 
    """
3317 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3318 
 
3319 
    Parameters:
3320 
     - orderId
3321 
    """
3322 
    self.send_markOrderReturnRequestReceived(orderId)
3323 
    return self.recv_markOrderReturnRequestReceived()
3324 
 
3325 
  def send_markOrderReturnRequestReceived(self, orderId):
3326 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3327 
    args = markOrderReturnRequestReceived_args()
3328 
    args.orderId = orderId
3329 
    args.write(self._oprot)
3330 
    self._oprot.writeMessageEnd()
3331 
    self._oprot.trans.flush()
3332 
 
3333 
  def recv_markOrderReturnRequestReceived(self, ):
3334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3335 
    if mtype == TMessageType.EXCEPTION:
3336 
      x = TApplicationException()
3337 
      x.read(self._iprot)
3338 
      self._iprot.readMessageEnd()
3339 
      raise x
3340 
    result = markOrderReturnRequestReceived_result()
3341 
    result.read(self._iprot)
3342 
    self._iprot.readMessageEnd()
3343 
    if result.success is not None:
3344 
      return result.success
3345 
    if result.ex is not None:
3346 
      raise result.ex
3347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3348 
 
3349 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3350 
    """
3351 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3352 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3353 
 
3354 
    Parameters:
3355 
     - orderId
3356 
     - isAuthorized
3357 
    """
3358 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3359 
    return self.recv_markOrderReturnRequestAuthorized()
3360 
 
3361 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3362 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3363 
    args = markOrderReturnRequestAuthorized_args()
3364 
    args.orderId = orderId
3365 
    args.isAuthorized = isAuthorized
3366 
    args.write(self._oprot)
3367 
    self._oprot.writeMessageEnd()
3368 
    self._oprot.trans.flush()
3369 
 
3370 
  def recv_markOrderReturnRequestAuthorized(self, ):
3371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3372 
    if mtype == TMessageType.EXCEPTION:
3373 
      x = TApplicationException()
3374 
      x.read(self._iprot)
3375 
      self._iprot.readMessageEnd()
3376 
      raise x
3377 
    result = markOrderReturnRequestAuthorized_result()
3378 
    result.read(self._iprot)
3379 
    self._iprot.readMessageEnd()
3380 
    if result.success is not None:
3381 
      return result.success
3382 
    if result.ex is not None:
3383 
      raise result.ex
3384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3385 
 
4579 rajveer 3386 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3387 
    """
3388 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3389 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3390 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3391 
    For any other status, it returns false.
3392 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3393 
 
2536 chandransh 3394 
    Parameters:
3395 
     - orderId
4579 rajveer 3396 
     - providerId
2536 chandransh 3397 
    """
4579 rajveer 3398 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3399 
    return self.recv_requestPickupNumber()
3400 
 
4579 rajveer 3401 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3402 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3403 
    args = requestPickupNumber_args()
3404 
    args.orderId = orderId
4579 rajveer 3405 
    args.providerId = providerId
2536 chandransh 3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_requestPickupNumber(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = requestPickupNumber_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3431 rajveer 3420 
    if result.success is not None:
2536 chandransh 3421 
      return result.success
3431 rajveer 3422 
    if result.ex is not None:
2536 chandransh 3423 
      raise result.ex
3424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3425 
 
4602 rajveer 3426 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3427 
    """
4452 rajveer 3428 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3429 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3430 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3431 
    	3. Returns true
2591 chandransh 3432 
    If the order is in any other status, it returns false.
2536 chandransh 3433 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3434 
 
2536 chandransh 3435 
    Parameters:
3436 
     - orderId
3437 
     - pickupNumber
4602 rajveer 3438 
     - providerId
2536 chandransh 3439 
    """
4602 rajveer 3440 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3441 
    return self.recv_authorizePickup()
3442 
 
4602 rajveer 3443 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3444 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3445 
    args = authorizePickup_args()
3446 
    args.orderId = orderId
3447 
    args.pickupNumber = pickupNumber
4602 rajveer 3448 
    args.providerId = providerId
2536 chandransh 3449 
    args.write(self._oprot)
3450 
    self._oprot.writeMessageEnd()
3451 
    self._oprot.trans.flush()
3452 
 
3453 
  def recv_authorizePickup(self, ):
3454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3455 
    if mtype == TMessageType.EXCEPTION:
3456 
      x = TApplicationException()
3457 
      x.read(self._iprot)
3458 
      self._iprot.readMessageEnd()
3459 
      raise x
3460 
    result = authorizePickup_result()
3461 
    result.read(self._iprot)
3462 
    self._iprot.readMessageEnd()
3431 rajveer 3463 
    if result.success is not None:
2536 chandransh 3464 
      return result.success
3431 rajveer 3465 
    if result.ex is not None:
2536 chandransh 3466 
      raise result.ex
3467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3468 
 
2764 chandransh 3469 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3470 
    """
3471 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3472 
 
2764 chandransh 3473 
    Parameters:
3474 
     - providerId
3475 
     - pickupDetails
3476 
    """
3477 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3478 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3479 
 
3480 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3481 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3482 
    args = markDoasAsPickedUp_args()
3483 
    args.providerId = providerId
3484 
    args.pickupDetails = pickupDetails
3485 
    args.write(self._oprot)
3486 
    self._oprot.writeMessageEnd()
3487 
    self._oprot.trans.flush()
3488 
 
3489 
  def recv_markDoasAsPickedUp(self, ):
3490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3491 
    if mtype == TMessageType.EXCEPTION:
3492 
      x = TApplicationException()
3493 
      x.read(self._iprot)
3494 
      self._iprot.readMessageEnd()
3495 
      raise x
3496 
    result = markDoasAsPickedUp_result()
3497 
    result.read(self._iprot)
3498 
    self._iprot.readMessageEnd()
4910 phani.kuma 3499 
    return
3500 
 
3501 
  def getDoasNotPickedUp(self, providerId):
3502 
    """
3503 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3504 
 
3505 
    Parameters:
3506 
     - providerId
3507 
    """
3508 
    self.send_getDoasNotPickedUp(providerId)
3509 
    return self.recv_getDoasNotPickedUp()
3510 
 
3511 
  def send_getDoasNotPickedUp(self, providerId):
3512 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3513 
    args = getDoasNotPickedUp_args()
3514 
    args.providerId = providerId
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getDoasNotPickedUp(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getDoasNotPickedUp_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3431 rajveer 3529 
    if result.success is not None:
2764 chandransh 3530 
      return result.success
4910 phani.kuma 3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3532 
 
4741 phani.kuma 3533 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3534 
    """
3535 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3536 
 
3537 
    Parameters:
3538 
     - providerId
3539 
     - pickupDetails
3540 
    """
3541 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3542 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3543 
 
3544 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3545 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3546 
    args = markReturnOrdersAsPickedUp_args()
3547 
    args.providerId = providerId
3548 
    args.pickupDetails = pickupDetails
3549 
    args.write(self._oprot)
3550 
    self._oprot.writeMessageEnd()
3551 
    self._oprot.trans.flush()
3552 
 
3553 
  def recv_markReturnOrdersAsPickedUp(self, ):
3554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3555 
    if mtype == TMessageType.EXCEPTION:
3556 
      x = TApplicationException()
3557 
      x.read(self._iprot)
3558 
      self._iprot.readMessageEnd()
3559 
      raise x
3560 
    result = markReturnOrdersAsPickedUp_result()
3561 
    result.read(self._iprot)
3562 
    self._iprot.readMessageEnd()
4910 phani.kuma 3563 
    return
3564 
 
3565 
  def getReturnOrdersNotPickedUp(self, providerId):
3566 
    """
3567 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3568 
 
3569 
    Parameters:
3570 
     - providerId
3571 
    """
3572 
    self.send_getReturnOrdersNotPickedUp(providerId)
3573 
    return self.recv_getReturnOrdersNotPickedUp()
3574 
 
3575 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3576 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3577 
    args = getReturnOrdersNotPickedUp_args()
3578 
    args.providerId = providerId
3579 
    args.write(self._oprot)
3580 
    self._oprot.writeMessageEnd()
3581 
    self._oprot.trans.flush()
3582 
 
3583 
  def recv_getReturnOrdersNotPickedUp(self, ):
3584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3585 
    if mtype == TMessageType.EXCEPTION:
3586 
      x = TApplicationException()
3587 
      x.read(self._iprot)
3588 
      self._iprot.readMessageEnd()
3589 
      raise x
3590 
    result = getReturnOrdersNotPickedUp_result()
3591 
    result.read(self._iprot)
3592 
    self._iprot.readMessageEnd()
4741 phani.kuma 3593 
    if result.success is not None:
3594 
      return result.success
4910 phani.kuma 3595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3596 
 
4479 rajveer 3597 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3598 
    """
4452 rajveer 3599 
    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 3600 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3601 
    If the order is in any other state, it returns false.
3602 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3603 
 
2591 chandransh 3604 
    Parameters:
3605 
     - orderId
4479 rajveer 3606 
     - receiveCondition
2591 chandransh 3607 
    """
4479 rajveer 3608 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3609 
    return self.recv_receiveReturn()
2536 chandransh 3610 
 
4479 rajveer 3611 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3612 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3613 
    args = receiveReturn_args()
2591 chandransh 3614 
    args.orderId = orderId
4479 rajveer 3615 
    args.receiveCondition = receiveCondition
2591 chandransh 3616 
    args.write(self._oprot)
3617 
    self._oprot.writeMessageEnd()
3618 
    self._oprot.trans.flush()
3619 
 
2616 chandransh 3620 
  def recv_receiveReturn(self, ):
2591 chandransh 3621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3622 
    if mtype == TMessageType.EXCEPTION:
3623 
      x = TApplicationException()
3624 
      x.read(self._iprot)
3625 
      self._iprot.readMessageEnd()
3626 
      raise x
2616 chandransh 3627 
    result = receiveReturn_result()
2591 chandransh 3628 
    result.read(self._iprot)
3629 
    self._iprot.readMessageEnd()
3431 rajveer 3630 
    if result.success is not None:
2591 chandransh 3631 
      return result.success
3431 rajveer 3632 
    if result.ex is not None:
2591 chandransh 3633 
      raise result.ex
2616 chandransh 3634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3635 
 
3636 
  def validateDoa(self, orderId, isValid):
3637 
    """
4452 rajveer 3638 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3639 
    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 3640 
    If the order is in any other state, it returns false.
3641 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3642 
 
2591 chandransh 3643 
    Parameters:
3644 
     - orderId
3645 
     - isValid
3646 
    """
3647 
    self.send_validateDoa(orderId, isValid)
3648 
    return self.recv_validateDoa()
3649 
 
3650 
  def send_validateDoa(self, orderId, isValid):
3651 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3652 
    args = validateDoa_args()
3653 
    args.orderId = orderId
3654 
    args.isValid = isValid
3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
3659 
  def recv_validateDoa(self, ):
3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
3666 
    result = validateDoa_result()
3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3431 rajveer 3669 
    if result.success is not None:
2591 chandransh 3670 
      return result.success
3431 rajveer 3671 
    if result.ex is not None:
2591 chandransh 3672 
      raise result.ex
3673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3674 
 
4495 rajveer 3675 
  def validateReturnProduct(self, orderId, isUsable):
3676 
    """
3677 
    Parameters:
3678 
     - orderId
3679 
     - isUsable
3680 
    """
3681 
    self.send_validateReturnProduct(orderId, isUsable)
3682 
    return self.recv_validateReturnProduct()
3683 
 
3684 
  def send_validateReturnProduct(self, orderId, isUsable):
3685 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3686 
    args = validateReturnProduct_args()
3687 
    args.orderId = orderId
3688 
    args.isUsable = isUsable
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_validateReturnProduct(self, ):
3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
3700 
    result = validateReturnProduct_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.success is not None:
3704 
      return result.success
3705 
    if result.ex is not None:
3706 
      raise result.ex
3707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3708 
 
2616 chandransh 3709 
  def reshipOrder(self, orderId):
3710 
    """
4484 rajveer 3711 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3712 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3713 
    	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 3714 
 
3715 
    If the order is in DOA_CERT_VALID state, it does the following:
3716 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3717 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3718 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3719 
 
2616 chandransh 3720 
    Returns the id of the newly created order.
3431 rajveer 3721 
 
2616 chandransh 3722 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3723 
 
2616 chandransh 3724 
    Parameters:
3725 
     - orderId
3726 
    """
3727 
    self.send_reshipOrder(orderId)
3728 
    return self.recv_reshipOrder()
2591 chandransh 3729 
 
2616 chandransh 3730 
  def send_reshipOrder(self, orderId):
3731 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3732 
    args = reshipOrder_args()
3733 
    args.orderId = orderId
3734 
    args.write(self._oprot)
3735 
    self._oprot.writeMessageEnd()
3736 
    self._oprot.trans.flush()
3737 
 
3738 
  def recv_reshipOrder(self, ):
3739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3740 
    if mtype == TMessageType.EXCEPTION:
3741 
      x = TApplicationException()
3742 
      x.read(self._iprot)
3743 
      self._iprot.readMessageEnd()
3744 
      raise x
3745 
    result = reshipOrder_result()
3746 
    result.read(self._iprot)
3747 
    self._iprot.readMessageEnd()
3431 rajveer 3748 
    if result.success is not None:
2616 chandransh 3749 
      return result.success
3431 rajveer 3750 
    if result.ex is not None:
2616 chandransh 3751 
      raise result.ex
3752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3753 
 
3226 chandransh 3754 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3755 
    """
4484 rajveer 3756 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3757 
    	1. Creates a refund request for batch processing.
3758 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3759 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3760 
 
2616 chandransh 3761 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3762 
    	1. Creates a refund request for batch processing.
3226 chandransh 3763 
    	2. Cancels the reservation of the item in the warehouse.
3764 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3765 
 
3226 chandransh 3766 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3767 
    	1. Cancels the reservation of the item in the warehouse.
3768 
    	2. Marks the current order as CANCELED.
3769 
 
3770 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3771 
 
2616 chandransh 3772 
    Returns True if it is successful, False otherwise.
3431 rajveer 3773 
 
2616 chandransh 3774 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3775 
 
2616 chandransh 3776 
    Parameters:
3777 
     - orderId
3226 chandransh 3778 
     - refundedBy
3779 
     - reason
2616 chandransh 3780 
    """
3226 chandransh 3781 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3782 
    return self.recv_refundOrder()
3783 
 
3226 chandransh 3784 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3785 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3786 
    args = refundOrder_args()
3787 
    args.orderId = orderId
3226 chandransh 3788 
    args.refundedBy = refundedBy
3789 
    args.reason = reason
2616 chandransh 3790 
    args.write(self._oprot)
3791 
    self._oprot.writeMessageEnd()
3792 
    self._oprot.trans.flush()
3793 
 
3794 
  def recv_refundOrder(self, ):
3795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3796 
    if mtype == TMessageType.EXCEPTION:
3797 
      x = TApplicationException()
3798 
      x.read(self._iprot)
3799 
      self._iprot.readMessageEnd()
3800 
      raise x
3801 
    result = refundOrder_result()
3802 
    result.read(self._iprot)
3803 
    self._iprot.readMessageEnd()
3431 rajveer 3804 
    if result.success is not None:
2616 chandransh 3805 
      return result.success
3431 rajveer 3806 
    if result.ex is not None:
2616 chandransh 3807 
      raise result.ex
3808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3809 
 
2690 chandransh 3810 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3811 
    """
3812 
    Get all return orders created between the from and to dates for the given warehouse.
3813 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3814 
 
2690 chandransh 3815 
    Parameters:
3816 
     - warehouseId
3817 
     - fromDate
3818 
     - toDate
3819 
    """
3820 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3821 
    return self.recv_getReturnOrders()
2616 chandransh 3822 
 
2690 chandransh 3823 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3824 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3825 
    args = getReturnOrders_args()
3826 
    args.warehouseId = warehouseId
3827 
    args.fromDate = fromDate
3828 
    args.toDate = toDate
3829 
    args.write(self._oprot)
3830 
    self._oprot.writeMessageEnd()
3831 
    self._oprot.trans.flush()
3832 
 
3833 
  def recv_getReturnOrders(self, ):
3834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3835 
    if mtype == TMessageType.EXCEPTION:
3836 
      x = TApplicationException()
3837 
      x.read(self._iprot)
3838 
      self._iprot.readMessageEnd()
3839 
      raise x
3840 
    result = getReturnOrders_result()
3841 
    result.read(self._iprot)
3842 
    self._iprot.readMessageEnd()
3431 rajveer 3843 
    if result.success is not None:
2690 chandransh 3844 
      return result.success
3845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3846 
 
5481 phani.kuma 3847 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3848 
    """
3849 
    Get all return orders created between the from and to dates.
3850 
 
3851 
    Parameters:
3852 
     - onlyNotProcessed
3853 
     - fromDate
3854 
     - toDate
3855 
    """
3856 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3857 
    return self.recv_getAllReturnOrders()
3858 
 
3859 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3860 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3861 
    args = getAllReturnOrders_args()
3862 
    args.onlyNotProcessed = onlyNotProcessed
3863 
    args.fromDate = fromDate
3864 
    args.toDate = toDate
3865 
    args.write(self._oprot)
3866 
    self._oprot.writeMessageEnd()
3867 
    self._oprot.trans.flush()
3868 
 
3869 
  def recv_getAllReturnOrders(self, ):
3870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3871 
    if mtype == TMessageType.EXCEPTION:
3872 
      x = TApplicationException()
3873 
      x.read(self._iprot)
3874 
      self._iprot.readMessageEnd()
3875 
      raise x
3876 
    result = getAllReturnOrders_result()
3877 
    result.read(self._iprot)
3878 
    self._iprot.readMessageEnd()
3879 
    if result.success is not None:
3880 
      return result.success
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3882 
 
2700 chandransh 3883 
  def getReturnOrder(self, id):
3884 
    """
3885 
    Returns the ReturnOrder corresponding to the given id.
3886 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3887 
 
2700 chandransh 3888 
    Parameters:
3889 
     - id
3890 
    """
3891 
    self.send_getReturnOrder(id)
3892 
    return self.recv_getReturnOrder()
3893 
 
3894 
  def send_getReturnOrder(self, id):
3895 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3896 
    args = getReturnOrder_args()
3897 
    args.id = id
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_getReturnOrder(self, ):
3903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3904 
    if mtype == TMessageType.EXCEPTION:
3905 
      x = TApplicationException()
3906 
      x.read(self._iprot)
3907 
      self._iprot.readMessageEnd()
3908 
      raise x
3909 
    result = getReturnOrder_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
3431 rajveer 3912 
    if result.success is not None:
2700 chandransh 3913 
      return result.success
3431 rajveer 3914 
    if result.ex is not None:
2700 chandransh 3915 
      raise result.ex
3916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3917 
 
2690 chandransh 3918 
  def processReturn(self, returnOrderId):
3919 
    """
3920 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3921 
 
2690 chandransh 3922 
    Parameters:
3923 
     - returnOrderId
3924 
    """
3925 
    self.send_processReturn(returnOrderId)
3926 
    self.recv_processReturn()
3927 
 
3928 
  def send_processReturn(self, returnOrderId):
3929 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3930 
    args = processReturn_args()
3931 
    args.returnOrderId = returnOrderId
3932 
    args.write(self._oprot)
3933 
    self._oprot.writeMessageEnd()
3934 
    self._oprot.trans.flush()
3935 
 
3936 
  def recv_processReturn(self, ):
3937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3938 
    if mtype == TMessageType.EXCEPTION:
3939 
      x = TApplicationException()
3940 
      x.read(self._iprot)
3941 
      self._iprot.readMessageEnd()
3942 
      raise x
3943 
    result = processReturn_result()
3944 
    result.read(self._iprot)
3945 
    self._iprot.readMessageEnd()
3431 rajveer 3946 
    if result.ex is not None:
2690 chandransh 3947 
      raise result.ex
3948 
    return
3949 
 
3451 chandransh 3950 
  def updateWeight(self, orderId, weight):
3951 
    """
3952 
    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 3953 
 
3451 chandransh 3954 
    Parameters:
3955 
     - orderId
3956 
     - weight
3957 
    """
3958 
    self.send_updateWeight(orderId, weight)
3959 
    return self.recv_updateWeight()
3960 
 
3961 
  def send_updateWeight(self, orderId, weight):
3962 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3963 
    args = updateWeight_args()
3964 
    args.orderId = orderId
3965 
    args.weight = weight
3966 
    args.write(self._oprot)
3967 
    self._oprot.writeMessageEnd()
3968 
    self._oprot.trans.flush()
3969 
 
3970 
  def recv_updateWeight(self, ):
3971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3972 
    if mtype == TMessageType.EXCEPTION:
3973 
      x = TApplicationException()
3974 
      x.read(self._iprot)
3975 
      self._iprot.readMessageEnd()
3976 
      raise x
3977 
    result = updateWeight_result()
3978 
    result.read(self._iprot)
3979 
    self._iprot.readMessageEnd()
3980 
    if result.success is not None:
3981 
      return result.success
3982 
    if result.ex is not None:
3983 
      raise result.ex
3984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3985 
 
3469 chandransh 3986 
  def changeItem(self, orderId, itemId):
3987 
    """
3988 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3989 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3990 
 
3469 chandransh 3991 
    Parameters:
3992 
     - orderId
3993 
     - itemId
3994 
    """
3995 
    self.send_changeItem(orderId, itemId)
3996 
    return self.recv_changeItem()
3997 
 
3998 
  def send_changeItem(self, orderId, itemId):
3999 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4000 
    args = changeItem_args()
4001 
    args.orderId = orderId
4002 
    args.itemId = itemId
4003 
    args.write(self._oprot)
4004 
    self._oprot.writeMessageEnd()
4005 
    self._oprot.trans.flush()
4006 
 
4007 
  def recv_changeItem(self, ):
4008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4009 
    if mtype == TMessageType.EXCEPTION:
4010 
      x = TApplicationException()
4011 
      x.read(self._iprot)
4012 
      self._iprot.readMessageEnd()
4013 
      raise x
4014 
    result = changeItem_result()
4015 
    result.read(self._iprot)
4016 
    self._iprot.readMessageEnd()
4017 
    if result.success is not None:
4018 
      return result.success
4019 
    if result.ex is not None:
4020 
      raise result.ex
4021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4022 
 
4023 
  def shiftToWarehouse(self, orderId, warehouseId):
4024 
    """
4025 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4026 
 
4027 
    Parameters:
4028 
     - orderId
4029 
     - warehouseId
4030 
    """
4031 
    self.send_shiftToWarehouse(orderId, warehouseId)
4032 
    return self.recv_shiftToWarehouse()
4033 
 
4034 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4035 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4036 
    args = shiftToWarehouse_args()
4037 
    args.orderId = orderId
4038 
    args.warehouseId = warehouseId
4039 
    args.write(self._oprot)
4040 
    self._oprot.writeMessageEnd()
4041 
    self._oprot.trans.flush()
4042 
 
4043 
  def recv_shiftToWarehouse(self, ):
4044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4045 
    if mtype == TMessageType.EXCEPTION:
4046 
      x = TApplicationException()
4047 
      x.read(self._iprot)
4048 
      self._iprot.readMessageEnd()
4049 
      raise x
4050 
    result = shiftToWarehouse_result()
4051 
    result.read(self._iprot)
4052 
    self._iprot.readMessageEnd()
4053 
    if result.success is not None:
4054 
      return result.success
4055 
    if result.ex is not None:
4056 
      raise result.ex
4057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4058 
 
4647 rajveer 4059 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4060 
    """
4061 
    Adds the given delay reason to the given order.
3986 chandransh 4062 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4063 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4064 
 
3553 chandransh 4065 
    Parameters:
4066 
     - orderId
4067 
     - delayReason
3986 chandransh 4068 
     - furtherDelay
4647 rajveer 4069 
     - delayReasonText
3553 chandransh 4070 
    """
4647 rajveer 4071 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4072 
    return self.recv_addDelayReason()
4073 
 
4647 rajveer 4074 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4075 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4076 
    args = addDelayReason_args()
4077 
    args.orderId = orderId
4078 
    args.delayReason = delayReason
3986 chandransh 4079 
    args.furtherDelay = furtherDelay
4647 rajveer 4080 
    args.delayReasonText = delayReasonText
3553 chandransh 4081 
    args.write(self._oprot)
4082 
    self._oprot.writeMessageEnd()
4083 
    self._oprot.trans.flush()
4084 
 
4085 
  def recv_addDelayReason(self, ):
4086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4087 
    if mtype == TMessageType.EXCEPTION:
4088 
      x = TApplicationException()
4089 
      x.read(self._iprot)
4090 
      self._iprot.readMessageEnd()
4091 
      raise x
4092 
    result = addDelayReason_result()
4093 
    result.read(self._iprot)
4094 
    self._iprot.readMessageEnd()
4095 
    if result.success is not None:
4096 
      return result.success
4097 
    if result.ex is not None:
4098 
      raise result.ex
4099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4100 
 
3956 chandransh 4101 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4102 
    """
4103 
    Marks the COD orders with given AWB nos. as having been processed.
4104 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4105 
 
3956 chandransh 4106 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4107 
    1. There is no order corresponding to an AWB number.
4108 
    2. The captured amount for a payment exceeds the total payment.
4109 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4110 
 
4111 
    Parameters:
4112 
     - collectedAmountMap
4113 
     - xferBy
4114 
     - xferTxnId
4115 
     - xferDate
4116 
    """
4117 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4118 
    return self.recv_reconcileCodCollection()
4119 
 
4120 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4121 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4122 
    args = reconcileCodCollection_args()
4123 
    args.collectedAmountMap = collectedAmountMap
4124 
    args.xferBy = xferBy
4125 
    args.xferTxnId = xferTxnId
4126 
    args.xferDate = xferDate
4127 
    args.write(self._oprot)
4128 
    self._oprot.writeMessageEnd()
4129 
    self._oprot.trans.flush()
4130 
 
4131 
  def recv_reconcileCodCollection(self, ):
4132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4133 
    if mtype == TMessageType.EXCEPTION:
4134 
      x = TApplicationException()
4135 
      x.read(self._iprot)
4136 
      self._iprot.readMessageEnd()
4137 
      raise x
4138 
    result = reconcileCodCollection_result()
4139 
    result.read(self._iprot)
4140 
    self._iprot.readMessageEnd()
4141 
    if result.success is not None:
4142 
      return result.success
4143 
    if result.ex is not None:
4144 
      raise result.ex
4145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4146 
 
4008 mandeep.dh 4147 
  def getTransactionsRequiringExtraProcessing(self, category):
4148 
    """
4065 mandeep.dh 4149 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4150 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4151 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4152 
 
4008 mandeep.dh 4153 
    Parameters:
4154 
     - category
4155 
    """
4156 
    self.send_getTransactionsRequiringExtraProcessing(category)
4157 
    return self.recv_getTransactionsRequiringExtraProcessing()
4158 
 
4159 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4160 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4161 
    args = getTransactionsRequiringExtraProcessing_args()
4162 
    args.category = category
4163 
    args.write(self._oprot)
4164 
    self._oprot.writeMessageEnd()
4165 
    self._oprot.trans.flush()
4166 
 
4167 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4169 
    if mtype == TMessageType.EXCEPTION:
4170 
      x = TApplicationException()
4171 
      x.read(self._iprot)
4172 
      self._iprot.readMessageEnd()
4173 
      raise x
4174 
    result = getTransactionsRequiringExtraProcessing_result()
4175 
    result.read(self._iprot)
4176 
    self._iprot.readMessageEnd()
4177 
    if result.success is not None:
4178 
      return result.success
4179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4180 
 
4181 
  def markTransactionAsProcessed(self, transactionId, category):
4182 
    """
4183 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4184 
    It essentially deletes the transaction id record for a particular
4185 
    processing type category (if present) from DB.
4186 
    This is currently used by CRM application.
4008 mandeep.dh 4187 
 
4188 
    Parameters:
4189 
     - transactionId
4190 
     - category
4191 
    """
4192 
    self.send_markTransactionAsProcessed(transactionId, category)
4193 
    self.recv_markTransactionAsProcessed()
4194 
 
4195 
  def send_markTransactionAsProcessed(self, transactionId, category):
4196 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4197 
    args = markTransactionAsProcessed_args()
4198 
    args.transactionId = transactionId
4199 
    args.category = category
4200 
    args.write(self._oprot)
4201 
    self._oprot.writeMessageEnd()
4202 
    self._oprot.trans.flush()
4203 
 
4204 
  def recv_markTransactionAsProcessed(self, ):
4205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4206 
    if mtype == TMessageType.EXCEPTION:
4207 
      x = TApplicationException()
4208 
      x.read(self._iprot)
4209 
      self._iprot.readMessageEnd()
4210 
      raise x
4211 
    result = markTransactionAsProcessed_result()
4212 
    result.read(self._iprot)
4213 
    self._iprot.readMessageEnd()
4214 
    return
4215 
 
4018 chandransh 4216 
  def getItemWiseRiskyOrdersCount(self, ):
4217 
    """
4218 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4219 
    is defined as one whose shipping date is about to expire.
4220 
    """
4221 
    self.send_getItemWiseRiskyOrdersCount()
4222 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4223 
 
4018 chandransh 4224 
  def send_getItemWiseRiskyOrdersCount(self, ):
4225 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4226 
    args = getItemWiseRiskyOrdersCount_args()
4227 
    args.write(self._oprot)
4228 
    self._oprot.writeMessageEnd()
4229 
    self._oprot.trans.flush()
4230 
 
4231 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4233 
    if mtype == TMessageType.EXCEPTION:
4234 
      x = TApplicationException()
4235 
      x.read(self._iprot)
4236 
      self._iprot.readMessageEnd()
4237 
      raise x
4238 
    result = getItemWiseRiskyOrdersCount_result()
4239 
    result.read(self._iprot)
4240 
    self._iprot.readMessageEnd()
4241 
    if result.success is not None:
4242 
      return result.success
4243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4244 
 
4295 varun.gupt 4245 
  def getOrdersForItemIds(self, itemIds):
4246 
    """
4247 
    Returns a list of all orders which have items with given id
4248 
 
4249 
    Parameters:
4250 
     - itemIds
4251 
    """
4252 
    self.send_getOrdersForItemIds(itemIds)
4253 
    return self.recv_getOrdersForItemIds()
4254 
 
4255 
  def send_getOrdersForItemIds(self, itemIds):
4256 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4257 
    args = getOrdersForItemIds_args()
4258 
    args.itemIds = itemIds
4259 
    args.write(self._oprot)
4260 
    self._oprot.writeMessageEnd()
4261 
    self._oprot.trans.flush()
4262 
 
4263 
  def recv_getOrdersForItemIds(self, ):
4264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4265 
    if mtype == TMessageType.EXCEPTION:
4266 
      x = TApplicationException()
4267 
      x.read(self._iprot)
4268 
      self._iprot.readMessageEnd()
4269 
      raise x
4270 
    result = getOrdersForItemIds_result()
4271 
    result.read(self._iprot)
4272 
    self._iprot.readMessageEnd()
4273 
    if result.success is not None:
4274 
      return result.success
4275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4276 
 
4247 rajveer 4277 
  def markOrderCancellationRequestReceived(self, orderId):
4278 
    """
4279 
    Mark order as cancellation request received. If customer sends request of cancellation of
4280 
    a particular order, this method will be called. It will just change status of the order
4281 
    depending on its current status. It also records the previous status, so that we can move
4282 
    back to that status if cancellation request is denied.
4018 chandransh 4283 
 
4247 rajveer 4284 
    Parameters:
4285 
     - orderId
4286 
    """
4287 
    self.send_markOrderCancellationRequestReceived(orderId)
4288 
    self.recv_markOrderCancellationRequestReceived()
4289 
 
4290 
  def send_markOrderCancellationRequestReceived(self, orderId):
4291 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4292 
    args = markOrderCancellationRequestReceived_args()
4293 
    args.orderId = orderId
4294 
    args.write(self._oprot)
4295 
    self._oprot.writeMessageEnd()
4296 
    self._oprot.trans.flush()
4297 
 
4298 
  def recv_markOrderCancellationRequestReceived(self, ):
4299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4300 
    if mtype == TMessageType.EXCEPTION:
4301 
      x = TApplicationException()
4302 
      x.read(self._iprot)
4303 
      self._iprot.readMessageEnd()
4304 
      raise x
4305 
    result = markOrderCancellationRequestReceived_result()
4306 
    result.read(self._iprot)
4307 
    self._iprot.readMessageEnd()
4308 
    if result.ex is not None:
4309 
      raise result.ex
4310 
    return
4311 
 
4312 
  def markOrderCancellationRequestConfirmed(self, orderId):
4313 
    """
4314 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4315 
    cancellation request confirmed. After this OM will be able to cancel the order.
4316 
 
4317 
    Parameters:
4318 
     - orderId
4319 
    """
4320 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4321 
    self.recv_markOrderCancellationRequestConfirmed()
4322 
 
4323 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4324 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4325 
    args = markOrderCancellationRequestConfirmed_args()
4326 
    args.orderId = orderId
4327 
    args.write(self._oprot)
4328 
    self._oprot.writeMessageEnd()
4329 
    self._oprot.trans.flush()
4330 
 
4331 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4333 
    if mtype == TMessageType.EXCEPTION:
4334 
      x = TApplicationException()
4335 
      x.read(self._iprot)
4336 
      self._iprot.readMessageEnd()
4337 
      raise x
4338 
    result = markOrderCancellationRequestConfirmed_result()
4339 
    result.read(self._iprot)
4340 
    self._iprot.readMessageEnd()
4341 
    if result.ex is not None:
4342 
      raise result.ex
4343 
    return
4344 
 
4345 
  def markOrderCancellationRequestDenied(self, orderId):
4346 
    """
4347 
    If we decide to not to cancel order, we will move the order ro previous status.
4348 
 
4349 
    Parameters:
4350 
     - orderId
4351 
    """
4352 
    self.send_markOrderCancellationRequestDenied(orderId)
4353 
    self.recv_markOrderCancellationRequestDenied()
4354 
 
4355 
  def send_markOrderCancellationRequestDenied(self, orderId):
4356 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4357 
    args = markOrderCancellationRequestDenied_args()
4358 
    args.orderId = orderId
4359 
    args.write(self._oprot)
4360 
    self._oprot.writeMessageEnd()
4361 
    self._oprot.trans.flush()
4362 
 
4363 
  def recv_markOrderCancellationRequestDenied(self, ):
4364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4365 
    if mtype == TMessageType.EXCEPTION:
4366 
      x = TApplicationException()
4367 
      x.read(self._iprot)
4368 
      self._iprot.readMessageEnd()
4369 
      raise x
4370 
    result = markOrderCancellationRequestDenied_result()
4371 
    result.read(self._iprot)
4372 
    self._iprot.readMessageEnd()
4373 
    if result.ex is not None:
4374 
      raise result.ex
4375 
    return
4376 
 
4258 rajveer 4377 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4378 
    """
4258 rajveer 4379 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4380 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4381 
 
4382 
    Parameters:
4258 rajveer 4383 
     - transactionId
4247 rajveer 4384 
    """
4258 rajveer 4385 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4386 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4387 
 
4258 rajveer 4388 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4389 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4390 
    args = markTransactionAsPaymentFlagRemoved_args()
4391 
    args.transactionId = transactionId
4247 rajveer 4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4258 rajveer 4396 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4258 rajveer 4403 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.ex is not None:
4407 
      raise result.ex
4408 
    return
4409 
 
4259 anupam.sin 4410 
  def refundTransaction(self, transactionId, refundedBy, reason):
4411 
    """
4412 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4413 
    need to be cancelled
4247 rajveer 4414 
 
4259 anupam.sin 4415 
    Parameters:
4416 
     - transactionId
4417 
     - refundedBy
4418 
     - reason
4419 
    """
4420 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4421 
    self.recv_refundTransaction()
4422 
 
4423 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4424 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4425 
    args = refundTransaction_args()
4426 
    args.transactionId = transactionId
4427 
    args.refundedBy = refundedBy
4428 
    args.reason = reason
4429 
    args.write(self._oprot)
4430 
    self._oprot.writeMessageEnd()
4431 
    self._oprot.trans.flush()
4432 
 
4433 
  def recv_refundTransaction(self, ):
4434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4435 
    if mtype == TMessageType.EXCEPTION:
4436 
      x = TApplicationException()
4437 
      x.read(self._iprot)
4438 
      self._iprot.readMessageEnd()
4439 
      raise x
4440 
    result = refundTransaction_result()
4441 
    result.read(self._iprot)
4442 
    self._iprot.readMessageEnd()
4443 
    if result.ex is not None:
4444 
      raise result.ex
4445 
    return
4446 
 
4324 mandeep.dh 4447 
  def updateShipmentAddress(self, orderId, addressId):
4448 
    """
4449 
    Updates shipment address of an order. Delivery and shipping date estimates
4450 
    etc. are also updated here.
4451 
 
4452 
    Throws TransactionServiceException in case address change is not
4453 
    possible due to certain reasons such as new pincode in address is
4454 
    not serviceable etc.
4455 
 
4456 
    Parameters:
4457 
     - orderId
4458 
     - addressId
4459 
    """
4460 
    self.send_updateShipmentAddress(orderId, addressId)
4461 
    self.recv_updateShipmentAddress()
4462 
 
4463 
  def send_updateShipmentAddress(self, orderId, addressId):
4464 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4465 
    args = updateShipmentAddress_args()
4466 
    args.orderId = orderId
4467 
    args.addressId = addressId
4468 
    args.write(self._oprot)
4469 
    self._oprot.writeMessageEnd()
4470 
    self._oprot.trans.flush()
4471 
 
4472 
  def recv_updateShipmentAddress(self, ):
4473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4474 
    if mtype == TMessageType.EXCEPTION:
4475 
      x = TApplicationException()
4476 
      x.read(self._iprot)
4477 
      self._iprot.readMessageEnd()
4478 
      raise x
4479 
    result = updateShipmentAddress_result()
4480 
    result.read(self._iprot)
4481 
    self._iprot.readMessageEnd()
4482 
    if result.ex is not None:
4483 
      raise result.ex
4484 
    return
4485 
 
4285 rajveer 4486 
  def acceptOrdersForItemId(self, itemId, inventory):
4487 
    """
4488 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4489 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4490 
 
4285 rajveer 4491 
    Parameters:
4492 
     - itemId
4493 
     - inventory
4494 
    """
4495 
    self.send_acceptOrdersForItemId(itemId, inventory)
4496 
    return self.recv_acceptOrdersForItemId()
4497 
 
4498 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4499 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4500 
    args = acceptOrdersForItemId_args()
4501 
    args.itemId = itemId
4502 
    args.inventory = inventory
4503 
    args.write(self._oprot)
4504 
    self._oprot.writeMessageEnd()
4505 
    self._oprot.trans.flush()
4506 
 
4507 
  def recv_acceptOrdersForItemId(self, ):
4508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4509 
    if mtype == TMessageType.EXCEPTION:
4510 
      x = TApplicationException()
4511 
      x.read(self._iprot)
4512 
      self._iprot.readMessageEnd()
4513 
      raise x
4514 
    result = acceptOrdersForItemId_result()
4515 
    result.read(self._iprot)
4516 
    self._iprot.readMessageEnd()
4517 
    if result.success is not None:
4518 
      return result.success
4519 
    if result.ex is not None:
4520 
      raise result.ex
4521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4522 
 
4369 rajveer 4523 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4524 
    """
4525 
    Parameters:
4526 
     - vendorId
4527 
     - itemId
4528 
     - quantity
4529 
     - estimate
4369 rajveer 4530 
     - isReminder
4303 rajveer 4531 
    """
4369 rajveer 4532 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4533 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4534 
 
4369 rajveer 4535 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4536 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4537 
    args = markOrdersAsPORaised_args()
4538 
    args.vendorId = vendorId
4539 
    args.itemId = itemId
4540 
    args.quantity = quantity
4541 
    args.estimate = estimate
4369 rajveer 4542 
    args.isReminder = isReminder
4303 rajveer 4543 
    args.write(self._oprot)
4544 
    self._oprot.writeMessageEnd()
4545 
    self._oprot.trans.flush()
4546 
 
4547 
  def recv_markOrdersAsPORaised(self, ):
4548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4549 
    if mtype == TMessageType.EXCEPTION:
4550 
      x = TApplicationException()
4551 
      x.read(self._iprot)
4552 
      self._iprot.readMessageEnd()
4553 
      raise x
4554 
    result = markOrdersAsPORaised_result()
4555 
    result.read(self._iprot)
4556 
    self._iprot.readMessageEnd()
4557 
    if result.ex is not None:
4558 
      raise result.ex
4559 
    return
4560 
 
4369 rajveer 4561 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4562 
    """
4563 
    Parameters:
4564 
     - vendorId
4565 
     - itemId
4566 
     - quantity
4567 
     - estimate
4369 rajveer 4568 
     - isReminder
4303 rajveer 4569 
    """
4369 rajveer 4570 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4571 
    self.recv_markOrdersAsReversalInitiated()
4572 
 
4369 rajveer 4573 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4574 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4575 
    args = markOrdersAsReversalInitiated_args()
4576 
    args.vendorId = vendorId
4577 
    args.itemId = itemId
4578 
    args.quantity = quantity
4579 
    args.estimate = estimate
4369 rajveer 4580 
    args.isReminder = isReminder
4303 rajveer 4581 
    args.write(self._oprot)
4582 
    self._oprot.writeMessageEnd()
4583 
    self._oprot.trans.flush()
4584 
 
4585 
  def recv_markOrdersAsReversalInitiated(self, ):
4586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4587 
    if mtype == TMessageType.EXCEPTION:
4588 
      x = TApplicationException()
4589 
      x.read(self._iprot)
4590 
      self._iprot.readMessageEnd()
4591 
      raise x
4592 
    result = markOrdersAsReversalInitiated_result()
4593 
    result.read(self._iprot)
4594 
    self._iprot.readMessageEnd()
4595 
    if result.ex is not None:
4596 
      raise result.ex
4597 
    return
4598 
 
4369 rajveer 4599 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4600 
    """
4601 
    Parameters:
4602 
     - vendorId
4603 
     - itemId
4604 
     - quantity
4605 
     - estimate
4369 rajveer 4606 
     - isReminder
4303 rajveer 4607 
    """
4369 rajveer 4608 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4609 
    self.recv_markOrdersAsNotAvailabke()
4610 
 
4369 rajveer 4611 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4612 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4613 
    args = markOrdersAsNotAvailabke_args()
4614 
    args.vendorId = vendorId
4615 
    args.itemId = itemId
4616 
    args.quantity = quantity
4617 
    args.estimate = estimate
4369 rajveer 4618 
    args.isReminder = isReminder
4303 rajveer 4619 
    args.write(self._oprot)
4620 
    self._oprot.writeMessageEnd()
4621 
    self._oprot.trans.flush()
4622 
 
4623 
  def recv_markOrdersAsNotAvailabke(self, ):
4624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4625 
    if mtype == TMessageType.EXCEPTION:
4626 
      x = TApplicationException()
4627 
      x.read(self._iprot)
4628 
      self._iprot.readMessageEnd()
4629 
      raise x
4630 
    result = markOrdersAsNotAvailabke_result()
4631 
    result.read(self._iprot)
4632 
    self._iprot.readMessageEnd()
4633 
    if result.ex is not None:
4634 
      raise result.ex
4635 
    return
4636 
 
4369 rajveer 4637 
  def markOrdersAsTimeout(self, vendorId):
4638 
    """
4639 
    Parameters:
4640 
     - vendorId
4641 
    """
4642 
    self.send_markOrdersAsTimeout(vendorId)
4643 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4644 
 
4369 rajveer 4645 
  def send_markOrdersAsTimeout(self, vendorId):
4646 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4647 
    args = markOrdersAsTimeout_args()
4648 
    args.vendorId = vendorId
4649 
    args.write(self._oprot)
4650 
    self._oprot.writeMessageEnd()
4651 
    self._oprot.trans.flush()
4652 
 
4653 
  def recv_markOrdersAsTimeout(self, ):
4654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4655 
    if mtype == TMessageType.EXCEPTION:
4656 
      x = TApplicationException()
4657 
      x.read(self._iprot)
4658 
      self._iprot.readMessageEnd()
4659 
      raise x
4660 
    result = markOrdersAsTimeout_result()
4661 
    result.read(self._iprot)
4662 
    self._iprot.readMessageEnd()
4663 
    if result.success is not None:
4664 
      return result.success
4665 
    if result.ex is not None:
4666 
      raise result.ex
4667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4668 
 
4662 rajveer 4669 
  def markOrderAsLostInTransit(self, orderId):
4670 
    """
4671 
    Mark order as LOST_IN_TRANSIT
4672 
 
4673 
    Parameters:
4674 
     - orderId
4675 
    """
4676 
    self.send_markOrderAsLostInTransit(orderId)
4677 
    return self.recv_markOrderAsLostInTransit()
4678 
 
4679 
  def send_markOrderAsLostInTransit(self, orderId):
4680 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4681 
    args = markOrderAsLostInTransit_args()
4682 
    args.orderId = orderId
4683 
    args.write(self._oprot)
4684 
    self._oprot.writeMessageEnd()
4685 
    self._oprot.trans.flush()
4686 
 
4687 
  def recv_markOrderAsLostInTransit(self, ):
4688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4689 
    if mtype == TMessageType.EXCEPTION:
4690 
      x = TApplicationException()
4691 
      x.read(self._iprot)
4692 
      self._iprot.readMessageEnd()
4693 
      raise x
4694 
    result = markOrderAsLostInTransit_result()
4695 
    result.read(self._iprot)
4696 
    self._iprot.readMessageEnd()
4697 
    if result.success is not None:
4698 
      return result.success
4699 
    if result.ex is not None:
4700 
      raise result.ex
4701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4702 
 
4386 anupam.sin 4703 
  def getOrderForAwb(self, awb):
4704 
    """
4705 
    Returns the order corresponding to an AWB number
4369 rajveer 4706 
 
4386 anupam.sin 4707 
    Parameters:
4708 
     - awb
4709 
    """
4710 
    self.send_getOrderForAwb(awb)
4711 
    return self.recv_getOrderForAwb()
4712 
 
4713 
  def send_getOrderForAwb(self, awb):
4714 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4715 
    args = getOrderForAwb_args()
4716 
    args.awb = awb
4717 
    args.write(self._oprot)
4718 
    self._oprot.writeMessageEnd()
4719 
    self._oprot.trans.flush()
4720 
 
4721 
  def recv_getOrderForAwb(self, ):
4722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4723 
    if mtype == TMessageType.EXCEPTION:
4724 
      x = TApplicationException()
4725 
      x.read(self._iprot)
4726 
      self._iprot.readMessageEnd()
4727 
      raise x
4728 
    result = getOrderForAwb_result()
4729 
    result.read(self._iprot)
4730 
    self._iprot.readMessageEnd()
4731 
    if result.success is not None:
4732 
      return result.success
4733 
    if result.ex is not None:
4734 
      raise result.ex
4735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4736 
 
4910 phani.kuma 4737 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4738 
    """
4910 phani.kuma 4739 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4740 
 
4506 phani.kuma 4741 
    Parameters:
4742 
     - logistics_provider_id
4910 phani.kuma 4743 
     - order_status_list
4506 phani.kuma 4744 
    """
4910 phani.kuma 4745 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4746 
    return self.recv_getOrdersForProviderForStatus()
4747 
 
4910 phani.kuma 4748 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4749 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4750 
    args = getOrdersForProviderForStatus_args()
4751 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4752 
    args.order_status_list = order_status_list
4506 phani.kuma 4753 
    args.write(self._oprot)
4754 
    self._oprot.writeMessageEnd()
4755 
    self._oprot.trans.flush()
4756 
 
4757 
  def recv_getOrdersForProviderForStatus(self, ):
4758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4759 
    if mtype == TMessageType.EXCEPTION:
4760 
      x = TApplicationException()
4761 
      x.read(self._iprot)
4762 
      self._iprot.readMessageEnd()
4763 
      raise x
4764 
    result = getOrdersForProviderForStatus_result()
4765 
    result.read(self._iprot)
4766 
    self._iprot.readMessageEnd()
4767 
    if result.success is not None:
4768 
      return result.success
4769 
    if result.ex is not None:
4770 
      raise result.ex
4771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4772 
 
4600 varun.gupt 4773 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4774 
    """
4775 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4776 
 
4600 varun.gupt 4777 
    Parameters:
4778 
     - vendorId
4779 
     - billingDateFrom
4780 
     - billingDateTo
4781 
    """
4782 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4783 
    return self.recv_getBilledOrdersForVendor()
4784 
 
4785 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4786 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4787 
    args = getBilledOrdersForVendor_args()
4788 
    args.vendorId = vendorId
4789 
    args.billingDateFrom = billingDateFrom
4790 
    args.billingDateTo = billingDateTo
4791 
    args.write(self._oprot)
4792 
    self._oprot.writeMessageEnd()
4793 
    self._oprot.trans.flush()
4794 
 
4795 
  def recv_getBilledOrdersForVendor(self, ):
4796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4797 
    if mtype == TMessageType.EXCEPTION:
4798 
      x = TApplicationException()
4799 
      x.read(self._iprot)
4800 
      self._iprot.readMessageEnd()
4801 
      raise x
4802 
    result = getBilledOrdersForVendor_result()
4803 
    result.read(self._iprot)
4804 
    self._iprot.readMessageEnd()
4805 
    if result.success is not None:
4806 
      return result.success
4807 
    if result.ex is not None:
4808 
      raise result.ex
4809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4810 
 
4607 rajveer 4811 
  def getSlippedSippingDateOrders(self, ):
4812 
    self.send_getSlippedSippingDateOrders()
4813 
    return self.recv_getSlippedSippingDateOrders()
4814 
 
4815 
  def send_getSlippedSippingDateOrders(self, ):
4816 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4817 
    args = getSlippedSippingDateOrders_args()
4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_getSlippedSippingDateOrders(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = getSlippedSippingDateOrders_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.success is not None:
4833 
      return result.success
4834 
    if result.ex is not None:
4835 
      raise result.ex
4836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4837 
 
4709 rajveer 4838 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4839 
    """
4840 
    Parameters:
4841 
     - cancelDateFrom
4842 
     - cancelDateTo
4843 
    """
4844 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4845 
    return self.recv_getCancelledOrders()
4846 
 
4847 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4848 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4849 
    args = getCancelledOrders_args()
4850 
    args.cancelDateFrom = cancelDateFrom
4851 
    args.cancelDateTo = cancelDateTo
4852 
    args.write(self._oprot)
4853 
    self._oprot.writeMessageEnd()
4854 
    self._oprot.trans.flush()
4855 
 
4856 
  def recv_getCancelledOrders(self, ):
4857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4858 
    if mtype == TMessageType.EXCEPTION:
4859 
      x = TApplicationException()
4860 
      x.read(self._iprot)
4861 
      self._iprot.readMessageEnd()
4862 
      raise x
4863 
    result = getCancelledOrders_result()
4864 
    result.read(self._iprot)
4865 
    self._iprot.readMessageEnd()
4866 
    if result.success is not None:
4867 
      return result.success
4868 
    if result.ex is not None:
4869 
      raise result.ex
4870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4871 
 
4600 varun.gupt 4872 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4873 
    """
4874 
    Parameters:
4875 
     - mapAWBAndAmount
4876 
    """
4877 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4878 
    self.recv_saveBluedartSettlements()
4879 
 
4880 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4881 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4882 
    args = saveBluedartSettlements_args()
4883 
    args.mapAWBAndAmount = mapAWBAndAmount
4884 
    args.write(self._oprot)
4885 
    self._oprot.writeMessageEnd()
4886 
    self._oprot.trans.flush()
4887 
 
4888 
  def recv_saveBluedartSettlements(self, ):
4889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4890 
    if mtype == TMessageType.EXCEPTION:
4891 
      x = TApplicationException()
4892 
      x.read(self._iprot)
4893 
      self._iprot.readMessageEnd()
4894 
      raise x
4895 
    result = saveBluedartSettlements_result()
4896 
    result.read(self._iprot)
4897 
    self._iprot.readMessageEnd()
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    return
4901 
 
4905 varun.gupt 4902 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4903 
    """
4904 
    Parameters:
4905 
     - settlementDate
4906 
     - paymentGatewayId
4905 varun.gupt 4907 
     - referenceId
4600 varun.gupt 4908 
     - serviceTax
4909 
     - otherCharges
4910 
     - netCollection
4911 
    """
4905 varun.gupt 4912 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4913 
    self.recv_savePaymentSettlements()
4914 
 
4905 varun.gupt 4915 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4916 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4917 
    args = savePaymentSettlements_args()
4918 
    args.settlementDate = settlementDate
4919 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4920 
    args.referenceId = referenceId
4600 varun.gupt 4921 
    args.serviceTax = serviceTax
4922 
    args.otherCharges = otherCharges
4923 
    args.netCollection = netCollection
4924 
    args.write(self._oprot)
4925 
    self._oprot.writeMessageEnd()
4926 
    self._oprot.trans.flush()
4927 
 
4928 
  def recv_savePaymentSettlements(self, ):
4929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4930 
    if mtype == TMessageType.EXCEPTION:
4931 
      x = TApplicationException()
4932 
      x.read(self._iprot)
4933 
      self._iprot.readMessageEnd()
4934 
      raise x
4935 
    result = savePaymentSettlements_result()
4936 
    result.read(self._iprot)
4937 
    self._iprot.readMessageEnd()
4938 
    if result.ex is not None:
4939 
      raise result.ex
4940 
    return
4941 
 
4942 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4943 
    """
4944 
    Parameters:
4945 
     - settlementId
4946 
     - settlementDate
4947 
     - transactionDateFrom
4948 
     - transactionDateTo
4949 
     - amount
4950 
    """
4951 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4952 
    self.recv_saveEBSSettlementSummary()
4953 
 
4954 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4955 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4956 
    args = saveEBSSettlementSummary_args()
4957 
    args.settlementId = settlementId
4958 
    args.settlementDate = settlementDate
4959 
    args.transactionDateFrom = transactionDateFrom
4960 
    args.transactionDateTo = transactionDateTo
4961 
    args.amount = amount
4962 
    args.write(self._oprot)
4963 
    self._oprot.writeMessageEnd()
4964 
    self._oprot.trans.flush()
4965 
 
4966 
  def recv_saveEBSSettlementSummary(self, ):
4967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4968 
    if mtype == TMessageType.EXCEPTION:
4969 
      x = TApplicationException()
4970 
      x.read(self._iprot)
4971 
      self._iprot.readMessageEnd()
4972 
      raise x
4973 
    result = saveEBSSettlementSummary_result()
4974 
    result.read(self._iprot)
4975 
    self._iprot.readMessageEnd()
4976 
    if result.ex is not None:
4977 
      raise result.ex
4978 
    return
4979 
 
5386 phani.kuma 4980 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4981 
    """
4982 
    Parameters:
5189 varun.gupt 4983 
     - referenceId
4984 
     - isRefund
4600 varun.gupt 4985 
    """
5386 phani.kuma 4986 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4987 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4988 
 
5386 phani.kuma 4989 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4990 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4991 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4992 
    args.referenceId = referenceId
4993 
    args.isRefund = isRefund
4600 varun.gupt 4994 
    args.write(self._oprot)
4995 
    self._oprot.writeMessageEnd()
4996 
    self._oprot.trans.flush()
4997 
 
5386 phani.kuma 4998 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5000 
    if mtype == TMessageType.EXCEPTION:
5001 
      x = TApplicationException()
5002 
      x.read(self._iprot)
5003 
      self._iprot.readMessageEnd()
5004 
      raise x
5386 phani.kuma 5005 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5006 
    result.read(self._iprot)
5007 
    self._iprot.readMessageEnd()
5008 
    if result.success is not None:
5009 
      return result.success
5010 
    if result.ex is not None:
5011 
      raise result.ex
5386 phani.kuma 5012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5013 
 
5386 phani.kuma 5014 
  def getSettlementForCod(self, orderId, isRefund):
5015 
    """
5016 
    Parameters:
5017 
     - orderId
5018 
     - isRefund
5019 
    """
5020 
    self.send_getSettlementForCod(orderId, isRefund)
5021 
    return self.recv_getSettlementForCod()
5022 
 
5023 
  def send_getSettlementForCod(self, orderId, isRefund):
5024 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5025 
    args = getSettlementForCod_args()
5026 
    args.orderId = orderId
5027 
    args.isRefund = isRefund
5028 
    args.write(self._oprot)
5029 
    self._oprot.writeMessageEnd()
5030 
    self._oprot.trans.flush()
5031 
 
5032 
  def recv_getSettlementForCod(self, ):
5033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5034 
    if mtype == TMessageType.EXCEPTION:
5035 
      x = TApplicationException()
5036 
      x.read(self._iprot)
5037 
      self._iprot.readMessageEnd()
5038 
      raise x
5039 
    result = getSettlementForCod_result()
5040 
    result.read(self._iprot)
5041 
    self._iprot.readMessageEnd()
5042 
    if result.success is not None:
5043 
      return result.success
5044 
    if result.ex is not None:
5045 
      raise result.ex
5046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5047 
 
4600 varun.gupt 5048 
  def getEBSSettlementSummaries(self, ):
5049 
    self.send_getEBSSettlementSummaries()
5050 
    return self.recv_getEBSSettlementSummaries()
5051 
 
5052 
  def send_getEBSSettlementSummaries(self, ):
5053 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5054 
    args = getEBSSettlementSummaries_args()
5055 
    args.write(self._oprot)
5056 
    self._oprot.writeMessageEnd()
5057 
    self._oprot.trans.flush()
5058 
 
5059 
  def recv_getEBSSettlementSummaries(self, ):
5060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5061 
    if mtype == TMessageType.EXCEPTION:
5062 
      x = TApplicationException()
5063 
      x.read(self._iprot)
5064 
      self._iprot.readMessageEnd()
5065 
      raise x
5066 
    result = getEBSSettlementSummaries_result()
5067 
    result.read(self._iprot)
5068 
    self._iprot.readMessageEnd()
5069 
    if result.success is not None:
5070 
      return result.success
5071 
    if result.ex is not None:
5072 
      raise result.ex
5073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5074 
 
5075 
  def markEBSSettlementUploaded(self, settlementId):
5076 
    """
5077 
    Parameters:
5078 
     - settlementId
5079 
    """
5080 
    self.send_markEBSSettlementUploaded(settlementId)
5081 
    self.recv_markEBSSettlementUploaded()
5082 
 
5083 
  def send_markEBSSettlementUploaded(self, settlementId):
5084 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5085 
    args = markEBSSettlementUploaded_args()
5086 
    args.settlementId = settlementId
5087 
    args.write(self._oprot)
5088 
    self._oprot.writeMessageEnd()
5089 
    self._oprot.trans.flush()
5090 
 
5091 
  def recv_markEBSSettlementUploaded(self, ):
5092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5093 
    if mtype == TMessageType.EXCEPTION:
5094 
      x = TApplicationException()
5095 
      x.read(self._iprot)
5096 
      self._iprot.readMessageEnd()
5097 
      raise x
5098 
    result = markEBSSettlementUploaded_result()
5099 
    result.read(self._iprot)
5100 
    self._iprot.readMessageEnd()
5101 
    if result.ex is not None:
5102 
      raise result.ex
5103 
    return
5104 
 
5105 
  def getEBSSettlementDate(self, settlementId):
5106 
    """
5107 
    Parameters:
5108 
     - settlementId
5109 
    """
5110 
    self.send_getEBSSettlementDate(settlementId)
5111 
    return self.recv_getEBSSettlementDate()
5112 
 
5113 
  def send_getEBSSettlementDate(self, settlementId):
5114 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5115 
    args = getEBSSettlementDate_args()
5116 
    args.settlementId = settlementId
5117 
    args.write(self._oprot)
5118 
    self._oprot.writeMessageEnd()
5119 
    self._oprot.trans.flush()
5120 
 
5121 
  def recv_getEBSSettlementDate(self, ):
5122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5123 
    if mtype == TMessageType.EXCEPTION:
5124 
      x = TApplicationException()
5125 
      x.read(self._iprot)
5126 
      self._iprot.readMessageEnd()
5127 
      raise x
5128 
    result = getEBSSettlementDate_result()
5129 
    result.read(self._iprot)
5130 
    self._iprot.readMessageEnd()
5131 
    if result.success is not None:
5132 
      return result.success
5133 
    if result.ex is not None:
5134 
      raise result.ex
5135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5136 
 
4715 varun.gupt 5137 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5138 
    """
5139 
    Parameters:
5140 
     - settlementDateFrom
5141 
     - settlementDateTo
5142 
     - isRefund
5143 
    """
5144 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5145 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5146 
 
4715 varun.gupt 5147 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5148 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5149 
    args = getSettlementsByDate_args()
5150 
    args.settlementDateFrom = settlementDateFrom
5151 
    args.settlementDateTo = settlementDateTo
5152 
    args.isRefund = isRefund
5153 
    args.write(self._oprot)
5154 
    self._oprot.writeMessageEnd()
5155 
    self._oprot.trans.flush()
5156 
 
5157 
  def recv_getSettlementsByDate(self, ):
5158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5159 
    if mtype == TMessageType.EXCEPTION:
5160 
      x = TApplicationException()
5161 
      x.read(self._iprot)
5162 
      self._iprot.readMessageEnd()
5163 
      raise x
5164 
    result = getSettlementsByDate_result()
5165 
    result.read(self._iprot)
5166 
    self._iprot.readMessageEnd()
5167 
    if result.success is not None:
5168 
      return result.success
5169 
    if result.ex is not None:
5170 
      raise result.ex
5171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5172 
 
5173 
  def getReshippedOrderIds(self, orderIds):
5174 
    """
5175 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5176 
 
5177 
    Parameters:
5178 
     - orderIds
5179 
    """
5180 
    self.send_getReshippedOrderIds(orderIds)
5181 
    return self.recv_getReshippedOrderIds()
5182 
 
5183 
  def send_getReshippedOrderIds(self, orderIds):
5184 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5185 
    args = getReshippedOrderIds_args()
5186 
    args.orderIds = orderIds
5187 
    args.write(self._oprot)
5188 
    self._oprot.writeMessageEnd()
5189 
    self._oprot.trans.flush()
5190 
 
5191 
  def recv_getReshippedOrderIds(self, ):
5192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5193 
    if mtype == TMessageType.EXCEPTION:
5194 
      x = TApplicationException()
5195 
      x.read(self._iprot)
5196 
      self._iprot.readMessageEnd()
5197 
      raise x
5198 
    result = getReshippedOrderIds_result()
5199 
    result.read(self._iprot)
5200 
    self._iprot.readMessageEnd()
5201 
    if result.success is not None:
5202 
      return result.success
5203 
    if result.ex is not None:
5204 
      raise result.ex
5205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5206 
 
5481 phani.kuma 5207 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5208 
    """
5209 
    Parameters:
5210 
     - vendorId
5481 phani.kuma 5211 
     - onlyVendorNotPaid
5212 
     - billingDateFrom
5213 
     - billingDateTo
4875 varun.gupt 5214 
    """
5481 phani.kuma 5215 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5216 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5217 
 
5481 phani.kuma 5218 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5219 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5220 
    args = getBilledOrders_args()
4875 varun.gupt 5221 
    args.vendorId = vendorId
5481 phani.kuma 5222 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5223 
    args.billingDateFrom = billingDateFrom
5224 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5225 
    args.write(self._oprot)
5226 
    self._oprot.writeMessageEnd()
5227 
    self._oprot.trans.flush()
5228 
 
5481 phani.kuma 5229 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5231 
    if mtype == TMessageType.EXCEPTION:
5232 
      x = TApplicationException()
5233 
      x.read(self._iprot)
5234 
      self._iprot.readMessageEnd()
5235 
      raise x
5481 phani.kuma 5236 
    result = getBilledOrders_result()
4875 varun.gupt 5237 
    result.read(self._iprot)
5238 
    self._iprot.readMessageEnd()
5239 
    if result.success is not None:
5240 
      return result.success
5241 
    if result.ex is not None:
5242 
      raise result.ex
5481 phani.kuma 5243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5244 
 
5031 varun.gupt 5245 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5246 
    """
5247 
    Parameters:
5248 
     - startDate
5249 
     - endDate
5250 
    """
5251 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5252 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5253 
 
5031 varun.gupt 5254 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5255 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5256 
    args = getStatusDistributionOfOrders_args()
5257 
    args.startDate = startDate
5258 
    args.endDate = endDate
5259 
    args.write(self._oprot)
5260 
    self._oprot.writeMessageEnd()
5261 
    self._oprot.trans.flush()
5262 
 
5263 
  def recv_getStatusDistributionOfOrders(self, ):
5264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5265 
    if mtype == TMessageType.EXCEPTION:
5266 
      x = TApplicationException()
5267 
      x.read(self._iprot)
5268 
      self._iprot.readMessageEnd()
5269 
      raise x
5270 
    result = getStatusDistributionOfOrders_result()
5271 
    result.read(self._iprot)
5272 
    self._iprot.readMessageEnd()
5273 
    if result.success is not None:
5274 
      return result.success
5275 
    if result.ex is not None:
5276 
      raise result.ex
5277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5278 
 
5067 varun.gupt 5279 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5280 
    """
5281 
    Parameters:
5282 
     - status
5283 
     - startDatetime
5284 
     - endDatetime
5285 
    """
5286 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5287 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5288 
 
5067 varun.gupt 5289 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5290 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5291 
    args = getOrderIdsForStatus_args()
5292 
    args.status = status
5293 
    args.startDatetime = startDatetime
5294 
    args.endDatetime = endDatetime
5295 
    args.write(self._oprot)
5296 
    self._oprot.writeMessageEnd()
5297 
    self._oprot.trans.flush()
5298 
 
5299 
  def recv_getOrderIdsForStatus(self, ):
5300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5301 
    if mtype == TMessageType.EXCEPTION:
5302 
      x = TApplicationException()
5303 
      x.read(self._iprot)
5304 
      self._iprot.readMessageEnd()
5305 
      raise x
5306 
    result = getOrderIdsForStatus_result()
5307 
    result.read(self._iprot)
5308 
    self._iprot.readMessageEnd()
5309 
    if result.success is not None:
5310 
      return result.success
5311 
    if result.ex is not None:
5312 
      raise result.ex
5313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5314 
 
5348 anupam.sin 5315 
  def updateCODAgent(self, agent, orderId):
5316 
    """
5317 
    Updates the agent who handled the COD verification call
5318 
 
5319 
    Parameters:
5320 
     - agent
5321 
     - orderId
5322 
    """
5323 
    self.send_updateCODAgent(agent, orderId)
5324 
    self.recv_updateCODAgent()
5325 
 
5326 
  def send_updateCODAgent(self, agent, orderId):
5327 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5328 
    args = updateCODAgent_args()
5329 
    args.agent = agent
5330 
    args.orderId = orderId
5331 
    args.write(self._oprot)
5332 
    self._oprot.writeMessageEnd()
5333 
    self._oprot.trans.flush()
5334 
 
5335 
  def recv_updateCODAgent(self, ):
5336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5337 
    if mtype == TMessageType.EXCEPTION:
5338 
      x = TApplicationException()
5339 
      x.read(self._iprot)
5340 
      self._iprot.readMessageEnd()
5341 
      raise x
5342 
    result = updateCODAgent_result()
5343 
    result.read(self._iprot)
5344 
    self._iprot.readMessageEnd()
5345 
    if result.ex is not None:
5346 
      raise result.ex
5347 
    return
5348 
 
5099 varun.gupt 5349 
  def updateOrderAsPaidToVendor(self, orderId):
5350 
    """
5351 
    Parameters:
5352 
     - orderId
5353 
    """
5354 
    self.send_updateOrderAsPaidToVendor(orderId)
5355 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5356 
 
5099 varun.gupt 5357 
  def send_updateOrderAsPaidToVendor(self, orderId):
5358 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5359 
    args = updateOrderAsPaidToVendor_args()
5360 
    args.orderId = orderId
5361 
    args.write(self._oprot)
5362 
    self._oprot.writeMessageEnd()
5363 
    self._oprot.trans.flush()
5364 
 
5365 
  def recv_updateOrderAsPaidToVendor(self, ):
5366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5367 
    if mtype == TMessageType.EXCEPTION:
5368 
      x = TApplicationException()
5369 
      x.read(self._iprot)
5370 
      self._iprot.readMessageEnd()
5371 
      raise x
5372 
    result = updateOrderAsPaidToVendor_result()
5373 
    result.read(self._iprot)
5374 
    self._iprot.readMessageEnd()
5375 
    if result.ex is not None:
5376 
      raise result.ex
5377 
    return
5378 
 
5386 phani.kuma 5379 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5380 
    """
5381 
    Parameters:
5382 
     - orderId
5383 
    """
5384 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5385 
    self.recv_updateOrderOnlyAsPaidToVendor()
5386 
 
5387 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5388 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5389 
    args = updateOrderOnlyAsPaidToVendor_args()
5390 
    args.orderId = orderId
5391 
    args.write(self._oprot)
5392 
    self._oprot.writeMessageEnd()
5393 
    self._oprot.trans.flush()
5394 
 
5395 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5397 
    if mtype == TMessageType.EXCEPTION:
5398 
      x = TApplicationException()
5399 
      x.read(self._iprot)
5400 
      self._iprot.readMessageEnd()
5401 
      raise x
5402 
    result = updateOrderOnlyAsPaidToVendor_result()
5403 
    result.read(self._iprot)
5404 
    self._iprot.readMessageEnd()
5405 
    if result.ex is not None:
5406 
      raise result.ex
5407 
    return
5408 
 
5208 varun.gupt 5409 
  def getRefundedOrdersMarkedPaid(self, ):
5410 
    self.send_getRefundedOrdersMarkedPaid()
5411 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5412 
 
5208 varun.gupt 5413 
  def send_getRefundedOrdersMarkedPaid(self, ):
5414 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5415 
    args = getRefundedOrdersMarkedPaid_args()
5416 
    args.write(self._oprot)
5417 
    self._oprot.writeMessageEnd()
5418 
    self._oprot.trans.flush()
5419 
 
5420 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5422 
    if mtype == TMessageType.EXCEPTION:
5423 
      x = TApplicationException()
5424 
      x.read(self._iprot)
5425 
      self._iprot.readMessageEnd()
5426 
      raise x
5427 
    result = getRefundedOrdersMarkedPaid_result()
5428 
    result.read(self._iprot)
5429 
    self._iprot.readMessageEnd()
5430 
    if result.success is not None:
5431 
      return result.success
5432 
    if result.ex is not None:
5433 
      raise result.ex
5434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5435 
 
5447 anupam.sin 5436 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5437 
    """
5438 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5439 
 
5447 anupam.sin 5440 
 
5441 
    Parameters:
5442 
     - minOrderId
5443 
     - maxOrderId
5444 
    """
5445 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5446 
    return self.recv_getAllVerificationAgents()
5447 
 
5448 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5449 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5450 
    args = getAllVerificationAgents_args()
5451 
    args.minOrderId = minOrderId
5452 
    args.maxOrderId = maxOrderId
5453 
    args.write(self._oprot)
5454 
    self._oprot.writeMessageEnd()
5455 
    self._oprot.trans.flush()
5456 
 
5457 
  def recv_getAllVerificationAgents(self, ):
5458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5459 
    if mtype == TMessageType.EXCEPTION:
5460 
      x = TApplicationException()
5461 
      x.read(self._iprot)
5462 
      self._iprot.readMessageEnd()
5463 
      raise x
5464 
    result = getAllVerificationAgents_result()
5465 
    result.read(self._iprot)
5466 
    self._iprot.readMessageEnd()
5467 
    if result.success is not None:
5468 
      return result.success
5469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5470 
 
5527 anupam.sin 5471 
  def getAllAttributesForOrderId(self, orderId):
5472 
    """
5473 
    gets all attributes for a given orderId
5447 anupam.sin 5474 
 
5527 anupam.sin 5475 
    Parameters:
5476 
     - orderId
5477 
    """
5478 
    self.send_getAllAttributesForOrderId(orderId)
5479 
    return self.recv_getAllAttributesForOrderId()
5480 
 
5481 
  def send_getAllAttributesForOrderId(self, orderId):
5482 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5483 
    args = getAllAttributesForOrderId_args()
5484 
    args.orderId = orderId
5485 
    args.write(self._oprot)
5486 
    self._oprot.writeMessageEnd()
5487 
    self._oprot.trans.flush()
5488 
 
5489 
  def recv_getAllAttributesForOrderId(self, ):
5490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5491 
    if mtype == TMessageType.EXCEPTION:
5492 
      x = TApplicationException()
5493 
      x.read(self._iprot)
5494 
      self._iprot.readMessageEnd()
5495 
      raise x
5496 
    result = getAllAttributesForOrderId_result()
5497 
    result.read(self._iprot)
5498 
    self._iprot.readMessageEnd()
5499 
    if result.success is not None:
5500 
      return result.success
5501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5502 
 
5676 rajveer 5503 
  def setOrderAttributes(self, orderId, attributes):
5504 
    """
5505 
    sets attributes for an order
5506 
 
5507 
    Parameters:
5508 
     - orderId
5509 
     - attributes
5510 
    """
5511 
    self.send_setOrderAttributes(orderId, attributes)
5512 
    self.recv_setOrderAttributes()
5513 
 
5514 
  def send_setOrderAttributes(self, orderId, attributes):
5515 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5516 
    args = setOrderAttributes_args()
5517 
    args.orderId = orderId
5518 
    args.attributes = attributes
5519 
    args.write(self._oprot)
5520 
    self._oprot.writeMessageEnd()
5521 
    self._oprot.trans.flush()
5522 
 
5523 
  def recv_setOrderAttributes(self, ):
5524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5525 
    if mtype == TMessageType.EXCEPTION:
5526 
      x = TApplicationException()
5527 
      x.read(self._iprot)
5528 
      self._iprot.readMessageEnd()
5529 
      raise x
5530 
    result = setOrderAttributes_result()
5531 
    result.read(self._iprot)
5532 
    self._iprot.readMessageEnd()
5533 
    return
5534 
 
5527 anupam.sin 5535 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5536 
    """
5537 
    sets attributes for all orders in a transaction
5538 
 
5539 
    Parameters:
5540 
     - transactionId
5541 
     - attribute
5542 
    """
5543 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5544 
    self.recv_setOrderAttributeForTransaction()
5545 
 
5546 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5547 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5548 
    args = setOrderAttributeForTransaction_args()
5549 
    args.transactionId = transactionId
5550 
    args.attribute = attribute
5551 
    args.write(self._oprot)
5552 
    self._oprot.writeMessageEnd()
5553 
    self._oprot.trans.flush()
5554 
 
5555 
  def recv_setOrderAttributeForTransaction(self, ):
5556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5557 
    if mtype == TMessageType.EXCEPTION:
5558 
      x = TApplicationException()
5559 
      x.read(self._iprot)
5560 
      self._iprot.readMessageEnd()
5561 
      raise x
5562 
    result = setOrderAttributeForTransaction_result()
5563 
    result.read(self._iprot)
5564 
    self._iprot.readMessageEnd()
5565 
    return
5566 
 
5553 rajveer 5567 
  def getReceivePendingOrders(self, storeId):
5568 
    """
5569 
    Parameters:
5570 
     - storeId
5571 
    """
5572 
    self.send_getReceivePendingOrders(storeId)
5573 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5574 
 
5553 rajveer 5575 
  def send_getReceivePendingOrders(self, storeId):
5576 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5577 
    args = getReceivePendingOrders_args()
5578 
    args.storeId = storeId
5579 
    args.write(self._oprot)
5580 
    self._oprot.writeMessageEnd()
5581 
    self._oprot.trans.flush()
5582 
 
5583 
  def recv_getReceivePendingOrders(self, ):
5584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5585 
    if mtype == TMessageType.EXCEPTION:
5586 
      x = TApplicationException()
5587 
      x.read(self._iprot)
5588 
      self._iprot.readMessageEnd()
5589 
      raise x
5590 
    result = getReceivePendingOrders_result()
5591 
    result.read(self._iprot)
5592 
    self._iprot.readMessageEnd()
5593 
    if result.success is not None:
5594 
      return result.success
5595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5596 
 
5597 
  def getReceivedAtStoreOrders(self, storeId):
5598 
    """
5599 
    Parameters:
5600 
     - storeId
5601 
    """
5602 
    self.send_getReceivedAtStoreOrders(storeId)
5603 
    return self.recv_getReceivedAtStoreOrders()
5604 
 
5605 
  def send_getReceivedAtStoreOrders(self, storeId):
5606 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5607 
    args = getReceivedAtStoreOrders_args()
5608 
    args.storeId = storeId
5609 
    args.write(self._oprot)
5610 
    self._oprot.writeMessageEnd()
5611 
    self._oprot.trans.flush()
5612 
 
5613 
  def recv_getReceivedAtStoreOrders(self, ):
5614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5615 
    if mtype == TMessageType.EXCEPTION:
5616 
      x = TApplicationException()
5617 
      x.read(self._iprot)
5618 
      self._iprot.readMessageEnd()
5619 
      raise x
5620 
    result = getReceivedAtStoreOrders_result()
5621 
    result.read(self._iprot)
5622 
    self._iprot.readMessageEnd()
5623 
    if result.success is not None:
5624 
      return result.success
5625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5626 
 
5713 rajveer 5627 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5628 
    """
5629 
    Parameters:
5630 
     - storeId
5631 
     - fromDate
5632 
     - toDate
5633 
     - onlyCod
5634 
    """
5635 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5636 
    return self.recv_getOrdersCollectionAtStore()
5637 
 
5638 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5639 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5640 
    args = getOrdersCollectionAtStore_args()
5641 
    args.storeId = storeId
5642 
    args.fromDate = fromDate
5643 
    args.toDate = toDate
5644 
    args.onlyCod = onlyCod
5645 
    args.write(self._oprot)
5646 
    self._oprot.writeMessageEnd()
5647 
    self._oprot.trans.flush()
5648 
 
5649 
  def recv_getOrdersCollectionAtStore(self, ):
5650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5651 
    if mtype == TMessageType.EXCEPTION:
5652 
      x = TApplicationException()
5653 
      x.read(self._iprot)
5654 
      self._iprot.readMessageEnd()
5655 
      raise x
5656 
    result = getOrdersCollectionAtStore_result()
5657 
    result.read(self._iprot)
5658 
    self._iprot.readMessageEnd()
5659 
    if result.success is not None:
5660 
      return result.success
5661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5662 
 
5833 rajveer 5663 
  def getOrderAttributeValue(self, orderId, attributeName):
5664 
    """
5665 
    Parameters:
5666 
     - orderId
5667 
     - attributeName
5668 
    """
5669 
    self.send_getOrderAttributeValue(orderId, attributeName)
5670 
    return self.recv_getOrderAttributeValue()
5671 
 
5672 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5673 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5674 
    args = getOrderAttributeValue_args()
5675 
    args.orderId = orderId
5676 
    args.attributeName = attributeName
5677 
    args.write(self._oprot)
5678 
    self._oprot.writeMessageEnd()
5679 
    self._oprot.trans.flush()
5680 
 
5681 
  def recv_getOrderAttributeValue(self, ):
5682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5683 
    if mtype == TMessageType.EXCEPTION:
5684 
      x = TApplicationException()
5685 
      x.read(self._iprot)
5686 
      self._iprot.readMessageEnd()
5687 
      raise x
5688 
    result = getOrderAttributeValue_result()
5689 
    result.read(self._iprot)
5690 
    self._iprot.readMessageEnd()
5691 
    if result.success is not None:
5692 
      return result.success
5693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5694 
 
6019 rajveer 5695 
  def changeJacketNumber(self, orderId, jacketNumber):
5696 
    """
5697 
    Parameters:
5698 
     - orderId
5699 
     - jacketNumber
5700 
    """
5701 
    self.send_changeJacketNumber(orderId, jacketNumber)
5702 
    return self.recv_changeJacketNumber()
5703 
 
5704 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5705 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5706 
    args = changeJacketNumber_args()
5707 
    args.orderId = orderId
5708 
    args.jacketNumber = jacketNumber
5709 
    args.write(self._oprot)
5710 
    self._oprot.writeMessageEnd()
5711 
    self._oprot.trans.flush()
5712 
 
5713 
  def recv_changeJacketNumber(self, ):
5714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5715 
    if mtype == TMessageType.EXCEPTION:
5716 
      x = TApplicationException()
5717 
      x.read(self._iprot)
5718 
      self._iprot.readMessageEnd()
5719 
      raise x
5720 
    result = changeJacketNumber_result()
5721 
    result.read(self._iprot)
5722 
    self._iprot.readMessageEnd()
5723 
    if result.success is not None:
5724 
      return result.success
5725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5726 
 
5727 
  def markOrderAsRtoInTransit(self, orderId):
5728 
    """
5729 
    Parameters:
5730 
     - orderId
5731 
    """
5732 
    self.send_markOrderAsRtoInTransit(orderId)
5733 
    return self.recv_markOrderAsRtoInTransit()
5734 
 
5735 
  def send_markOrderAsRtoInTransit(self, orderId):
5736 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5737 
    args = markOrderAsRtoInTransit_args()
5738 
    args.orderId = orderId
5739 
    args.write(self._oprot)
5740 
    self._oprot.writeMessageEnd()
5741 
    self._oprot.trans.flush()
5742 
 
5743 
  def recv_markOrderAsRtoInTransit(self, ):
5744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5745 
    if mtype == TMessageType.EXCEPTION:
5746 
      x = TApplicationException()
5747 
      x.read(self._iprot)
5748 
      self._iprot.readMessageEnd()
5749 
      raise x
5750 
    result = markOrderAsRtoInTransit_result()
5751 
    result.read(self._iprot)
5752 
    self._iprot.readMessageEnd()
5753 
    if result.success is not None:
5754 
      return result.success
5755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5756 
 
5593 mandeep.dh 5757 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5758 
    """
5759 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5760 
    invoked while scanning IN of items.
5553 rajveer 5761 
 
5593 mandeep.dh 5762 
    Parameters:
5763 
     - itemId
5764 
     - quantity
5765 
     - fulfilmentWarehouseId
5766 
     - billingWarehouseId
5767 
    """
5768 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5769 
    self.recv_acceptOrderForItem()
5770 
 
5771 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5772 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5773 
    args = acceptOrderForItem_args()
5774 
    args.itemId = itemId
5775 
    args.quantity = quantity
5776 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5777 
    args.billingWarehouseId = billingWarehouseId
5778 
    args.write(self._oprot)
5779 
    self._oprot.writeMessageEnd()
5780 
    self._oprot.trans.flush()
5781 
 
5782 
  def recv_acceptOrderForItem(self, ):
5783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5784 
    if mtype == TMessageType.EXCEPTION:
5785 
      x = TApplicationException()
5786 
      x.read(self._iprot)
5787 
      self._iprot.readMessageEnd()
5788 
      raise x
5789 
    result = acceptOrderForItem_result()
5790 
    result.read(self._iprot)
5791 
    self._iprot.readMessageEnd()
5792 
    return
5793 
 
6000 mandeep.dh 5794 
  def createRechargeOrder(self, rechargeOrder):
5795 
    """
5796 
    Parameters:
5797 
     - rechargeOrder
5798 
    """
5799 
    self.send_createRechargeOrder(rechargeOrder)
5800 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5801 
 
6000 mandeep.dh 5802 
  def send_createRechargeOrder(self, rechargeOrder):
5803 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5804 
    args = createRechargeOrder_args()
5805 
    args.rechargeOrder = rechargeOrder
5806 
    args.write(self._oprot)
5807 
    self._oprot.writeMessageEnd()
5808 
    self._oprot.trans.flush()
5809 
 
5810 
  def recv_createRechargeOrder(self, ):
5811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5812 
    if mtype == TMessageType.EXCEPTION:
5813 
      x = TApplicationException()
5814 
      x.read(self._iprot)
5815 
      self._iprot.readMessageEnd()
5816 
      raise x
5817 
    result = createRechargeOrder_result()
5818 
    result.read(self._iprot)
5819 
    self._iprot.readMessageEnd()
5820 
    if result.success is not None:
5821 
      return result.success
5822 
    if result.ex is not None:
5823 
      raise result.ex
5824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5825 
 
6031 rajveer 5826 
  def getRechargeOrder(self, rechargeRrderId):
5827 
    """
5828 
    Parameters:
5829 
     - rechargeRrderId
5830 
    """
5831 
    self.send_getRechargeOrder(rechargeRrderId)
5832 
    return self.recv_getRechargeOrder()
5833 
 
5834 
  def send_getRechargeOrder(self, rechargeRrderId):
5835 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5836 
    args = getRechargeOrder_args()
5837 
    args.rechargeRrderId = rechargeRrderId
5838 
    args.write(self._oprot)
5839 
    self._oprot.writeMessageEnd()
5840 
    self._oprot.trans.flush()
5841 
 
5842 
  def recv_getRechargeOrder(self, ):
5843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5844 
    if mtype == TMessageType.EXCEPTION:
5845 
      x = TApplicationException()
5846 
      x.read(self._iprot)
5847 
      self._iprot.readMessageEnd()
5848 
      raise x
5849 
    result = getRechargeOrder_result()
5850 
    result.read(self._iprot)
5851 
    self._iprot.readMessageEnd()
5852 
    if result.success is not None:
5853 
      return result.success
5854 
    if result.ex is not None:
5855 
      raise result.ex
5856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5857 
 
5858 
  def getRechargeOrders(self, userId):
5859 
    """
5860 
    Parameters:
5861 
     - userId
5862 
    """
5863 
    self.send_getRechargeOrders(userId)
5864 
    return self.recv_getRechargeOrders()
5865 
 
5866 
  def send_getRechargeOrders(self, userId):
5867 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5868 
    args = getRechargeOrders_args()
5869 
    args.userId = userId
5870 
    args.write(self._oprot)
5871 
    self._oprot.writeMessageEnd()
5872 
    self._oprot.trans.flush()
5873 
 
5874 
  def recv_getRechargeOrders(self, ):
5875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5876 
    if mtype == TMessageType.EXCEPTION:
5877 
      x = TApplicationException()
5878 
      x.read(self._iprot)
5879 
      self._iprot.readMessageEnd()
5880 
      raise x
5881 
    result = getRechargeOrders_result()
5882 
    result.read(self._iprot)
5883 
    self._iprot.readMessageEnd()
5884 
    if result.success is not None:
5885 
      return result.success
5886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5887 
 
6000 mandeep.dh 5888 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5889 
    """
5890 
    Parameters:
5891 
     - rechargeOrderId
5892 
     - rechargeOrderStatus
5893 
    """
5894 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5895 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5896 
 
5897 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5898 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5899 
    args = updateRechargeOrderStatus_args()
5900 
    args.rechargeOrderId = rechargeOrderId
5901 
    args.rechargeOrderStatus = rechargeOrderStatus
5902 
    args.write(self._oprot)
5903 
    self._oprot.writeMessageEnd()
5904 
    self._oprot.trans.flush()
5905 
 
5906 
  def recv_updateRechargeOrderStatus(self, ):
5907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5908 
    if mtype == TMessageType.EXCEPTION:
5909 
      x = TApplicationException()
5910 
      x.read(self._iprot)
5911 
      self._iprot.readMessageEnd()
5912 
      raise x
5913 
    result = updateRechargeOrderStatus_result()
5914 
    result.read(self._iprot)
5915 
    self._iprot.readMessageEnd()
6031 rajveer 5916 
    if result.success is not None:
5917 
      return result.success
6000 mandeep.dh 5918 
    if result.ex is not None:
5919 
      raise result.ex
6031 rajveer 5920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5921 
 
6031 rajveer 5922 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5923 
    """
5924 
    Parameters:
6031 rajveer 5925 
     - rechargeOrderId
6000 mandeep.dh 5926 
    """
6031 rajveer 5927 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5928 
    return self.recv_activateRechargeTxn()
5929 
 
6031 rajveer 5930 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5931 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5932 
    args = activateRechargeTxn_args()
6031 rajveer 5933 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5934 
    args.write(self._oprot)
5935 
    self._oprot.writeMessageEnd()
5936 
    self._oprot.trans.flush()
5937 
 
5938 
  def recv_activateRechargeTxn(self, ):
5939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5940 
    if mtype == TMessageType.EXCEPTION:
5941 
      x = TApplicationException()
5942 
      x.read(self._iprot)
5943 
      self._iprot.readMessageEnd()
5944 
      raise x
5945 
    result = activateRechargeTxn_result()
5946 
    result.read(self._iprot)
5947 
    self._iprot.readMessageEnd()
5948 
    if result.success is not None:
5949 
      return result.success
5950 
    if result.ex is not None:
5951 
      raise result.ex
5952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5953 
 
6031 rajveer 5954 
  def getUserWallet(self, userId):
6000 mandeep.dh 5955 
    """
5956 
    Parameters:
6031 rajveer 5957 
     - userId
6000 mandeep.dh 5958 
    """
6031 rajveer 5959 
    self.send_getUserWallet(userId)
5960 
    return self.recv_getUserWallet()
6000 mandeep.dh 5961 
 
6031 rajveer 5962 
  def send_getUserWallet(self, userId):
5963 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
5964 
    args = getUserWallet_args()
5965 
    args.userId = userId
6000 mandeep.dh 5966 
    args.write(self._oprot)
5967 
    self._oprot.writeMessageEnd()
5968 
    self._oprot.trans.flush()
5969 
 
6031 rajveer 5970 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 5971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5972 
    if mtype == TMessageType.EXCEPTION:
5973 
      x = TApplicationException()
5974 
      x.read(self._iprot)
5975 
      self._iprot.readMessageEnd()
5976 
      raise x
6031 rajveer 5977 
    result = getUserWallet_result()
6000 mandeep.dh 5978 
    result.read(self._iprot)
5979 
    self._iprot.readMessageEnd()
5980 
    if result.success is not None:
5981 
      return result.success
6031 rajveer 5982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 5983 
 
6031 rajveer 5984 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 5985 
    """
5986 
    Parameters:
6031 rajveer 5987 
     - userId
6000 mandeep.dh 5988 
    """
6031 rajveer 5989 
    self.send_getUserWalletHistory(userId)
5990 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 5991 
 
6031 rajveer 5992 
  def send_getUserWalletHistory(self, userId):
5993 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
5994 
    args = getUserWalletHistory_args()
5995 
    args.userId = userId
6000 mandeep.dh 5996 
    args.write(self._oprot)
5997 
    self._oprot.writeMessageEnd()
5998 
    self._oprot.trans.flush()
5999 
 
6031 rajveer 6000 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6002 
    if mtype == TMessageType.EXCEPTION:
6003 
      x = TApplicationException()
6004 
      x.read(self._iprot)
6005 
      self._iprot.readMessageEnd()
6006 
      raise x
6031 rajveer 6007 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6008 
    result.read(self._iprot)
6009 
    self._iprot.readMessageEnd()
6010 
    if result.success is not None:
6011 
      return result.success
6031 rajveer 6012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6013 
 
6048 rajveer 6014 
  def getServiceProviders(self, rechargeType):
6015 
    """
6016 
    Parameters:
6017 
     - rechargeType
6018 
    """
6019 
    self.send_getServiceProviders(rechargeType)
6020 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6021 
 
6048 rajveer 6022 
  def send_getServiceProviders(self, rechargeType):
6023 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6024 
    args = getServiceProviders_args()
6025 
    args.rechargeType = rechargeType
6026 
    args.write(self._oprot)
6027 
    self._oprot.writeMessageEnd()
6028 
    self._oprot.trans.flush()
6029 
 
6030 
  def recv_getServiceProviders(self, ):
6031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6032 
    if mtype == TMessageType.EXCEPTION:
6033 
      x = TApplicationException()
6034 
      x.read(self._iprot)
6035 
      self._iprot.readMessageEnd()
6036 
      raise x
6037 
    result = getServiceProviders_result()
6038 
    result.read(self._iprot)
6039 
    self._iprot.readMessageEnd()
6040 
    if result.success is not None:
6041 
      return result.success
6042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6043 
 
6044 
  def getServiceProviderForDevice(self, deviceNumber):
6045 
    """
6046 
    Parameters:
6047 
     - deviceNumber
6048 
    """
6049 
    self.send_getServiceProviderForDevice(deviceNumber)
6050 
    return self.recv_getServiceProviderForDevice()
6051 
 
6052 
  def send_getServiceProviderForDevice(self, deviceNumber):
6053 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6054 
    args = getServiceProviderForDevice_args()
6055 
    args.deviceNumber = deviceNumber
6056 
    args.write(self._oprot)
6057 
    self._oprot.writeMessageEnd()
6058 
    self._oprot.trans.flush()
6059 
 
6060 
  def recv_getServiceProviderForDevice(self, ):
6061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6062 
    if mtype == TMessageType.EXCEPTION:
6063 
      x = TApplicationException()
6064 
      x.read(self._iprot)
6065 
      self._iprot.readMessageEnd()
6066 
      raise x
6067 
    result = getServiceProviderForDevice_result()
6068 
    result.read(self._iprot)
6069 
    self._iprot.readMessageEnd()
6070 
    if result.success is not None:
6071 
      return result.success
6072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6073 
 
6074 
 
3376 rajveer 6075 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6076 
  def __init__(self, handler):
3376 rajveer 6077 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6078 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6079 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6080 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6081 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6082 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6083 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6084 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6085 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6086 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6087 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6088 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6089 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6090 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6091 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6092 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6093 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6094 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6095 
    self._processMap["createOrder"] = Processor.process_createOrder
6096 
    self._processMap["getOrder"] = Processor.process_getOrder
6097 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6098 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6099 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6100 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6101 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6102 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6103 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6104 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6105 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6106 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6107 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6108 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6109 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6110 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6111 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6112 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6113 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6114 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6115 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6116 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6117 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6118 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6119 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6120 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6121 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6122 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6123 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6124 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6125 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6126 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6127 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6128 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6129 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6130 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6131 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6132 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6133 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6134 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6135 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6136 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6137 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6138 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6139 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6140 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6141 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6142 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6143 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6144 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6145 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6146 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6147 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6148 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6149 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6150 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6151 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6152 
    self._processMap["changeItem"] = Processor.process_changeItem
6153 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6154 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6155 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6156 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6157 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6158 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6159 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6160 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6161 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6162 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6163 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6164 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6165 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6166 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6167 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6168 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6169 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6170 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6171 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6172 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6173 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6174 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6175 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6176 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6177 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6178 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6179 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6180 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6181 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6182 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6183 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6184 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6185 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6186 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6187 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6188 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6189 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6190 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6191 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6192 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6193 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6194 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6195 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6196 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6197 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6198 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6199 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6200 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6201 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6202 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6203 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6204 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6205 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6206 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6207 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6208 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6209 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6210 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6211 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6048 rajveer 6212 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6213 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
94 ashish 6214 
 
6215 
  def process(self, iprot, oprot):
6216 
    (name, type, seqid) = iprot.readMessageBegin()
6217 
    if name not in self._processMap:
6218 
      iprot.skip(TType.STRUCT)
6219 
      iprot.readMessageEnd()
6220 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6221 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6222 
      x.write(oprot)
6223 
      oprot.writeMessageEnd()
6224 
      oprot.trans.flush()
6225 
      return
6226 
    else:
6227 
      self._processMap[name](self, seqid, iprot, oprot)
6228 
    return True
6229 
 
6230 
  def process_createTransaction(self, seqid, iprot, oprot):
6231 
    args = createTransaction_args()
6232 
    args.read(iprot)
6233 
    iprot.readMessageEnd()
6234 
    result = createTransaction_result()
6235 
    try:
132 ashish 6236 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6237 
    except TransactionServiceException, ex:
6238 
      result.ex = ex
6239 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6240 
    result.write(oprot)
6241 
    oprot.writeMessageEnd()
6242 
    oprot.trans.flush()
6243 
 
6244 
  def process_getTransaction(self, seqid, iprot, oprot):
6245 
    args = getTransaction_args()
6246 
    args.read(iprot)
6247 
    iprot.readMessageEnd()
6248 
    result = getTransaction_result()
6249 
    try:
6250 
      result.success = self._handler.getTransaction(args.id)
6251 
    except TransactionServiceException, ex:
6252 
      result.ex = ex
6253 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6254 
    result.write(oprot)
6255 
    oprot.writeMessageEnd()
6256 
    oprot.trans.flush()
6257 
 
6258 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6259 
    args = getTransactionsForCustomer_args()
6260 
    args.read(iprot)
6261 
    iprot.readMessageEnd()
6262 
    result = getTransactionsForCustomer_result()
6263 
    try:
6264 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6265 
    except TransactionServiceException, ex:
6266 
      result.ex = ex
6267 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6268 
    result.write(oprot)
6269 
    oprot.writeMessageEnd()
6270 
    oprot.trans.flush()
6271 
 
132 ashish 6272 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6273 
    args = getTransactionsForShoppingCartId_args()
6274 
    args.read(iprot)
6275 
    iprot.readMessageEnd()
6276 
    result = getTransactionsForShoppingCartId_result()
6277 
    try:
6278 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6279 
    except TransactionServiceException, ex:
6280 
      result.ex = ex
6281 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6282 
    result.write(oprot)
6283 
    oprot.writeMessageEnd()
6284 
    oprot.trans.flush()
6285 
 
94 ashish 6286 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6287 
    args = getTransactionStatus_args()
6288 
    args.read(iprot)
6289 
    iprot.readMessageEnd()
6290 
    result = getTransactionStatus_result()
6291 
    try:
6292 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6293 
    except TransactionServiceException, ex:
6294 
      result.ex = ex
6295 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6296 
    result.write(oprot)
6297 
    oprot.writeMessageEnd()
6298 
    oprot.trans.flush()
6299 
 
6300 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6301 
    args = changeTransactionStatus_args()
6302 
    args.read(iprot)
6303 
    iprot.readMessageEnd()
6304 
    result = changeTransactionStatus_result()
6305 
    try:
5527 anupam.sin 6306 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6307 
    except TransactionServiceException, ex:
6308 
      result.ex = ex
6309 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6310 
    result.write(oprot)
6311 
    oprot.writeMessageEnd()
6312 
    oprot.trans.flush()
6313 
 
1398 varun.gupt 6314 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6315 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6316 
    args.read(iprot)
6317 
    iprot.readMessageEnd()
1398 varun.gupt 6318 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6319 
    try:
1398 varun.gupt 6320 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6321 
    except TransactionServiceException, ex:
6322 
      result.ex = ex
1398 varun.gupt 6323 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6324 
    result.write(oprot)
6325 
    oprot.writeMessageEnd()
6326 
    oprot.trans.flush()
6327 
 
483 rajveer 6328 
  def process_getAllOrders(self, seqid, iprot, oprot):
6329 
    args = getAllOrders_args()
94 ashish 6330 
    args.read(iprot)
6331 
    iprot.readMessageEnd()
483 rajveer 6332 
    result = getAllOrders_result()
94 ashish 6333 
    try:
4801 anupam.sin 6334 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6335 
    except TransactionServiceException, ex:
6336 
      result.ex = ex
483 rajveer 6337 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6338 
    result.write(oprot)
6339 
    oprot.writeMessageEnd()
6340 
    oprot.trans.flush()
6341 
 
4133 chandransh 6342 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6343 
    args = getOrdersInBatch_args()
6344 
    args.read(iprot)
6345 
    iprot.readMessageEnd()
6346 
    result = getOrdersInBatch_result()
6347 
    try:
6348 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6349 
    except TransactionServiceException, ex:
6350 
      result.ex = ex
6351 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6352 
    result.write(oprot)
6353 
    oprot.writeMessageEnd()
6354 
    oprot.trans.flush()
6355 
 
6356 
  def process_getOrderCount(self, seqid, iprot, oprot):
6357 
    args = getOrderCount_args()
6358 
    args.read(iprot)
6359 
    iprot.readMessageEnd()
6360 
    result = getOrderCount_result()
6361 
    try:
6362 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6363 
    except TransactionServiceException, ex:
6364 
      result.ex = ex
6365 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6366 
    result.write(oprot)
6367 
    oprot.writeMessageEnd()
6368 
    oprot.trans.flush()
6369 
 
999 varun.gupt 6370 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6371 
    args = getOrdersByBillingDate_args()
6372 
    args.read(iprot)
6373 
    iprot.readMessageEnd()
6374 
    result = getOrdersByBillingDate_result()
6375 
    try:
6376 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6377 
    except TransactionServiceException, ex:
6378 
      result.ex = ex
6379 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6380 
    result.write(oprot)
6381 
    oprot.writeMessageEnd()
6382 
    oprot.trans.flush()
6383 
 
3427 chandransh 6384 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6385 
    args = getOrdersByShippingDate_args()
6386 
    args.read(iprot)
6387 
    iprot.readMessageEnd()
6388 
    result = getOrdersByShippingDate_result()
6389 
    try:
3451 chandransh 6390 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6391 
    except TransactionServiceException, ex:
6392 
      result.ex = ex
6393 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6394 
    result.write(oprot)
6395 
    oprot.writeMessageEnd()
6396 
    oprot.trans.flush()
6397 
 
1382 varun.gupt 6398 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6399 
    args = getReturnableOrdersForCustomer_args()
6400 
    args.read(iprot)
6401 
    iprot.readMessageEnd()
6402 
    result = getReturnableOrdersForCustomer_result()
6403 
    try:
6404 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6405 
    except TransactionServiceException, ex:
6406 
      result.ex = ex
6407 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6408 
    result.write(oprot)
6409 
    oprot.writeMessageEnd()
6410 
    oprot.trans.flush()
6411 
 
6412 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6413 
    args = getCancellableOrdersForCustomer_args()
6414 
    args.read(iprot)
6415 
    iprot.readMessageEnd()
6416 
    result = getCancellableOrdersForCustomer_result()
6417 
    try:
6418 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6419 
    except TransactionServiceException, ex:
6420 
      result.ex = ex
6421 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6422 
    result.write(oprot)
6423 
    oprot.writeMessageEnd()
6424 
    oprot.trans.flush()
6425 
 
483 rajveer 6426 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6427 
    args = changeOrderStatus_args()
94 ashish 6428 
    args.read(iprot)
6429 
    iprot.readMessageEnd()
483 rajveer 6430 
    result = changeOrderStatus_result()
94 ashish 6431 
    try:
483 rajveer 6432 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6433 
    except TransactionServiceException, ex:
6434 
      result.ex = ex
483 rajveer 6435 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6436 
    result.write(oprot)
6437 
    oprot.writeMessageEnd()
6438 
    oprot.trans.flush()
6439 
 
483 rajveer 6440 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6441 
    args = getOrdersForTransaction_args()
94 ashish 6442 
    args.read(iprot)
6443 
    iprot.readMessageEnd()
483 rajveer 6444 
    result = getOrdersForTransaction_result()
94 ashish 6445 
    try:
1528 ankur.sing 6446 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6447 
    except TransactionServiceException, ex:
6448 
      result.ex = ex
483 rajveer 6449 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6450 
    result.write(oprot)
6451 
    oprot.writeMessageEnd()
6452 
    oprot.trans.flush()
6453 
 
483 rajveer 6454 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6455 
    args = getOrdersForCustomer_args()
94 ashish 6456 
    args.read(iprot)
6457 
    iprot.readMessageEnd()
483 rajveer 6458 
    result = getOrdersForCustomer_result()
94 ashish 6459 
    try:
3014 chandransh 6460 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6461 
    except TransactionServiceException, ex:
6462 
      result.ex = ex
483 rajveer 6463 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6464 
    result.write(oprot)
6465 
    oprot.writeMessageEnd()
6466 
    oprot.trans.flush()
6467 
 
483 rajveer 6468 
  def process_createOrder(self, seqid, iprot, oprot):
6469 
    args = createOrder_args()
94 ashish 6470 
    args.read(iprot)
6471 
    iprot.readMessageEnd()
483 rajveer 6472 
    result = createOrder_result()
94 ashish 6473 
    try:
483 rajveer 6474 
      result.success = self._handler.createOrder(args.order)
94 ashish 6475 
    except TransactionServiceException, ex:
6476 
      result.ex = ex
483 rajveer 6477 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6478 
    result.write(oprot)
6479 
    oprot.writeMessageEnd()
6480 
    oprot.trans.flush()
6481 
 
483 rajveer 6482 
  def process_getOrder(self, seqid, iprot, oprot):
6483 
    args = getOrder_args()
94 ashish 6484 
    args.read(iprot)
6485 
    iprot.readMessageEnd()
483 rajveer 6486 
    result = getOrder_result()
94 ashish 6487 
    try:
483 rajveer 6488 
      result.success = self._handler.getOrder(args.id)
94 ashish 6489 
    except TransactionServiceException, ex:
6490 
      result.ex = ex
483 rajveer 6491 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6492 
    result.write(oprot)
6493 
    oprot.writeMessageEnd()
6494 
    oprot.trans.flush()
6495 
 
483 rajveer 6496 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6497 
    args = getLineItemsForOrder_args()
94 ashish 6498 
    args.read(iprot)
6499 
    iprot.readMessageEnd()
483 rajveer 6500 
    result = getLineItemsForOrder_result()
94 ashish 6501 
    try:
483 rajveer 6502 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6503 
    except TransactionServiceException, ex:
6504 
      result.ex = ex
483 rajveer 6505 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6506 
    result.write(oprot)
6507 
    oprot.writeMessageEnd()
6508 
    oprot.trans.flush()
6509 
 
4999 phani.kuma 6510 
  def process_getOrderList(self, seqid, iprot, oprot):
6511 
    args = getOrderList_args()
6512 
    args.read(iprot)
6513 
    iprot.readMessageEnd()
6514 
    result = getOrderList_result()
6515 
    result.success = self._handler.getOrderList(args.order_ids)
6516 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
5386 phani.kuma 6521 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6522 
    args = getOrderListForVendor_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getOrderListForVendor_result()
6526 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6527 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6528 
    result.write(oprot)
6529 
    oprot.writeMessageEnd()
6530 
    oprot.trans.flush()
6531 
 
1528 ankur.sing 6532 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6533 
    args = getOrderForCustomer_args()
6534 
    args.read(iprot)
6535 
    iprot.readMessageEnd()
6536 
    result = getOrderForCustomer_result()
6537 
    try:
6538 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6539 
    except TransactionServiceException, ex:
6540 
      result.ex = ex
6541 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6542 
    result.write(oprot)
6543 
    oprot.writeMessageEnd()
6544 
    oprot.trans.flush()
6545 
 
3064 chandransh 6546 
  def process_getAlerts(self, seqid, iprot, oprot):
6547 
    args = getAlerts_args()
6548 
    args.read(iprot)
6549 
    iprot.readMessageEnd()
6550 
    result = getAlerts_result()
4444 rajveer 6551 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6552 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6553 
    result.write(oprot)
6554 
    oprot.writeMessageEnd()
6555 
    oprot.trans.flush()
6556 
 
4394 rajveer 6557 
  def process_addAlert(self, seqid, iprot, oprot):
6558 
    args = addAlert_args()
3064 chandransh 6559 
    args.read(iprot)
6560 
    iprot.readMessageEnd()
4394 rajveer 6561 
    result = addAlert_result()
4444 rajveer 6562 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6563 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6564 
    result.write(oprot)
6565 
    oprot.writeMessageEnd()
6566 
    oprot.trans.flush()
6567 
 
4444 rajveer 6568 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6569 
    args = markAlertsAsSeen_args()
6570 
    args.read(iprot)
6571 
    iprot.readMessageEnd()
6572 
    result = markAlertsAsSeen_result()
6573 
    self._handler.markAlertsAsSeen(args.warehouseId)
6574 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
3064 chandransh 6579 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6580 
    args = getValidOrderCount_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = getValidOrderCount_result()
6584 
    result.success = self._handler.getValidOrderCount()
6585 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
6590 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6591 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
6594 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6595 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6596 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
6600 
 
6601 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6602 
    args = getValidOrdersAmountRange_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getValidOrdersAmountRange_result()
6606 
    result.success = self._handler.getValidOrdersAmountRange()
6607 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
6611 
 
6612 
  def process_getValidOrders(self, seqid, iprot, oprot):
6613 
    args = getValidOrders_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = getValidOrders_result()
5874 rajveer 6617 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6618 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
1220 chandransh 6623 
  def process_batchOrders(self, seqid, iprot, oprot):
6624 
    args = batchOrders_args()
6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
6627 
    result = batchOrders_result()
6628 
    try:
6629 
      result.success = self._handler.batchOrders(args.warehouseId)
6630 
    except TransactionServiceException, ex:
6631 
      result.ex = ex
6632 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6633 
    result.write(oprot)
6634 
    oprot.writeMessageEnd()
6635 
    oprot.trans.flush()
6636 
 
1208 chandransh 6637 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6638 
    args = markOrderAsOutOfStock_args()
6639 
    args.read(iprot)
6640 
    iprot.readMessageEnd()
6641 
    result = markOrderAsOutOfStock_result()
6642 
    try:
6643 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6644 
    except TransactionServiceException, ex:
6645 
      result.ex = ex
6646 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6647 
    result.write(oprot)
6648 
    oprot.writeMessageEnd()
6649 
    oprot.trans.flush()
6650 
 
3064 chandransh 6651 
  def process_verifyOrder(self, seqid, iprot, oprot):
6652 
    args = verifyOrder_args()
759 chandransh 6653 
    args.read(iprot)
6654 
    iprot.readMessageEnd()
3064 chandransh 6655 
    result = verifyOrder_result()
759 chandransh 6656 
    try:
3064 chandransh 6657 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6658 
    except TransactionServiceException, ex:
6659 
      result.ex = ex
3064 chandransh 6660 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6661 
    result.write(oprot)
6662 
    oprot.writeMessageEnd()
6663 
    oprot.trans.flush()
6664 
 
3064 chandransh 6665 
  def process_acceptOrder(self, seqid, iprot, oprot):
6666 
    args = acceptOrder_args()
1113 chandransh 6667 
    args.read(iprot)
6668 
    iprot.readMessageEnd()
3064 chandransh 6669 
    result = acceptOrder_result()
1113 chandransh 6670 
    try:
3064 chandransh 6671 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6672 
    except TransactionServiceException, ex:
6673 
      result.ex = ex
3064 chandransh 6674 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6675 
    result.write(oprot)
6676 
    oprot.writeMessageEnd()
6677 
    oprot.trans.flush()
6678 
 
3064 chandransh 6679 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6680 
    args = addBillingDetails_args()
1135 chandransh 6681 
    args.read(iprot)
6682 
    iprot.readMessageEnd()
3064 chandransh 6683 
    result = addBillingDetails_result()
1135 chandransh 6684 
    try:
5110 mandeep.dh 6685 
      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 6686 
    except TransactionServiceException, ex:
6687 
      result.ex = ex
3064 chandransh 6688 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6689 
    result.write(oprot)
6690 
    oprot.writeMessageEnd()
6691 
    oprot.trans.flush()
6692 
 
4579 rajveer 6693 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6694 
    args = addInvoiceNumber_args()
6695 
    args.read(iprot)
6696 
    iprot.readMessageEnd()
6697 
    result = addInvoiceNumber_result()
6698 
    try:
4763 rajveer 6699 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6700 
    except TransactionServiceException, ex:
6701 
      result.ex = ex
6702 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6703 
    result.write(oprot)
6704 
    oprot.writeMessageEnd()
6705 
    oprot.trans.flush()
6706 
 
4410 rajveer 6707 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6708 
    args = markOrdersAsShippedFromWarehouse_args()
6709 
    args.read(iprot)
6710 
    iprot.readMessageEnd()
6711 
    result = markOrdersAsShippedFromWarehouse_result()
6712 
    try:
4789 rajveer 6713 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6714 
    except TransactionServiceException, ex:
6715 
      result.ex = ex
6716 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6717 
    result.write(oprot)
6718 
    oprot.writeMessageEnd()
6719 
    oprot.trans.flush()
6720 
 
5676 rajveer 6721 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6722 
    args = markOrdersAsReturnedFromStore_args()
6723 
    args.read(iprot)
6724 
    iprot.readMessageEnd()
6725 
    result = markOrdersAsReturnedFromStore_result()
6726 
    try:
5713 rajveer 6727 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6728 
    except TransactionServiceException, ex:
6729 
      result.ex = ex
6730 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6731 
    result.write(oprot)
6732 
    oprot.writeMessageEnd()
6733 
    oprot.trans.flush()
6734 
 
3064 chandransh 6735 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6736 
    args = markOrdersAsPickedUp_args()
304 ashish 6737 
    args.read(iprot)
6738 
    iprot.readMessageEnd()
3064 chandransh 6739 
    result = markOrdersAsPickedUp_result()
6740 
    try:
4910 phani.kuma 6741 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6742 
    except TransactionServiceException, ex:
6743 
      result.ex = ex
6744 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6745 
    result.write(oprot)
6746 
    oprot.writeMessageEnd()
6747 
    oprot.trans.flush()
94 ashish 6748 
 
4910 phani.kuma 6749 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6750 
    args = getOrdersNotPickedUp_args()
6751 
    args.read(iprot)
6752 
    iprot.readMessageEnd()
6753 
    result = getOrdersNotPickedUp_result()
6754 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6755 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6756 
    result.write(oprot)
6757 
    oprot.writeMessageEnd()
6758 
    oprot.trans.flush()
6759 
 
3064 chandransh 6760 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6761 
    args = markOrdersAsDelivered_args()
304 ashish 6762 
    args.read(iprot)
6763 
    iprot.readMessageEnd()
3064 chandransh 6764 
    result = markOrdersAsDelivered_result()
6765 
    try:
6766 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6767 
    except TransactionServiceException, ex:
6768 
      result.ex = ex
6769 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
6773 
 
4910 phani.kuma 6774 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6775 
    args = markAsRTOrders_args()
1596 ankur.sing 6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
4910 phani.kuma 6778 
    result = markAsRTOrders_result()
3064 chandransh 6779 
    try:
4910 phani.kuma 6780 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6781 
    except TransactionServiceException, ex:
6782 
      result.ex = ex
4910 phani.kuma 6783 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6784 
    result.write(oprot)
6785 
    oprot.writeMessageEnd()
6786 
    oprot.trans.flush()
304 ashish 6787 
 
4910 phani.kuma 6788 
  def process_getRTOrders(self, seqid, iprot, oprot):
6789 
    args = getRTOrders_args()
6790 
    args.read(iprot)
6791 
    iprot.readMessageEnd()
6792 
    result = getRTOrders_result()
6793 
    result.success = self._handler.getRTOrders(args.providerId)
6794 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6795 
    result.write(oprot)
6796 
    oprot.writeMessageEnd()
6797 
    oprot.trans.flush()
6798 
 
3064 chandransh 6799 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6800 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6801 
    args.read(iprot)
6802 
    iprot.readMessageEnd()
3064 chandransh 6803 
    result = updateNonDeliveryReason_result()
6804 
    try:
4910 phani.kuma 6805 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6806 
    except TransactionServiceException, ex:
6807 
      result.ex = ex
6808 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
1596 ankur.sing 6812 
 
4910 phani.kuma 6813 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6814 
    args = getNonDeliveredOrdersbyCourier_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = getNonDeliveredOrdersbyCourier_result()
6818 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6819 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6820 
    result.write(oprot)
6821 
    oprot.writeMessageEnd()
6822 
    oprot.trans.flush()
6823 
 
6824 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6825 
    args = markOrdersAsLocalConnected_args()
6826 
    args.read(iprot)
6827 
    iprot.readMessageEnd()
6828 
    result = markOrdersAsLocalConnected_result()
6829 
    try:
6830 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6831 
    except TransactionServiceException, ex:
6832 
      result.ex = ex
6833 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6834 
    result.write(oprot)
6835 
    oprot.writeMessageEnd()
6836 
    oprot.trans.flush()
6837 
 
6838 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6839 
    args = getOrdersNotLocalConnected_args()
6840 
    args.read(iprot)
6841 
    iprot.readMessageEnd()
6842 
    result = getOrdersNotLocalConnected_result()
6843 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6844 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6845 
    result.write(oprot)
6846 
    oprot.writeMessageEnd()
6847 
    oprot.trans.flush()
6848 
 
6849 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6850 
    args = markOrdersAsDestinationCityReached_args()
6851 
    args.read(iprot)
6852 
    iprot.readMessageEnd()
6853 
    result = markOrdersAsDestinationCityReached_result()
6854 
    try:
6855 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6856 
    except TransactionServiceException, ex:
6857 
      result.ex = ex
6858 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6859 
    result.write(oprot)
6860 
    oprot.writeMessageEnd()
6861 
    oprot.trans.flush()
6862 
 
6863 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6864 
    args = markOrdersAsFirstDeliveryAttempted_args()
6865 
    args.read(iprot)
6866 
    iprot.readMessageEnd()
6867 
    result = markOrdersAsFirstDeliveryAttempted_result()
6868 
    try:
6869 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6870 
    except TransactionServiceException, ex:
6871 
      result.ex = ex
6872 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6873 
    result.write(oprot)
6874 
    oprot.writeMessageEnd()
6875 
    oprot.trans.flush()
6876 
 
3064 chandransh 6877 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6878 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6879 
    args.read(iprot)
6880 
    iprot.readMessageEnd()
3064 chandransh 6881 
    result = getUndeliveredOrders_result()
6882 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6883 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6884 
    result.write(oprot)
6885 
    oprot.writeMessageEnd()
6886 
    oprot.trans.flush()
6887 
 
4783 phani.kuma 6888 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6889 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6890 
    args.read(iprot)
6891 
    iprot.readMessageEnd()
6892 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6893 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6894 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6895 
    result.write(oprot)
6896 
    oprot.writeMessageEnd()
6897 
    oprot.trans.flush()
6898 
 
2536 chandransh 6899 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6900 
    args = toggleDOAFlag_args()
6901 
    args.read(iprot)
6902 
    iprot.readMessageEnd()
6903 
    result = toggleDOAFlag_result()
6904 
    try:
6905 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6906 
    except TransactionServiceException, ex:
6907 
      result.ex = ex
6908 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6909 
    result.write(oprot)
6910 
    oprot.writeMessageEnd()
6911 
    oprot.trans.flush()
1886 ankur.sing 6912 
 
4712 rajveer 6913 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6914 
    args = markOrderAsDelivered_args()
6915 
    args.read(iprot)
6916 
    iprot.readMessageEnd()
6917 
    result = markOrderAsDelivered_result()
6918 
    try:
6919 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6920 
    except TransactionServiceException, ex:
6921 
      result.ex = ex
6922 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6923 
    result.write(oprot)
6924 
    oprot.writeMessageEnd()
6925 
    oprot.trans.flush()
6926 
 
5553 rajveer 6927 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6928 
    args = markOrderAsReceivedAtStore_args()
6929 
    args.read(iprot)
6930 
    iprot.readMessageEnd()
6931 
    result = markOrderAsReceivedAtStore_result()
6932 
    try:
6933 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6934 
    except TransactionServiceException, ex:
6935 
      result.ex = ex
6936 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
6940 
 
4454 rajveer 6941 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6942 
    args = markOrderDoaRequestReceived_args()
6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
6945 
    result = markOrderDoaRequestReceived_result()
6946 
    try:
6947 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6948 
    except TransactionServiceException, ex:
6949 
      result.ex = ex
6950 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
6955 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6956 
    args = markOrderDoaRequestAuthorized_args()
6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
6959 
    result = markOrderDoaRequestAuthorized_result()
6960 
    try:
6961 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6962 
    except TransactionServiceException, ex:
6963 
      result.ex = ex
6964 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
6968 
 
4488 rajveer 6969 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6970 
    args = markOrderReturnRequestReceived_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = markOrderReturnRequestReceived_result()
6974 
    try:
6975 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
6978 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
6983 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6984 
    args = markOrderReturnRequestAuthorized_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = markOrderReturnRequestAuthorized_result()
6988 
    try:
6989 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
6992 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
2536 chandransh 6997 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6998 
    args = requestPickupNumber_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = requestPickupNumber_result()
7002 
    try:
4579 rajveer 7003 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7004 
    except TransactionServiceException, ex:
7005 
      result.ex = ex
7006 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7007 
    result.write(oprot)
7008 
    oprot.writeMessageEnd()
7009 
    oprot.trans.flush()
7010 
 
7011 
  def process_authorizePickup(self, seqid, iprot, oprot):
7012 
    args = authorizePickup_args()
7013 
    args.read(iprot)
7014 
    iprot.readMessageEnd()
7015 
    result = authorizePickup_result()
7016 
    try:
4602 rajveer 7017 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7018 
    except TransactionServiceException, ex:
7019 
      result.ex = ex
7020 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
7024 
 
2764 chandransh 7025 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7026 
    args = markDoasAsPickedUp_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7030 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7031 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
4910 phani.kuma 7036 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7037 
    args = getDoasNotPickedUp_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = getDoasNotPickedUp_result()
7041 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7042 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7043 
    result.write(oprot)
7044 
    oprot.writeMessageEnd()
7045 
    oprot.trans.flush()
7046 
 
4741 phani.kuma 7047 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7048 
    args = markReturnOrdersAsPickedUp_args()
7049 
    args.read(iprot)
7050 
    iprot.readMessageEnd()
7051 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7052 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7053 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7054 
    result.write(oprot)
7055 
    oprot.writeMessageEnd()
7056 
    oprot.trans.flush()
7057 
 
4910 phani.kuma 7058 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7059 
    args = getReturnOrdersNotPickedUp_args()
7060 
    args.read(iprot)
7061 
    iprot.readMessageEnd()
7062 
    result = getReturnOrdersNotPickedUp_result()
7063 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7064 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7065 
    result.write(oprot)
7066 
    oprot.writeMessageEnd()
7067 
    oprot.trans.flush()
7068 
 
2616 chandransh 7069 
  def process_receiveReturn(self, seqid, iprot, oprot):
7070 
    args = receiveReturn_args()
2591 chandransh 7071 
    args.read(iprot)
7072 
    iprot.readMessageEnd()
2616 chandransh 7073 
    result = receiveReturn_result()
2591 chandransh 7074 
    try:
4479 rajveer 7075 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7076 
    except TransactionServiceException, ex:
7077 
      result.ex = ex
2616 chandransh 7078 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7079 
    result.write(oprot)
7080 
    oprot.writeMessageEnd()
7081 
    oprot.trans.flush()
2536 chandransh 7082 
 
2591 chandransh 7083 
  def process_validateDoa(self, seqid, iprot, oprot):
7084 
    args = validateDoa_args()
7085 
    args.read(iprot)
7086 
    iprot.readMessageEnd()
7087 
    result = validateDoa_result()
7088 
    try:
7089 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7090 
    except TransactionServiceException, ex:
7091 
      result.ex = ex
7092 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7093 
    result.write(oprot)
7094 
    oprot.writeMessageEnd()
7095 
    oprot.trans.flush()
7096 
 
4495 rajveer 7097 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7098 
    args = validateReturnProduct_args()
7099 
    args.read(iprot)
7100 
    iprot.readMessageEnd()
7101 
    result = validateReturnProduct_result()
7102 
    try:
7103 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7104 
    except TransactionServiceException, ex:
7105 
      result.ex = ex
7106 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7107 
    result.write(oprot)
7108 
    oprot.writeMessageEnd()
7109 
    oprot.trans.flush()
7110 
 
2616 chandransh 7111 
  def process_reshipOrder(self, seqid, iprot, oprot):
7112 
    args = reshipOrder_args()
7113 
    args.read(iprot)
7114 
    iprot.readMessageEnd()
7115 
    result = reshipOrder_result()
7116 
    try:
7117 
      result.success = self._handler.reshipOrder(args.orderId)
7118 
    except TransactionServiceException, ex:
7119 
      result.ex = ex
7120 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7121 
    result.write(oprot)
7122 
    oprot.writeMessageEnd()
7123 
    oprot.trans.flush()
2591 chandransh 7124 
 
2616 chandransh 7125 
  def process_refundOrder(self, seqid, iprot, oprot):
7126 
    args = refundOrder_args()
7127 
    args.read(iprot)
7128 
    iprot.readMessageEnd()
7129 
    result = refundOrder_result()
7130 
    try:
3226 chandransh 7131 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7132 
    except TransactionServiceException, ex:
7133 
      result.ex = ex
7134 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
7138 
 
2690 chandransh 7139 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7140 
    args = getReturnOrders_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = getReturnOrders_result()
7144 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7145 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7146 
    result.write(oprot)
7147 
    oprot.writeMessageEnd()
7148 
    oprot.trans.flush()
2616 chandransh 7149 
 
5481 phani.kuma 7150 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7151 
    args = getAllReturnOrders_args()
7152 
    args.read(iprot)
7153 
    iprot.readMessageEnd()
7154 
    result = getAllReturnOrders_result()
7155 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7156 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7157 
    result.write(oprot)
7158 
    oprot.writeMessageEnd()
7159 
    oprot.trans.flush()
7160 
 
2700 chandransh 7161 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7162 
    args = getReturnOrder_args()
7163 
    args.read(iprot)
7164 
    iprot.readMessageEnd()
7165 
    result = getReturnOrder_result()
7166 
    try:
7167 
      result.success = self._handler.getReturnOrder(args.id)
7168 
    except TransactionServiceException, ex:
7169 
      result.ex = ex
7170 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
7174 
 
2690 chandransh 7175 
  def process_processReturn(self, seqid, iprot, oprot):
7176 
    args = processReturn_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = processReturn_result()
7180 
    try:
7181 
      self._handler.processReturn(args.returnOrderId)
7182 
    except TransactionServiceException, ex:
7183 
      result.ex = ex
7184 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7185 
    result.write(oprot)
7186 
    oprot.writeMessageEnd()
7187 
    oprot.trans.flush()
7188 
 
3451 chandransh 7189 
  def process_updateWeight(self, seqid, iprot, oprot):
7190 
    args = updateWeight_args()
7191 
    args.read(iprot)
7192 
    iprot.readMessageEnd()
7193 
    result = updateWeight_result()
7194 
    try:
7195 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7196 
    except TransactionServiceException, ex:
7197 
      result.ex = ex
7198 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7199 
    result.write(oprot)
7200 
    oprot.writeMessageEnd()
7201 
    oprot.trans.flush()
2819 chandransh 7202 
 
3469 chandransh 7203 
  def process_changeItem(self, seqid, iprot, oprot):
7204 
    args = changeItem_args()
7205 
    args.read(iprot)
7206 
    iprot.readMessageEnd()
7207 
    result = changeItem_result()
7208 
    try:
7209 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7210 
    except TransactionServiceException, ex:
7211 
      result.ex = ex
7212 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7213 
    result.write(oprot)
7214 
    oprot.writeMessageEnd()
7215 
    oprot.trans.flush()
3451 chandransh 7216 
 
3469 chandransh 7217 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7218 
    args = shiftToWarehouse_args()
7219 
    args.read(iprot)
7220 
    iprot.readMessageEnd()
7221 
    result = shiftToWarehouse_result()
7222 
    try:
7223 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7224 
    except TransactionServiceException, ex:
7225 
      result.ex = ex
7226 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7227 
    result.write(oprot)
7228 
    oprot.writeMessageEnd()
7229 
    oprot.trans.flush()
7230 
 
3553 chandransh 7231 
  def process_addDelayReason(self, seqid, iprot, oprot):
7232 
    args = addDelayReason_args()
7233 
    args.read(iprot)
7234 
    iprot.readMessageEnd()
7235 
    result = addDelayReason_result()
7236 
    try:
4647 rajveer 7237 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7238 
    except TransactionServiceException, ex:
7239 
      result.ex = ex
7240 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7241 
    result.write(oprot)
7242 
    oprot.writeMessageEnd()
7243 
    oprot.trans.flush()
3469 chandransh 7244 
 
3956 chandransh 7245 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7246 
    args = reconcileCodCollection_args()
7247 
    args.read(iprot)
7248 
    iprot.readMessageEnd()
7249 
    result = reconcileCodCollection_result()
7250 
    try:
7251 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7252 
    except TransactionServiceException, ex:
7253 
      result.ex = ex
7254 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7255 
    result.write(oprot)
7256 
    oprot.writeMessageEnd()
7257 
    oprot.trans.flush()
3553 chandransh 7258 
 
4008 mandeep.dh 7259 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7260 
    args = getTransactionsRequiringExtraProcessing_args()
7261 
    args.read(iprot)
7262 
    iprot.readMessageEnd()
7263 
    result = getTransactionsRequiringExtraProcessing_result()
7264 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7265 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7266 
    result.write(oprot)
7267 
    oprot.writeMessageEnd()
7268 
    oprot.trans.flush()
3956 chandransh 7269 
 
4008 mandeep.dh 7270 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7271 
    args = markTransactionAsProcessed_args()
7272 
    args.read(iprot)
7273 
    iprot.readMessageEnd()
7274 
    result = markTransactionAsProcessed_result()
7275 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7276 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7277 
    result.write(oprot)
7278 
    oprot.writeMessageEnd()
7279 
    oprot.trans.flush()
7280 
 
4018 chandransh 7281 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7282 
    args = getItemWiseRiskyOrdersCount_args()
7283 
    args.read(iprot)
7284 
    iprot.readMessageEnd()
7285 
    result = getItemWiseRiskyOrdersCount_result()
7286 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7287 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7288 
    result.write(oprot)
7289 
    oprot.writeMessageEnd()
7290 
    oprot.trans.flush()
4008 mandeep.dh 7291 
 
4295 varun.gupt 7292 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7293 
    args = getOrdersForItemIds_args()
7294 
    args.read(iprot)
7295 
    iprot.readMessageEnd()
7296 
    result = getOrdersForItemIds_result()
7297 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7298 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7299 
    result.write(oprot)
7300 
    oprot.writeMessageEnd()
7301 
    oprot.trans.flush()
7302 
 
4247 rajveer 7303 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7304 
    args = markOrderCancellationRequestReceived_args()
7305 
    args.read(iprot)
7306 
    iprot.readMessageEnd()
7307 
    result = markOrderCancellationRequestReceived_result()
7308 
    try:
7309 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7310 
    except TransactionServiceException, ex:
7311 
      result.ex = ex
7312 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7313 
    result.write(oprot)
7314 
    oprot.writeMessageEnd()
7315 
    oprot.trans.flush()
4018 chandransh 7316 
 
4247 rajveer 7317 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7318 
    args = markOrderCancellationRequestConfirmed_args()
7319 
    args.read(iprot)
7320 
    iprot.readMessageEnd()
7321 
    result = markOrderCancellationRequestConfirmed_result()
7322 
    try:
7323 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7324 
    except TransactionServiceException, ex:
7325 
      result.ex = ex
7326 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7327 
    result.write(oprot)
7328 
    oprot.writeMessageEnd()
7329 
    oprot.trans.flush()
7330 
 
7331 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7332 
    args = markOrderCancellationRequestDenied_args()
7333 
    args.read(iprot)
7334 
    iprot.readMessageEnd()
7335 
    result = markOrderCancellationRequestDenied_result()
7336 
    try:
7337 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7338 
    except TransactionServiceException, ex:
7339 
      result.ex = ex
7340 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7341 
    result.write(oprot)
7342 
    oprot.writeMessageEnd()
7343 
    oprot.trans.flush()
7344 
 
4258 rajveer 7345 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7346 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7347 
    args.read(iprot)
7348 
    iprot.readMessageEnd()
4258 rajveer 7349 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7350 
    try:
4258 rajveer 7351 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7352 
    except TransactionServiceException, ex:
7353 
      result.ex = ex
4258 rajveer 7354 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7355 
    result.write(oprot)
7356 
    oprot.writeMessageEnd()
7357 
    oprot.trans.flush()
7358 
 
4259 anupam.sin 7359 
  def process_refundTransaction(self, seqid, iprot, oprot):
7360 
    args = refundTransaction_args()
7361 
    args.read(iprot)
7362 
    iprot.readMessageEnd()
7363 
    result = refundTransaction_result()
7364 
    try:
7365 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7366 
    except TransactionServiceException, ex:
7367 
      result.ex = ex
7368 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7369 
    result.write(oprot)
7370 
    oprot.writeMessageEnd()
7371 
    oprot.trans.flush()
4247 rajveer 7372 
 
4324 mandeep.dh 7373 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7374 
    args = updateShipmentAddress_args()
7375 
    args.read(iprot)
7376 
    iprot.readMessageEnd()
7377 
    result = updateShipmentAddress_result()
7378 
    try:
7379 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7380 
    except TransactionServiceException, ex:
7381 
      result.ex = ex
7382 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7383 
    result.write(oprot)
7384 
    oprot.writeMessageEnd()
7385 
    oprot.trans.flush()
7386 
 
4285 rajveer 7387 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7388 
    args = acceptOrdersForItemId_args()
7389 
    args.read(iprot)
7390 
    iprot.readMessageEnd()
7391 
    result = acceptOrdersForItemId_result()
7392 
    try:
7393 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7394 
    except TransactionServiceException, ex:
7395 
      result.ex = ex
7396 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7397 
    result.write(oprot)
7398 
    oprot.writeMessageEnd()
7399 
    oprot.trans.flush()
4259 anupam.sin 7400 
 
4303 rajveer 7401 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7402 
    args = markOrdersAsPORaised_args()
7403 
    args.read(iprot)
7404 
    iprot.readMessageEnd()
7405 
    result = markOrdersAsPORaised_result()
7406 
    try:
4369 rajveer 7407 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7408 
    except TransactionServiceException, ex:
7409 
      result.ex = ex
7410 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7411 
    result.write(oprot)
7412 
    oprot.writeMessageEnd()
7413 
    oprot.trans.flush()
4285 rajveer 7414 
 
4303 rajveer 7415 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7416 
    args = markOrdersAsReversalInitiated_args()
7417 
    args.read(iprot)
7418 
    iprot.readMessageEnd()
7419 
    result = markOrdersAsReversalInitiated_result()
7420 
    try:
4369 rajveer 7421 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7422 
    except TransactionServiceException, ex:
7423 
      result.ex = ex
7424 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7425 
    result.write(oprot)
7426 
    oprot.writeMessageEnd()
7427 
    oprot.trans.flush()
7428 
 
7429 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7430 
    args = markOrdersAsNotAvailabke_args()
7431 
    args.read(iprot)
7432 
    iprot.readMessageEnd()
7433 
    result = markOrdersAsNotAvailabke_result()
7434 
    try:
4369 rajveer 7435 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7436 
    except TransactionServiceException, ex:
7437 
      result.ex = ex
7438 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7439 
    result.write(oprot)
7440 
    oprot.writeMessageEnd()
7441 
    oprot.trans.flush()
7442 
 
4369 rajveer 7443 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7444 
    args = markOrdersAsTimeout_args()
7445 
    args.read(iprot)
7446 
    iprot.readMessageEnd()
7447 
    result = markOrdersAsTimeout_result()
7448 
    try:
7449 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7450 
    except TransactionServiceException, ex:
7451 
      result.ex = ex
7452 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
4303 rajveer 7456 
 
4662 rajveer 7457 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7458 
    args = markOrderAsLostInTransit_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = markOrderAsLostInTransit_result()
7462 
    try:
7463 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7464 
    except TransactionServiceException, ex:
7465 
      result.ex = ex
7466 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7467 
    result.write(oprot)
7468 
    oprot.writeMessageEnd()
7469 
    oprot.trans.flush()
7470 
 
4386 anupam.sin 7471 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7472 
    args = getOrderForAwb_args()
7473 
    args.read(iprot)
7474 
    iprot.readMessageEnd()
7475 
    result = getOrderForAwb_result()
7476 
    try:
7477 
      result.success = self._handler.getOrderForAwb(args.awb)
7478 
    except TransactionServiceException, ex:
7479 
      result.ex = ex
7480 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7481 
    result.write(oprot)
7482 
    oprot.writeMessageEnd()
7483 
    oprot.trans.flush()
4369 rajveer 7484 
 
4506 phani.kuma 7485 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7486 
    args = getOrdersForProviderForStatus_args()
7487 
    args.read(iprot)
7488 
    iprot.readMessageEnd()
7489 
    result = getOrdersForProviderForStatus_result()
7490 
    try:
4910 phani.kuma 7491 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7492 
    except TransactionServiceException, ex:
7493 
      result.ex = ex
7494 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7495 
    result.write(oprot)
7496 
    oprot.writeMessageEnd()
7497 
    oprot.trans.flush()
4386 anupam.sin 7498 
 
4600 varun.gupt 7499 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7500 
    args = getBilledOrdersForVendor_args()
7501 
    args.read(iprot)
7502 
    iprot.readMessageEnd()
7503 
    result = getBilledOrdersForVendor_result()
7504 
    try:
7505 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7506 
    except TransactionServiceException, ex:
7507 
      result.ex = ex
7508 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7509 
    result.write(oprot)
7510 
    oprot.writeMessageEnd()
7511 
    oprot.trans.flush()
4506 phani.kuma 7512 
 
4607 rajveer 7513 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7514 
    args = getSlippedSippingDateOrders_args()
7515 
    args.read(iprot)
7516 
    iprot.readMessageEnd()
7517 
    result = getSlippedSippingDateOrders_result()
7518 
    try:
7519 
      result.success = self._handler.getSlippedSippingDateOrders()
7520 
    except TransactionServiceException, ex:
7521 
      result.ex = ex
7522 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7523 
    result.write(oprot)
7524 
    oprot.writeMessageEnd()
7525 
    oprot.trans.flush()
7526 
 
4709 rajveer 7527 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7528 
    args = getCancelledOrders_args()
7529 
    args.read(iprot)
7530 
    iprot.readMessageEnd()
7531 
    result = getCancelledOrders_result()
7532 
    try:
7533 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7534 
    except TransactionServiceException, ex:
7535 
      result.ex = ex
7536 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7537 
    result.write(oprot)
7538 
    oprot.writeMessageEnd()
7539 
    oprot.trans.flush()
7540 
 
4600 varun.gupt 7541 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7542 
    args = saveBluedartSettlements_args()
7543 
    args.read(iprot)
7544 
    iprot.readMessageEnd()
7545 
    result = saveBluedartSettlements_result()
7546 
    try:
7547 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7548 
    except TransactionServiceException, ex:
7549 
      result.ex = ex
7550 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7551 
    result.write(oprot)
7552 
    oprot.writeMessageEnd()
7553 
    oprot.trans.flush()
7554 
 
7555 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7556 
    args = savePaymentSettlements_args()
7557 
    args.read(iprot)
7558 
    iprot.readMessageEnd()
7559 
    result = savePaymentSettlements_result()
7560 
    try:
4905 varun.gupt 7561 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7562 
    except TransactionServiceException, ex:
7563 
      result.ex = ex
7564 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7565 
    result.write(oprot)
7566 
    oprot.writeMessageEnd()
7567 
    oprot.trans.flush()
7568 
 
7569 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7570 
    args = saveEBSSettlementSummary_args()
7571 
    args.read(iprot)
7572 
    iprot.readMessageEnd()
7573 
    result = saveEBSSettlementSummary_result()
7574 
    try:
7575 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7576 
    except TransactionServiceException, ex:
7577 
      result.ex = ex
7578 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7579 
    result.write(oprot)
7580 
    oprot.writeMessageEnd()
7581 
    oprot.trans.flush()
7582 
 
5386 phani.kuma 7583 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7584 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7585 
    args.read(iprot)
7586 
    iprot.readMessageEnd()
5386 phani.kuma 7587 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7588 
    try:
5386 phani.kuma 7589 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7590 
    except TransactionServiceException, ex:
7591 
      result.ex = ex
5386 phani.kuma 7592 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7593 
    result.write(oprot)
7594 
    oprot.writeMessageEnd()
7595 
    oprot.trans.flush()
7596 
 
5386 phani.kuma 7597 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7598 
    args = getSettlementForCod_args()
7599 
    args.read(iprot)
7600 
    iprot.readMessageEnd()
7601 
    result = getSettlementForCod_result()
7602 
    try:
7603 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7604 
    except TransactionServiceException, ex:
7605 
      result.ex = ex
7606 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7607 
    result.write(oprot)
7608 
    oprot.writeMessageEnd()
7609 
    oprot.trans.flush()
7610 
 
4600 varun.gupt 7611 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7612 
    args = getEBSSettlementSummaries_args()
7613 
    args.read(iprot)
7614 
    iprot.readMessageEnd()
7615 
    result = getEBSSettlementSummaries_result()
7616 
    try:
7617 
      result.success = self._handler.getEBSSettlementSummaries()
7618 
    except TransactionServiceException, ex:
7619 
      result.ex = ex
7620 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7621 
    result.write(oprot)
7622 
    oprot.writeMessageEnd()
7623 
    oprot.trans.flush()
7624 
 
7625 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7626 
    args = markEBSSettlementUploaded_args()
7627 
    args.read(iprot)
7628 
    iprot.readMessageEnd()
7629 
    result = markEBSSettlementUploaded_result()
7630 
    try:
7631 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7632 
    except TransactionServiceException, ex:
7633 
      result.ex = ex
7634 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
7639 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7640 
    args = getEBSSettlementDate_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = getEBSSettlementDate_result()
7644 
    try:
7645 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7646 
    except TransactionServiceException, ex:
7647 
      result.ex = ex
7648 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
7652 
 
4715 varun.gupt 7653 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7654 
    args = getSettlementsByDate_args()
7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
7657 
    result = getSettlementsByDate_result()
7658 
    try:
7659 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7660 
    except TransactionServiceException, ex:
7661 
      result.ex = ex
7662 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
4600 varun.gupt 7666 
 
4715 varun.gupt 7667 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7668 
    args = getReshippedOrderIds_args()
7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
7671 
    result = getReshippedOrderIds_result()
7672 
    try:
7673 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7674 
    except TransactionServiceException, ex:
7675 
      result.ex = ex
7676 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
7680 
 
5481 phani.kuma 7681 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7682 
    args = getBilledOrders_args()
4875 varun.gupt 7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
5481 phani.kuma 7685 
    result = getBilledOrders_result()
4875 varun.gupt 7686 
    try:
5481 phani.kuma 7687 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7688 
    except TransactionServiceException, ex:
7689 
      result.ex = ex
5481 phani.kuma 7690 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
4757 mandeep.dh 7694 
 
5031 varun.gupt 7695 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7696 
    args = getStatusDistributionOfOrders_args()
7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
7699 
    result = getStatusDistributionOfOrders_result()
7700 
    try:
7701 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7702 
    except TransactionServiceException, ex:
7703 
      result.ex = ex
7704 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
4875 varun.gupt 7708 
 
5067 varun.gupt 7709 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7710 
    args = getOrderIdsForStatus_args()
7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
7713 
    result = getOrderIdsForStatus_result()
7714 
    try:
7715 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7716 
    except TransactionServiceException, ex:
7717 
      result.ex = ex
7718 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7719 
    result.write(oprot)
7720 
    oprot.writeMessageEnd()
7721 
    oprot.trans.flush()
5031 varun.gupt 7722 
 
5348 anupam.sin 7723 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7724 
    args = updateCODAgent_args()
7725 
    args.read(iprot)
7726 
    iprot.readMessageEnd()
7727 
    result = updateCODAgent_result()
7728 
    try:
7729 
      self._handler.updateCODAgent(args.agent, args.orderId)
7730 
    except TransactionServiceException, ex:
7731 
      result.ex = ex
7732 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7733 
    result.write(oprot)
7734 
    oprot.writeMessageEnd()
7735 
    oprot.trans.flush()
7736 
 
5099 varun.gupt 7737 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7738 
    args = updateOrderAsPaidToVendor_args()
7739 
    args.read(iprot)
7740 
    iprot.readMessageEnd()
7741 
    result = updateOrderAsPaidToVendor_result()
7742 
    try:
7743 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7744 
    except TransactionServiceException, ex:
7745 
      result.ex = ex
7746 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7747 
    result.write(oprot)
7748 
    oprot.writeMessageEnd()
7749 
    oprot.trans.flush()
5067 varun.gupt 7750 
 
5386 phani.kuma 7751 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7752 
    args = updateOrderOnlyAsPaidToVendor_args()
7753 
    args.read(iprot)
7754 
    iprot.readMessageEnd()
7755 
    result = updateOrderOnlyAsPaidToVendor_result()
7756 
    try:
7757 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7758 
    except TransactionServiceException, ex:
7759 
      result.ex = ex
7760 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7761 
    result.write(oprot)
7762 
    oprot.writeMessageEnd()
7763 
    oprot.trans.flush()
7764 
 
5208 varun.gupt 7765 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7766 
    args = getRefundedOrdersMarkedPaid_args()
7767 
    args.read(iprot)
7768 
    iprot.readMessageEnd()
7769 
    result = getRefundedOrdersMarkedPaid_result()
7770 
    try:
7771 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7772 
    except TransactionServiceException, ex:
7773 
      result.ex = ex
7774 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7775 
    result.write(oprot)
7776 
    oprot.writeMessageEnd()
7777 
    oprot.trans.flush()
5099 varun.gupt 7778 
 
5447 anupam.sin 7779 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7780 
    args = getAllVerificationAgents_args()
7781 
    args.read(iprot)
7782 
    iprot.readMessageEnd()
7783 
    result = getAllVerificationAgents_result()
7784 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7785 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7786 
    result.write(oprot)
7787 
    oprot.writeMessageEnd()
7788 
    oprot.trans.flush()
5208 varun.gupt 7789 
 
5527 anupam.sin 7790 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7791 
    args = getAllAttributesForOrderId_args()
7792 
    args.read(iprot)
7793 
    iprot.readMessageEnd()
7794 
    result = getAllAttributesForOrderId_result()
7795 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7796 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7797 
    result.write(oprot)
7798 
    oprot.writeMessageEnd()
7799 
    oprot.trans.flush()
5447 anupam.sin 7800 
 
5676 rajveer 7801 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7802 
    args = setOrderAttributes_args()
7803 
    args.read(iprot)
7804 
    iprot.readMessageEnd()
7805 
    result = setOrderAttributes_result()
7806 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7807 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7808 
    result.write(oprot)
7809 
    oprot.writeMessageEnd()
7810 
    oprot.trans.flush()
7811 
 
5527 anupam.sin 7812 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7813 
    args = setOrderAttributeForTransaction_args()
7814 
    args.read(iprot)
7815 
    iprot.readMessageEnd()
7816 
    result = setOrderAttributeForTransaction_result()
7817 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7818 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7819 
    result.write(oprot)
7820 
    oprot.writeMessageEnd()
7821 
    oprot.trans.flush()
7822 
 
5553 rajveer 7823 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7824 
    args = getReceivePendingOrders_args()
7825 
    args.read(iprot)
7826 
    iprot.readMessageEnd()
7827 
    result = getReceivePendingOrders_result()
7828 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7829 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7830 
    result.write(oprot)
7831 
    oprot.writeMessageEnd()
7832 
    oprot.trans.flush()
5527 anupam.sin 7833 
 
5553 rajveer 7834 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7835 
    args = getReceivedAtStoreOrders_args()
7836 
    args.read(iprot)
7837 
    iprot.readMessageEnd()
7838 
    result = getReceivedAtStoreOrders_result()
7839 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7840 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
7844 
 
5713 rajveer 7845 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7846 
    args = getOrdersCollectionAtStore_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = getOrdersCollectionAtStore_result()
7850 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7851 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
7855 
 
5833 rajveer 7856 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7857 
    args = getOrderAttributeValue_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = getOrderAttributeValue_result()
7861 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7862 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
6019 rajveer 7867 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
7868 
    args = changeJacketNumber_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = changeJacketNumber_result()
7872 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
7873 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
7874 
    result.write(oprot)
7875 
    oprot.writeMessageEnd()
7876 
    oprot.trans.flush()
7877 
 
7878 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
7879 
    args = markOrderAsRtoInTransit_args()
7880 
    args.read(iprot)
7881 
    iprot.readMessageEnd()
7882 
    result = markOrderAsRtoInTransit_result()
7883 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
7884 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
7885 
    result.write(oprot)
7886 
    oprot.writeMessageEnd()
7887 
    oprot.trans.flush()
7888 
 
5593 mandeep.dh 7889 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7890 
    args = acceptOrderForItem_args()
7891 
    args.read(iprot)
7892 
    iprot.readMessageEnd()
7893 
    result = acceptOrderForItem_result()
7894 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7895 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
5553 rajveer 7899 
 
6000 mandeep.dh 7900 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
7901 
    args = createRechargeOrder_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = createRechargeOrder_result()
7905 
    try:
7906 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
7907 
    except TransactionServiceException, ex:
7908 
      result.ex = ex
7909 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
5593 mandeep.dh 7913 
 
6031 rajveer 7914 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
7915 
    args = getRechargeOrder_args()
7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
7918 
    result = getRechargeOrder_result()
7919 
    try:
7920 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
7921 
    except TransactionServiceException, ex:
7922 
      result.ex = ex
7923 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
7927 
 
7928 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
7929 
    args = getRechargeOrders_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = getRechargeOrders_result()
7933 
    result.success = self._handler.getRechargeOrders(args.userId)
7934 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
7938 
 
6000 mandeep.dh 7939 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
7940 
    args = updateRechargeOrderStatus_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = updateRechargeOrderStatus_result()
7944 
    try:
6031 rajveer 7945 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 7946 
    except TransactionServiceException, ex:
7947 
      result.ex = ex
7948 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
7949 
    result.write(oprot)
7950 
    oprot.writeMessageEnd()
7951 
    oprot.trans.flush()
7952 
 
7953 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
7954 
    args = activateRechargeTxn_args()
7955 
    args.read(iprot)
7956 
    iprot.readMessageEnd()
7957 
    result = activateRechargeTxn_result()
7958 
    try:
6031 rajveer 7959 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 7960 
    except TransactionServiceException, ex:
7961 
      result.ex = ex
7962 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
7963 
    result.write(oprot)
7964 
    oprot.writeMessageEnd()
7965 
    oprot.trans.flush()
7966 
 
6031 rajveer 7967 
  def process_getUserWallet(self, seqid, iprot, oprot):
7968 
    args = getUserWallet_args()
6000 mandeep.dh 7969 
    args.read(iprot)
7970 
    iprot.readMessageEnd()
6031 rajveer 7971 
    result = getUserWallet_result()
7972 
    result.success = self._handler.getUserWallet(args.userId)
7973 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 7974 
    result.write(oprot)
7975 
    oprot.writeMessageEnd()
7976 
    oprot.trans.flush()
7977 
 
6031 rajveer 7978 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
7979 
    args = getUserWalletHistory_args()
6000 mandeep.dh 7980 
    args.read(iprot)
7981 
    iprot.readMessageEnd()
6031 rajveer 7982 
    result = getUserWalletHistory_result()
7983 
    result.success = self._handler.getUserWalletHistory(args.userId)
7984 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 7985 
    result.write(oprot)
7986 
    oprot.writeMessageEnd()
7987 
    oprot.trans.flush()
7988 
 
6048 rajveer 7989 
  def process_getServiceProviders(self, seqid, iprot, oprot):
7990 
    args = getServiceProviders_args()
7991 
    args.read(iprot)
7992 
    iprot.readMessageEnd()
7993 
    result = getServiceProviders_result()
7994 
    result.success = self._handler.getServiceProviders(args.rechargeType)
7995 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
7996 
    result.write(oprot)
7997 
    oprot.writeMessageEnd()
7998 
    oprot.trans.flush()
6000 mandeep.dh 7999 
 
6048 rajveer 8000 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8001 
    args = getServiceProviderForDevice_args()
8002 
    args.read(iprot)
8003 
    iprot.readMessageEnd()
8004 
    result = getServiceProviderForDevice_result()
8005 
    result.success = self._handler.getServiceProviderForDevice(args.deviceNumber)
8006 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8007 
    result.write(oprot)
8008 
    oprot.writeMessageEnd()
8009 
    oprot.trans.flush()
8010 
 
8011 
 
94 ashish 8012 
# HELPER FUNCTIONS AND STRUCTURES
8013 
 
8014 
class createTransaction_args:
8015 
  """
8016 
  Attributes:
8017 
   - transaction
8018 
  """
8019 
 
8020 
  thrift_spec = (
8021 
    None, # 0
8022 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8023 
  )
8024 
 
8025 
  def __init__(self, transaction=None,):
8026 
    self.transaction = transaction
8027 
 
8028 
  def read(self, iprot):
8029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8031 
      return
8032 
    iprot.readStructBegin()
8033 
    while True:
8034 
      (fname, ftype, fid) = iprot.readFieldBegin()
8035 
      if ftype == TType.STOP:
8036 
        break
8037 
      if fid == 1:
8038 
        if ftype == TType.STRUCT:
8039 
          self.transaction = Transaction()
8040 
          self.transaction.read(iprot)
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      else:
8044 
        iprot.skip(ftype)
8045 
      iprot.readFieldEnd()
8046 
    iprot.readStructEnd()
8047 
 
8048 
  def write(self, oprot):
8049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8051 
      return
8052 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8053 
    if self.transaction is not None:
94 ashish 8054 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8055 
      self.transaction.write(oprot)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
3431 rajveer 8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
94 ashish 8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
8075 
class createTransaction_result:
8076 
  """
8077 
  Attributes:
132 ashish 8078 
   - success
94 ashish 8079 
   - ex
8080 
  """
8081 
 
8082 
  thrift_spec = (
132 ashish 8083 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8085 
  )
8086 
 
132 ashish 8087 
  def __init__(self, success=None, ex=None,):
8088 
    self.success = success
94 ashish 8089 
    self.ex = ex
8090 
 
8091 
  def read(self, iprot):
8092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8094 
      return
8095 
    iprot.readStructBegin()
8096 
    while True:
8097 
      (fname, ftype, fid) = iprot.readFieldBegin()
8098 
      if ftype == TType.STOP:
8099 
        break
132 ashish 8100 
      if fid == 0:
8101 
        if ftype == TType.I64:
8102 
          self.success = iprot.readI64();
8103 
        else:
8104 
          iprot.skip(ftype)
8105 
      elif fid == 1:
94 ashish 8106 
        if ftype == TType.STRUCT:
8107 
          self.ex = TransactionServiceException()
8108 
          self.ex.read(iprot)
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
8120 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8121 
    if self.success is not None:
132 ashish 8122 
      oprot.writeFieldBegin('success', TType.I64, 0)
8123 
      oprot.writeI64(self.success)
8124 
      oprot.writeFieldEnd()
3431 rajveer 8125 
    if self.ex is not None:
94 ashish 8126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8127 
      self.ex.write(oprot)
8128 
      oprot.writeFieldEnd()
8129 
    oprot.writeFieldStop()
8130 
    oprot.writeStructEnd()
8131 
 
3431 rajveer 8132 
  def validate(self):
8133 
    return
8134 
 
8135 
 
94 ashish 8136 
  def __repr__(self):
8137 
    L = ['%s=%r' % (key, value)
8138 
      for key, value in self.__dict__.iteritems()]
8139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8140 
 
8141 
  def __eq__(self, other):
8142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8143 
 
8144 
  def __ne__(self, other):
8145 
    return not (self == other)
8146 
 
8147 
class getTransaction_args:
8148 
  """
8149 
  Attributes:
8150 
   - id
8151 
  """
8152 
 
8153 
  thrift_spec = (
8154 
    None, # 0
8155 
    (1, TType.I64, 'id', None, None, ), # 1
8156 
  )
8157 
 
8158 
  def __init__(self, id=None,):
8159 
    self.id = id
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 1:
8171 
        if ftype == TType.I64:
8172 
          self.id = iprot.readI64();
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      else:
8176 
        iprot.skip(ftype)
8177 
      iprot.readFieldEnd()
8178 
    iprot.readStructEnd()
8179 
 
8180 
  def write(self, oprot):
8181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8183 
      return
8184 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8185 
    if self.id is not None:
94 ashish 8186 
      oprot.writeFieldBegin('id', TType.I64, 1)
8187 
      oprot.writeI64(self.id)
8188 
      oprot.writeFieldEnd()
8189 
    oprot.writeFieldStop()
8190 
    oprot.writeStructEnd()
8191 
 
3431 rajveer 8192 
  def validate(self):
8193 
    return
8194 
 
8195 
 
94 ashish 8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
8207 
class getTransaction_result:
8208 
  """
8209 
  Attributes:
8210 
   - success
8211 
   - ex
8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8217 
  )
8218 
 
8219 
  def __init__(self, success=None, ex=None,):
8220 
    self.success = success
8221 
    self.ex = ex
8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 0:
8233 
        if ftype == TType.STRUCT:
8234 
          self.success = Transaction()
8235 
          self.success.read(iprot)
8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      elif fid == 1:
8239 
        if ftype == TType.STRUCT:
8240 
          self.ex = TransactionServiceException()
8241 
          self.ex.read(iprot)
8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      else:
8245 
        iprot.skip(ftype)
8246 
      iprot.readFieldEnd()
8247 
    iprot.readStructEnd()
8248 
 
8249 
  def write(self, oprot):
8250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8252 
      return
8253 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8254 
    if self.success is not None:
94 ashish 8255 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8256 
      self.success.write(oprot)
8257 
      oprot.writeFieldEnd()
3431 rajveer 8258 
    if self.ex is not None:
94 ashish 8259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8260 
      self.ex.write(oprot)
8261 
      oprot.writeFieldEnd()
8262 
    oprot.writeFieldStop()
8263 
    oprot.writeStructEnd()
8264 
 
3431 rajveer 8265 
  def validate(self):
8266 
    return
8267 
 
8268 
 
94 ashish 8269 
  def __repr__(self):
8270 
    L = ['%s=%r' % (key, value)
8271 
      for key, value in self.__dict__.iteritems()]
8272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8273 
 
8274 
  def __eq__(self, other):
8275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8276 
 
8277 
  def __ne__(self, other):
8278 
    return not (self == other)
8279 
 
8280 
class getTransactionsForCustomer_args:
8281 
  """
8282 
  Attributes:
8283 
   - customerId
8284 
   - from_date
8285 
   - to_date
8286 
   - status
8287 
  """
8288 
 
8289 
  thrift_spec = (
8290 
    None, # 0
8291 
    (1, TType.I64, 'customerId', None, None, ), # 1
8292 
    (2, TType.I64, 'from_date', None, None, ), # 2
8293 
    (3, TType.I64, 'to_date', None, None, ), # 3
8294 
    (4, TType.I32, 'status', None, None, ), # 4
8295 
  )
8296 
 
8297 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8298 
    self.customerId = customerId
8299 
    self.from_date = from_date
8300 
    self.to_date = to_date
8301 
    self.status = status
8302 
 
8303 
  def read(self, iprot):
8304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8306 
      return
8307 
    iprot.readStructBegin()
8308 
    while True:
8309 
      (fname, ftype, fid) = iprot.readFieldBegin()
8310 
      if ftype == TType.STOP:
8311 
        break
8312 
      if fid == 1:
8313 
        if ftype == TType.I64:
8314 
          self.customerId = iprot.readI64();
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      elif fid == 2:
8318 
        if ftype == TType.I64:
8319 
          self.from_date = iprot.readI64();
8320 
        else:
8321 
          iprot.skip(ftype)
8322 
      elif fid == 3:
8323 
        if ftype == TType.I64:
8324 
          self.to_date = iprot.readI64();
8325 
        else:
8326 
          iprot.skip(ftype)
8327 
      elif fid == 4:
8328 
        if ftype == TType.I32:
8329 
          self.status = iprot.readI32();
8330 
        else:
8331 
          iprot.skip(ftype)
8332 
      else:
8333 
        iprot.skip(ftype)
8334 
      iprot.readFieldEnd()
8335 
    iprot.readStructEnd()
8336 
 
8337 
  def write(self, oprot):
8338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8340 
      return
8341 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8342 
    if self.customerId is not None:
94 ashish 8343 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8344 
      oprot.writeI64(self.customerId)
8345 
      oprot.writeFieldEnd()
3431 rajveer 8346 
    if self.from_date is not None:
94 ashish 8347 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8348 
      oprot.writeI64(self.from_date)
8349 
      oprot.writeFieldEnd()
3431 rajveer 8350 
    if self.to_date is not None:
94 ashish 8351 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8352 
      oprot.writeI64(self.to_date)
8353 
      oprot.writeFieldEnd()
3431 rajveer 8354 
    if self.status is not None:
94 ashish 8355 
      oprot.writeFieldBegin('status', TType.I32, 4)
8356 
      oprot.writeI32(self.status)
8357 
      oprot.writeFieldEnd()
8358 
    oprot.writeFieldStop()
8359 
    oprot.writeStructEnd()
8360 
 
3431 rajveer 8361 
  def validate(self):
8362 
    return
8363 
 
8364 
 
94 ashish 8365 
  def __repr__(self):
8366 
    L = ['%s=%r' % (key, value)
8367 
      for key, value in self.__dict__.iteritems()]
8368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8369 
 
8370 
  def __eq__(self, other):
8371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8372 
 
8373 
  def __ne__(self, other):
8374 
    return not (self == other)
8375 
 
8376 
class getTransactionsForCustomer_result:
8377 
  """
8378 
  Attributes:
8379 
   - success
8380 
   - ex
8381 
  """
8382 
 
8383 
  thrift_spec = (
8384 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8386 
  )
8387 
 
8388 
  def __init__(self, success=None, ex=None,):
8389 
    self.success = success
8390 
    self.ex = ex
8391 
 
8392 
  def read(self, iprot):
8393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8395 
      return
8396 
    iprot.readStructBegin()
8397 
    while True:
8398 
      (fname, ftype, fid) = iprot.readFieldBegin()
8399 
      if ftype == TType.STOP:
8400 
        break
8401 
      if fid == 0:
8402 
        if ftype == TType.LIST:
8403 
          self.success = []
6031 rajveer 8404 
          (_etype66, _size63) = iprot.readListBegin()
8405 
          for _i67 in xrange(_size63):
8406 
            _elem68 = Transaction()
8407 
            _elem68.read(iprot)
8408 
            self.success.append(_elem68)
94 ashish 8409 
          iprot.readListEnd()
8410 
        else:
8411 
          iprot.skip(ftype)
8412 
      elif fid == 1:
8413 
        if ftype == TType.STRUCT:
8414 
          self.ex = TransactionServiceException()
8415 
          self.ex.read(iprot)
8416 
        else:
8417 
          iprot.skip(ftype)
8418 
      else:
8419 
        iprot.skip(ftype)
8420 
      iprot.readFieldEnd()
8421 
    iprot.readStructEnd()
8422 
 
8423 
  def write(self, oprot):
8424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8426 
      return
8427 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8428 
    if self.success is not None:
94 ashish 8429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8430 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8431 
      for iter69 in self.success:
8432 
        iter69.write(oprot)
94 ashish 8433 
      oprot.writeListEnd()
8434 
      oprot.writeFieldEnd()
3431 rajveer 8435 
    if self.ex is not None:
94 ashish 8436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8437 
      self.ex.write(oprot)
8438 
      oprot.writeFieldEnd()
8439 
    oprot.writeFieldStop()
8440 
    oprot.writeStructEnd()
8441 
 
3431 rajveer 8442 
  def validate(self):
8443 
    return
8444 
 
8445 
 
94 ashish 8446 
  def __repr__(self):
8447 
    L = ['%s=%r' % (key, value)
8448 
      for key, value in self.__dict__.iteritems()]
8449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8450 
 
8451 
  def __eq__(self, other):
8452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8453 
 
8454 
  def __ne__(self, other):
8455 
    return not (self == other)
8456 
 
132 ashish 8457 
class getTransactionsForShoppingCartId_args:
8458 
  """
8459 
  Attributes:
8460 
   - shoppingCartId
8461 
  """
8462 
 
8463 
  thrift_spec = (
8464 
    None, # 0
8465 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8466 
  )
8467 
 
8468 
  def __init__(self, shoppingCartId=None,):
8469 
    self.shoppingCartId = shoppingCartId
8470 
 
8471 
  def read(self, iprot):
8472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8474 
      return
8475 
    iprot.readStructBegin()
8476 
    while True:
8477 
      (fname, ftype, fid) = iprot.readFieldBegin()
8478 
      if ftype == TType.STOP:
8479 
        break
8480 
      if fid == 1:
8481 
        if ftype == TType.I64:
8482 
          self.shoppingCartId = iprot.readI64();
8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      else:
8486 
        iprot.skip(ftype)
8487 
      iprot.readFieldEnd()
8488 
    iprot.readStructEnd()
8489 
 
8490 
  def write(self, oprot):
8491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8493 
      return
8494 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8495 
    if self.shoppingCartId is not None:
132 ashish 8496 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8497 
      oprot.writeI64(self.shoppingCartId)
8498 
      oprot.writeFieldEnd()
8499 
    oprot.writeFieldStop()
8500 
    oprot.writeStructEnd()
8501 
 
3431 rajveer 8502 
  def validate(self):
8503 
    return
8504 
 
8505 
 
132 ashish 8506 
  def __repr__(self):
8507 
    L = ['%s=%r' % (key, value)
8508 
      for key, value in self.__dict__.iteritems()]
8509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8510 
 
8511 
  def __eq__(self, other):
8512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8513 
 
8514 
  def __ne__(self, other):
8515 
    return not (self == other)
8516 
 
8517 
class getTransactionsForShoppingCartId_result:
8518 
  """
8519 
  Attributes:
8520 
   - success
8521 
   - ex
8522 
  """
8523 
 
8524 
  thrift_spec = (
8525 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8527 
  )
8528 
 
8529 
  def __init__(self, success=None, ex=None,):
8530 
    self.success = success
8531 
    self.ex = ex
8532 
 
8533 
  def read(self, iprot):
8534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8536 
      return
8537 
    iprot.readStructBegin()
8538 
    while True:
8539 
      (fname, ftype, fid) = iprot.readFieldBegin()
8540 
      if ftype == TType.STOP:
8541 
        break
8542 
      if fid == 0:
8543 
        if ftype == TType.LIST:
8544 
          self.success = []
6031 rajveer 8545 
          (_etype73, _size70) = iprot.readListBegin()
8546 
          for _i74 in xrange(_size70):
8547 
            _elem75 = Transaction()
8548 
            _elem75.read(iprot)
8549 
            self.success.append(_elem75)
132 ashish 8550 
          iprot.readListEnd()
8551 
        else:
8552 
          iprot.skip(ftype)
8553 
      elif fid == 1:
8554 
        if ftype == TType.STRUCT:
8555 
          self.ex = TransactionServiceException()
8556 
          self.ex.read(iprot)
8557 
        else:
8558 
          iprot.skip(ftype)
8559 
      else:
8560 
        iprot.skip(ftype)
8561 
      iprot.readFieldEnd()
8562 
    iprot.readStructEnd()
8563 
 
8564 
  def write(self, oprot):
8565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8567 
      return
8568 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8569 
    if self.success is not None:
132 ashish 8570 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8571 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8572 
      for iter76 in self.success:
8573 
        iter76.write(oprot)
132 ashish 8574 
      oprot.writeListEnd()
8575 
      oprot.writeFieldEnd()
3431 rajveer 8576 
    if self.ex is not None:
132 ashish 8577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8578 
      self.ex.write(oprot)
8579 
      oprot.writeFieldEnd()
8580 
    oprot.writeFieldStop()
8581 
    oprot.writeStructEnd()
8582 
 
3431 rajveer 8583 
  def validate(self):
8584 
    return
8585 
 
8586 
 
132 ashish 8587 
  def __repr__(self):
8588 
    L = ['%s=%r' % (key, value)
8589 
      for key, value in self.__dict__.iteritems()]
8590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8591 
 
8592 
  def __eq__(self, other):
8593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8594 
 
8595 
  def __ne__(self, other):
8596 
    return not (self == other)
8597 
 
94 ashish 8598 
class getTransactionStatus_args:
8599 
  """
8600 
  Attributes:
8601 
   - transactionId
8602 
  """
8603 
 
8604 
  thrift_spec = (
8605 
    None, # 0
8606 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8607 
  )
8608 
 
8609 
  def __init__(self, transactionId=None,):
8610 
    self.transactionId = transactionId
8611 
 
8612 
  def read(self, iprot):
8613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8615 
      return
8616 
    iprot.readStructBegin()
8617 
    while True:
8618 
      (fname, ftype, fid) = iprot.readFieldBegin()
8619 
      if ftype == TType.STOP:
8620 
        break
8621 
      if fid == 1:
8622 
        if ftype == TType.I64:
8623 
          self.transactionId = iprot.readI64();
8624 
        else:
8625 
          iprot.skip(ftype)
8626 
      else:
8627 
        iprot.skip(ftype)
8628 
      iprot.readFieldEnd()
8629 
    iprot.readStructEnd()
8630 
 
8631 
  def write(self, oprot):
8632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8634 
      return
8635 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8636 
    if self.transactionId is not None:
94 ashish 8637 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8638 
      oprot.writeI64(self.transactionId)
8639 
      oprot.writeFieldEnd()
8640 
    oprot.writeFieldStop()
8641 
    oprot.writeStructEnd()
8642 
 
3431 rajveer 8643 
  def validate(self):
8644 
    return
8645 
 
8646 
 
94 ashish 8647 
  def __repr__(self):
8648 
    L = ['%s=%r' % (key, value)
8649 
      for key, value in self.__dict__.iteritems()]
8650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8651 
 
8652 
  def __eq__(self, other):
8653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8654 
 
8655 
  def __ne__(self, other):
8656 
    return not (self == other)
8657 
 
8658 
class getTransactionStatus_result:
8659 
  """
8660 
  Attributes:
8661 
   - success
8662 
   - ex
8663 
  """
8664 
 
8665 
  thrift_spec = (
8666 
    (0, TType.I32, 'success', None, None, ), # 0
8667 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8668 
  )
8669 
 
8670 
  def __init__(self, success=None, ex=None,):
8671 
    self.success = success
8672 
    self.ex = ex
8673 
 
8674 
  def read(self, iprot):
8675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8677 
      return
8678 
    iprot.readStructBegin()
8679 
    while True:
8680 
      (fname, ftype, fid) = iprot.readFieldBegin()
8681 
      if ftype == TType.STOP:
8682 
        break
8683 
      if fid == 0:
8684 
        if ftype == TType.I32:
8685 
          self.success = iprot.readI32();
8686 
        else:
8687 
          iprot.skip(ftype)
8688 
      elif fid == 1:
8689 
        if ftype == TType.STRUCT:
8690 
          self.ex = TransactionServiceException()
8691 
          self.ex.read(iprot)
8692 
        else:
8693 
          iprot.skip(ftype)
8694 
      else:
8695 
        iprot.skip(ftype)
8696 
      iprot.readFieldEnd()
8697 
    iprot.readStructEnd()
8698 
 
8699 
  def write(self, oprot):
8700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8702 
      return
8703 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8704 
    if self.success is not None:
94 ashish 8705 
      oprot.writeFieldBegin('success', TType.I32, 0)
8706 
      oprot.writeI32(self.success)
8707 
      oprot.writeFieldEnd()
3431 rajveer 8708 
    if self.ex is not None:
94 ashish 8709 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8710 
      self.ex.write(oprot)
8711 
      oprot.writeFieldEnd()
8712 
    oprot.writeFieldStop()
8713 
    oprot.writeStructEnd()
8714 
 
3431 rajveer 8715 
  def validate(self):
8716 
    return
8717 
 
8718 
 
94 ashish 8719 
  def __repr__(self):
8720 
    L = ['%s=%r' % (key, value)
8721 
      for key, value in self.__dict__.iteritems()]
8722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8723 
 
8724 
  def __eq__(self, other):
8725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8726 
 
8727 
  def __ne__(self, other):
8728 
    return not (self == other)
8729 
 
8730 
class changeTransactionStatus_args:
8731 
  """
8732 
  Attributes:
8733 
   - transactionId
8734 
   - status
8735 
   - description
5527 anupam.sin 8736 
   - pickUp
8737 
   - orderType
94 ashish 8738 
  """
8739 
 
8740 
  thrift_spec = (
8741 
    None, # 0
8742 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8743 
    (2, TType.I32, 'status', None, None, ), # 2
8744 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8745 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8746 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8747 
  )
8748 
 
5527 anupam.sin 8749 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8750 
    self.transactionId = transactionId
8751 
    self.status = status
8752 
    self.description = description
5527 anupam.sin 8753 
    self.pickUp = pickUp
8754 
    self.orderType = orderType
94 ashish 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 == 1:
8766 
        if ftype == TType.I64:
8767 
          self.transactionId = iprot.readI64();
8768 
        else:
8769 
          iprot.skip(ftype)
8770 
      elif fid == 2:
8771 
        if ftype == TType.I32:
8772 
          self.status = iprot.readI32();
8773 
        else:
8774 
          iprot.skip(ftype)
8775 
      elif fid == 3:
8776 
        if ftype == TType.STRING:
8777 
          self.description = iprot.readString();
8778 
        else:
8779 
          iprot.skip(ftype)
5387 rajveer 8780 
      elif fid == 4:
5527 anupam.sin 8781 
        if ftype == TType.I64:
8782 
          self.pickUp = iprot.readI64();
5387 rajveer 8783 
        else:
8784 
          iprot.skip(ftype)
5527 anupam.sin 8785 
      elif fid == 5:
8786 
        if ftype == TType.I32:
8787 
          self.orderType = iprot.readI32();
8788 
        else:
8789 
          iprot.skip(ftype)
94 ashish 8790 
      else:
8791 
        iprot.skip(ftype)
8792 
      iprot.readFieldEnd()
8793 
    iprot.readStructEnd()
8794 
 
8795 
  def write(self, oprot):
8796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8798 
      return
8799 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8800 
    if self.transactionId is not None:
94 ashish 8801 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8802 
      oprot.writeI64(self.transactionId)
8803 
      oprot.writeFieldEnd()
3431 rajveer 8804 
    if self.status is not None:
94 ashish 8805 
      oprot.writeFieldBegin('status', TType.I32, 2)
8806 
      oprot.writeI32(self.status)
8807 
      oprot.writeFieldEnd()
3431 rajveer 8808 
    if self.description is not None:
94 ashish 8809 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8810 
      oprot.writeString(self.description)
8811 
      oprot.writeFieldEnd()
5527 anupam.sin 8812 
    if self.pickUp is not None:
8813 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8814 
      oprot.writeI64(self.pickUp)
5387 rajveer 8815 
      oprot.writeFieldEnd()
5527 anupam.sin 8816 
    if self.orderType is not None:
8817 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8818 
      oprot.writeI32(self.orderType)
8819 
      oprot.writeFieldEnd()
94 ashish 8820 
    oprot.writeFieldStop()
8821 
    oprot.writeStructEnd()
8822 
 
3431 rajveer 8823 
  def validate(self):
8824 
    return
8825 
 
8826 
 
94 ashish 8827 
  def __repr__(self):
8828 
    L = ['%s=%r' % (key, value)
8829 
      for key, value in self.__dict__.iteritems()]
8830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8831 
 
8832 
  def __eq__(self, other):
8833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8834 
 
8835 
  def __ne__(self, other):
8836 
    return not (self == other)
8837 
 
8838 
class changeTransactionStatus_result:
8839 
  """
8840 
  Attributes:
8841 
   - success
8842 
   - ex
8843 
  """
8844 
 
8845 
  thrift_spec = (
8846 
    (0, TType.BOOL, 'success', None, None, ), # 0
8847 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8848 
  )
8849 
 
8850 
  def __init__(self, success=None, ex=None,):
8851 
    self.success = success
8852 
    self.ex = ex
8853 
 
8854 
  def read(self, iprot):
8855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8857 
      return
8858 
    iprot.readStructBegin()
8859 
    while True:
8860 
      (fname, ftype, fid) = iprot.readFieldBegin()
8861 
      if ftype == TType.STOP:
8862 
        break
8863 
      if fid == 0:
8864 
        if ftype == TType.BOOL:
8865 
          self.success = iprot.readBool();
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      elif fid == 1:
8869 
        if ftype == TType.STRUCT:
8870 
          self.ex = TransactionServiceException()
8871 
          self.ex.read(iprot)
8872 
        else:
8873 
          iprot.skip(ftype)
8874 
      else:
8875 
        iprot.skip(ftype)
8876 
      iprot.readFieldEnd()
8877 
    iprot.readStructEnd()
8878 
 
8879 
  def write(self, oprot):
8880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8882 
      return
8883 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8884 
    if self.success is not None:
94 ashish 8885 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8886 
      oprot.writeBool(self.success)
8887 
      oprot.writeFieldEnd()
3431 rajveer 8888 
    if self.ex is not None:
94 ashish 8889 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8890 
      self.ex.write(oprot)
8891 
      oprot.writeFieldEnd()
8892 
    oprot.writeFieldStop()
8893 
    oprot.writeStructEnd()
8894 
 
3431 rajveer 8895 
  def validate(self):
8896 
    return
8897 
 
8898 
 
94 ashish 8899 
  def __repr__(self):
8900 
    L = ['%s=%r' % (key, value)
8901 
      for key, value in self.__dict__.iteritems()]
8902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8903 
 
8904 
  def __eq__(self, other):
8905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8906 
 
8907 
  def __ne__(self, other):
8908 
    return not (self == other)
8909 
 
1398 varun.gupt 8910 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8911 
  """
8912 
  Attributes:
8913 
   - transactionId
8914 
  """
8915 
 
8916 
  thrift_spec = (
8917 
    None, # 0
8918 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8919 
  )
8920 
 
8921 
  def __init__(self, transactionId=None,):
8922 
    self.transactionId = transactionId
8923 
 
8924 
  def read(self, iprot):
8925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8927 
      return
8928 
    iprot.readStructBegin()
8929 
    while True:
8930 
      (fname, ftype, fid) = iprot.readFieldBegin()
8931 
      if ftype == TType.STOP:
8932 
        break
8933 
      if fid == 1:
8934 
        if ftype == TType.I64:
8935 
          self.transactionId = iprot.readI64();
8936 
        else:
8937 
          iprot.skip(ftype)
8938 
      else:
8939 
        iprot.skip(ftype)
8940 
      iprot.readFieldEnd()
8941 
    iprot.readStructEnd()
8942 
 
8943 
  def write(self, oprot):
8944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8946 
      return
1398 varun.gupt 8947 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8948 
    if self.transactionId is not None:
1382 varun.gupt 8949 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8950 
      oprot.writeI64(self.transactionId)
8951 
      oprot.writeFieldEnd()
8952 
    oprot.writeFieldStop()
8953 
    oprot.writeStructEnd()
8954 
 
3431 rajveer 8955 
  def validate(self):
8956 
    return
8957 
 
8958 
 
1382 varun.gupt 8959 
  def __repr__(self):
8960 
    L = ['%s=%r' % (key, value)
8961 
      for key, value in self.__dict__.iteritems()]
8962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8963 
 
8964 
  def __eq__(self, other):
8965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8966 
 
8967 
  def __ne__(self, other):
8968 
    return not (self == other)
8969 
 
1398 varun.gupt 8970 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8971 
  """
8972 
  Attributes:
8973 
   - success
8974 
   - ex
8975 
  """
8976 
 
8977 
  thrift_spec = (
8978 
    (0, TType.BOOL, 'success', None, None, ), # 0
8979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8980 
  )
8981 
 
8982 
  def __init__(self, success=None, ex=None,):
8983 
    self.success = success
8984 
    self.ex = ex
8985 
 
8986 
  def read(self, iprot):
8987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8989 
      return
8990 
    iprot.readStructBegin()
8991 
    while True:
8992 
      (fname, ftype, fid) = iprot.readFieldBegin()
8993 
      if ftype == TType.STOP:
8994 
        break
8995 
      if fid == 0:
8996 
        if ftype == TType.BOOL:
8997 
          self.success = iprot.readBool();
8998 
        else:
8999 
          iprot.skip(ftype)
9000 
      elif fid == 1:
9001 
        if ftype == TType.STRUCT:
9002 
          self.ex = TransactionServiceException()
9003 
          self.ex.read(iprot)
9004 
        else:
9005 
          iprot.skip(ftype)
9006 
      else:
9007 
        iprot.skip(ftype)
9008 
      iprot.readFieldEnd()
9009 
    iprot.readStructEnd()
9010 
 
9011 
  def write(self, oprot):
9012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9014 
      return
1398 varun.gupt 9015 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9016 
    if self.success is not None:
1382 varun.gupt 9017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9018 
      oprot.writeBool(self.success)
9019 
      oprot.writeFieldEnd()
3431 rajveer 9020 
    if self.ex is not None:
1382 varun.gupt 9021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9022 
      self.ex.write(oprot)
9023 
      oprot.writeFieldEnd()
9024 
    oprot.writeFieldStop()
9025 
    oprot.writeStructEnd()
9026 
 
3431 rajveer 9027 
  def validate(self):
9028 
    return
9029 
 
9030 
 
1382 varun.gupt 9031 
  def __repr__(self):
9032 
    L = ['%s=%r' % (key, value)
9033 
      for key, value in self.__dict__.iteritems()]
9034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9035 
 
9036 
  def __eq__(self, other):
9037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9038 
 
9039 
  def __ne__(self, other):
9040 
    return not (self == other)
9041 
 
483 rajveer 9042 
class getAllOrders_args:
94 ashish 9043 
  """
9044 
  Attributes:
4801 anupam.sin 9045 
   - statuses
483 rajveer 9046 
   - from_date
9047 
   - to_date
9048 
   - warehouse_id
94 ashish 9049 
  """
9050 
 
9051 
  thrift_spec = (
9052 
    None, # 0
4801 anupam.sin 9053 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9054 
    (2, TType.I64, 'from_date', None, None, ), # 2
9055 
    (3, TType.I64, 'to_date', None, None, ), # 3
9056 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9057 
  )
9058 
 
4801 anupam.sin 9059 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9060 
    self.statuses = statuses
483 rajveer 9061 
    self.from_date = from_date
9062 
    self.to_date = to_date
9063 
    self.warehouse_id = warehouse_id
94 ashish 9064 
 
9065 
  def read(self, iprot):
9066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9068 
      return
9069 
    iprot.readStructBegin()
9070 
    while True:
9071 
      (fname, ftype, fid) = iprot.readFieldBegin()
9072 
      if ftype == TType.STOP:
9073 
        break
9074 
      if fid == 1:
4801 anupam.sin 9075 
        if ftype == TType.LIST:
9076 
          self.statuses = []
6031 rajveer 9077 
          (_etype80, _size77) = iprot.readListBegin()
9078 
          for _i81 in xrange(_size77):
9079 
            _elem82 = iprot.readI32();
9080 
            self.statuses.append(_elem82)
4801 anupam.sin 9081 
          iprot.readListEnd()
94 ashish 9082 
        else:
9083 
          iprot.skip(ftype)
483 rajveer 9084 
      elif fid == 2:
9085 
        if ftype == TType.I64:
9086 
          self.from_date = iprot.readI64();
94 ashish 9087 
        else:
9088 
          iprot.skip(ftype)
483 rajveer 9089 
      elif fid == 3:
9090 
        if ftype == TType.I64:
9091 
          self.to_date = iprot.readI64();
94 ashish 9092 
        else:
9093 
          iprot.skip(ftype)
483 rajveer 9094 
      elif fid == 4:
94 ashish 9095 
        if ftype == TType.I64:
483 rajveer 9096 
          self.warehouse_id = iprot.readI64();
94 ashish 9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      else:
9100 
        iprot.skip(ftype)
9101 
      iprot.readFieldEnd()
9102 
    iprot.readStructEnd()
9103 
 
9104 
  def write(self, oprot):
9105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9107 
      return
483 rajveer 9108 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9109 
    if self.statuses is not None:
9110 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9111 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9112 
      for iter83 in self.statuses:
9113 
        oprot.writeI32(iter83)
4801 anupam.sin 9114 
      oprot.writeListEnd()
94 ashish 9115 
      oprot.writeFieldEnd()
3431 rajveer 9116 
    if self.from_date is not None:
483 rajveer 9117 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9118 
      oprot.writeI64(self.from_date)
94 ashish 9119 
      oprot.writeFieldEnd()
3431 rajveer 9120 
    if self.to_date is not None:
483 rajveer 9121 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9122 
      oprot.writeI64(self.to_date)
94 ashish 9123 
      oprot.writeFieldEnd()
3431 rajveer 9124 
    if self.warehouse_id is not None:
483 rajveer 9125 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9126 
      oprot.writeI64(self.warehouse_id)
94 ashish 9127 
      oprot.writeFieldEnd()
9128 
    oprot.writeFieldStop()
9129 
    oprot.writeStructEnd()
9130 
 
3431 rajveer 9131 
  def validate(self):
9132 
    return
9133 
 
9134 
 
94 ashish 9135 
  def __repr__(self):
9136 
    L = ['%s=%r' % (key, value)
9137 
      for key, value in self.__dict__.iteritems()]
9138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9139 
 
9140 
  def __eq__(self, other):
9141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9142 
 
9143 
  def __ne__(self, other):
9144 
    return not (self == other)
9145 
 
483 rajveer 9146 
class getAllOrders_result:
94 ashish 9147 
  """
9148 
  Attributes:
9149 
   - success
9150 
   - ex
9151 
  """
9152 
 
9153 
  thrift_spec = (
483 rajveer 9154 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9156 
  )
9157 
 
9158 
  def __init__(self, success=None, ex=None,):
9159 
    self.success = success
9160 
    self.ex = ex
9161 
 
9162 
  def read(self, iprot):
9163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9165 
      return
9166 
    iprot.readStructBegin()
9167 
    while True:
9168 
      (fname, ftype, fid) = iprot.readFieldBegin()
9169 
      if ftype == TType.STOP:
9170 
        break
9171 
      if fid == 0:
483 rajveer 9172 
        if ftype == TType.LIST:
9173 
          self.success = []
6031 rajveer 9174 
          (_etype87, _size84) = iprot.readListBegin()
9175 
          for _i88 in xrange(_size84):
9176 
            _elem89 = Order()
9177 
            _elem89.read(iprot)
9178 
            self.success.append(_elem89)
483 rajveer 9179 
          iprot.readListEnd()
94 ashish 9180 
        else:
9181 
          iprot.skip(ftype)
9182 
      elif fid == 1:
9183 
        if ftype == TType.STRUCT:
9184 
          self.ex = TransactionServiceException()
9185 
          self.ex.read(iprot)
9186 
        else:
9187 
          iprot.skip(ftype)
9188 
      else:
9189 
        iprot.skip(ftype)
9190 
      iprot.readFieldEnd()
9191 
    iprot.readStructEnd()
9192 
 
9193 
  def write(self, oprot):
9194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9196 
      return
483 rajveer 9197 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9198 
    if self.success is not None:
483 rajveer 9199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9201 
      for iter90 in self.success:
9202 
        iter90.write(oprot)
483 rajveer 9203 
      oprot.writeListEnd()
94 ashish 9204 
      oprot.writeFieldEnd()
3431 rajveer 9205 
    if self.ex is not None:
94 ashish 9206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9207 
      self.ex.write(oprot)
9208 
      oprot.writeFieldEnd()
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
3431 rajveer 9212 
  def validate(self):
9213 
    return
9214 
 
9215 
 
94 ashish 9216 
  def __repr__(self):
9217 
    L = ['%s=%r' % (key, value)
9218 
      for key, value in self.__dict__.iteritems()]
9219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9220 
 
9221 
  def __eq__(self, other):
9222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9223 
 
9224 
  def __ne__(self, other):
9225 
    return not (self == other)
9226 
 
4133 chandransh 9227 
class getOrdersInBatch_args:
9228 
  """
9229 
  Attributes:
9230 
   - statuses
9231 
   - offset
9232 
   - limit
9233 
   - warehouse_id
9234 
  """
9235 
 
9236 
  thrift_spec = (
9237 
    None, # 0
9238 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9239 
    (2, TType.I64, 'offset', None, None, ), # 2
9240 
    (3, TType.I64, 'limit', None, None, ), # 3
9241 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9242 
  )
9243 
 
9244 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9245 
    self.statuses = statuses
9246 
    self.offset = offset
9247 
    self.limit = limit
9248 
    self.warehouse_id = warehouse_id
9249 
 
9250 
  def read(self, iprot):
9251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9253 
      return
9254 
    iprot.readStructBegin()
9255 
    while True:
9256 
      (fname, ftype, fid) = iprot.readFieldBegin()
9257 
      if ftype == TType.STOP:
9258 
        break
9259 
      if fid == 1:
9260 
        if ftype == TType.LIST:
9261 
          self.statuses = []
6031 rajveer 9262 
          (_etype94, _size91) = iprot.readListBegin()
9263 
          for _i95 in xrange(_size91):
9264 
            _elem96 = iprot.readI32();
9265 
            self.statuses.append(_elem96)
4133 chandransh 9266 
          iprot.readListEnd()
9267 
        else:
9268 
          iprot.skip(ftype)
9269 
      elif fid == 2:
9270 
        if ftype == TType.I64:
9271 
          self.offset = iprot.readI64();
9272 
        else:
9273 
          iprot.skip(ftype)
9274 
      elif fid == 3:
9275 
        if ftype == TType.I64:
9276 
          self.limit = iprot.readI64();
9277 
        else:
9278 
          iprot.skip(ftype)
9279 
      elif fid == 4:
9280 
        if ftype == TType.I64:
9281 
          self.warehouse_id = iprot.readI64();
9282 
        else:
9283 
          iprot.skip(ftype)
9284 
      else:
9285 
        iprot.skip(ftype)
9286 
      iprot.readFieldEnd()
9287 
    iprot.readStructEnd()
9288 
 
9289 
  def write(self, oprot):
9290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9292 
      return
9293 
    oprot.writeStructBegin('getOrdersInBatch_args')
9294 
    if self.statuses is not None:
9295 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9296 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9297 
      for iter97 in self.statuses:
9298 
        oprot.writeI32(iter97)
4133 chandransh 9299 
      oprot.writeListEnd()
9300 
      oprot.writeFieldEnd()
9301 
    if self.offset is not None:
9302 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9303 
      oprot.writeI64(self.offset)
9304 
      oprot.writeFieldEnd()
9305 
    if self.limit is not None:
9306 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9307 
      oprot.writeI64(self.limit)
9308 
      oprot.writeFieldEnd()
9309 
    if self.warehouse_id is not None:
9310 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9311 
      oprot.writeI64(self.warehouse_id)
9312 
      oprot.writeFieldEnd()
9313 
    oprot.writeFieldStop()
9314 
    oprot.writeStructEnd()
9315 
 
9316 
  def validate(self):
9317 
    return
9318 
 
9319 
 
9320 
  def __repr__(self):
9321 
    L = ['%s=%r' % (key, value)
9322 
      for key, value in self.__dict__.iteritems()]
9323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9324 
 
9325 
  def __eq__(self, other):
9326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9327 
 
9328 
  def __ne__(self, other):
9329 
    return not (self == other)
9330 
 
9331 
class getOrdersInBatch_result:
9332 
  """
9333 
  Attributes:
9334 
   - success
9335 
   - ex
9336 
  """
9337 
 
9338 
  thrift_spec = (
9339 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9341 
  )
9342 
 
9343 
  def __init__(self, success=None, ex=None,):
9344 
    self.success = success
9345 
    self.ex = ex
9346 
 
9347 
  def read(self, iprot):
9348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9350 
      return
9351 
    iprot.readStructBegin()
9352 
    while True:
9353 
      (fname, ftype, fid) = iprot.readFieldBegin()
9354 
      if ftype == TType.STOP:
9355 
        break
9356 
      if fid == 0:
9357 
        if ftype == TType.LIST:
9358 
          self.success = []
6031 rajveer 9359 
          (_etype101, _size98) = iprot.readListBegin()
9360 
          for _i102 in xrange(_size98):
9361 
            _elem103 = Order()
9362 
            _elem103.read(iprot)
9363 
            self.success.append(_elem103)
4133 chandransh 9364 
          iprot.readListEnd()
9365 
        else:
9366 
          iprot.skip(ftype)
9367 
      elif fid == 1:
9368 
        if ftype == TType.STRUCT:
9369 
          self.ex = TransactionServiceException()
9370 
          self.ex.read(iprot)
9371 
        else:
9372 
          iprot.skip(ftype)
9373 
      else:
9374 
        iprot.skip(ftype)
9375 
      iprot.readFieldEnd()
9376 
    iprot.readStructEnd()
9377 
 
9378 
  def write(self, oprot):
9379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9381 
      return
9382 
    oprot.writeStructBegin('getOrdersInBatch_result')
9383 
    if self.success is not None:
9384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9386 
      for iter104 in self.success:
9387 
        iter104.write(oprot)
4133 chandransh 9388 
      oprot.writeListEnd()
9389 
      oprot.writeFieldEnd()
9390 
    if self.ex is not None:
9391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9392 
      self.ex.write(oprot)
9393 
      oprot.writeFieldEnd()
9394 
    oprot.writeFieldStop()
9395 
    oprot.writeStructEnd()
9396 
 
9397 
  def validate(self):
9398 
    return
9399 
 
9400 
 
9401 
  def __repr__(self):
9402 
    L = ['%s=%r' % (key, value)
9403 
      for key, value in self.__dict__.iteritems()]
9404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9405 
 
9406 
  def __eq__(self, other):
9407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9408 
 
9409 
  def __ne__(self, other):
9410 
    return not (self == other)
9411 
 
9412 
class getOrderCount_args:
9413 
  """
9414 
  Attributes:
9415 
   - statuses
9416 
   - warehouseId
9417 
  """
9418 
 
9419 
  thrift_spec = (
9420 
    None, # 0
9421 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9422 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9423 
  )
9424 
 
9425 
  def __init__(self, statuses=None, warehouseId=None,):
9426 
    self.statuses = statuses
9427 
    self.warehouseId = warehouseId
9428 
 
9429 
  def read(self, iprot):
9430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9432 
      return
9433 
    iprot.readStructBegin()
9434 
    while True:
9435 
      (fname, ftype, fid) = iprot.readFieldBegin()
9436 
      if ftype == TType.STOP:
9437 
        break
9438 
      if fid == 1:
9439 
        if ftype == TType.LIST:
9440 
          self.statuses = []
6031 rajveer 9441 
          (_etype108, _size105) = iprot.readListBegin()
9442 
          for _i109 in xrange(_size105):
9443 
            _elem110 = iprot.readI32();
9444 
            self.statuses.append(_elem110)
4133 chandransh 9445 
          iprot.readListEnd()
9446 
        else:
9447 
          iprot.skip(ftype)
9448 
      elif fid == 2:
9449 
        if ftype == TType.I64:
9450 
          self.warehouseId = iprot.readI64();
9451 
        else:
9452 
          iprot.skip(ftype)
9453 
      else:
9454 
        iprot.skip(ftype)
9455 
      iprot.readFieldEnd()
9456 
    iprot.readStructEnd()
9457 
 
9458 
  def write(self, oprot):
9459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9461 
      return
9462 
    oprot.writeStructBegin('getOrderCount_args')
9463 
    if self.statuses is not None:
9464 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9465 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9466 
      for iter111 in self.statuses:
9467 
        oprot.writeI32(iter111)
4133 chandransh 9468 
      oprot.writeListEnd()
9469 
      oprot.writeFieldEnd()
9470 
    if self.warehouseId is not None:
9471 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9472 
      oprot.writeI64(self.warehouseId)
9473 
      oprot.writeFieldEnd()
9474 
    oprot.writeFieldStop()
9475 
    oprot.writeStructEnd()
9476 
 
9477 
  def validate(self):
9478 
    return
9479 
 
9480 
 
9481 
  def __repr__(self):
9482 
    L = ['%s=%r' % (key, value)
9483 
      for key, value in self.__dict__.iteritems()]
9484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9485 
 
9486 
  def __eq__(self, other):
9487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9488 
 
9489 
  def __ne__(self, other):
9490 
    return not (self == other)
9491 
 
9492 
class getOrderCount_result:
9493 
  """
9494 
  Attributes:
9495 
   - success
9496 
   - ex
9497 
  """
9498 
 
9499 
  thrift_spec = (
9500 
    (0, TType.I32, 'success', None, None, ), # 0
9501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9502 
  )
9503 
 
9504 
  def __init__(self, success=None, ex=None,):
9505 
    self.success = success
9506 
    self.ex = ex
9507 
 
9508 
  def read(self, iprot):
9509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9511 
      return
9512 
    iprot.readStructBegin()
9513 
    while True:
9514 
      (fname, ftype, fid) = iprot.readFieldBegin()
9515 
      if ftype == TType.STOP:
9516 
        break
9517 
      if fid == 0:
9518 
        if ftype == TType.I32:
9519 
          self.success = iprot.readI32();
9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      elif fid == 1:
9523 
        if ftype == TType.STRUCT:
9524 
          self.ex = TransactionServiceException()
9525 
          self.ex.read(iprot)
9526 
        else:
9527 
          iprot.skip(ftype)
9528 
      else:
9529 
        iprot.skip(ftype)
9530 
      iprot.readFieldEnd()
9531 
    iprot.readStructEnd()
9532 
 
9533 
  def write(self, oprot):
9534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9536 
      return
9537 
    oprot.writeStructBegin('getOrderCount_result')
9538 
    if self.success is not None:
9539 
      oprot.writeFieldBegin('success', TType.I32, 0)
9540 
      oprot.writeI32(self.success)
9541 
      oprot.writeFieldEnd()
9542 
    if self.ex is not None:
9543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9544 
      self.ex.write(oprot)
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
999 varun.gupt 9564 
class getOrdersByBillingDate_args:
9565 
  """
9566 
  Attributes:
9567 
   - status
9568 
   - start_billing_date
9569 
   - end_billing_date
9570 
   - warehouse_id
9571 
  """
9572 
 
9573 
  thrift_spec = (
9574 
    None, # 0
9575 
    (1, TType.I32, 'status', None, None, ), # 1
9576 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9577 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9578 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9579 
  )
9580 
 
9581 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9582 
    self.status = status
9583 
    self.start_billing_date = start_billing_date
9584 
    self.end_billing_date = end_billing_date
9585 
    self.warehouse_id = warehouse_id
9586 
 
9587 
  def read(self, iprot):
9588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9590 
      return
9591 
    iprot.readStructBegin()
9592 
    while True:
9593 
      (fname, ftype, fid) = iprot.readFieldBegin()
9594 
      if ftype == TType.STOP:
9595 
        break
9596 
      if fid == 1:
9597 
        if ftype == TType.I32:
9598 
          self.status = iprot.readI32();
9599 
        else:
9600 
          iprot.skip(ftype)
9601 
      elif fid == 2:
9602 
        if ftype == TType.I64:
9603 
          self.start_billing_date = iprot.readI64();
9604 
        else:
9605 
          iprot.skip(ftype)
9606 
      elif fid == 3:
9607 
        if ftype == TType.I64:
9608 
          self.end_billing_date = iprot.readI64();
9609 
        else:
9610 
          iprot.skip(ftype)
9611 
      elif fid == 4:
9612 
        if ftype == TType.I64:
9613 
          self.warehouse_id = iprot.readI64();
9614 
        else:
9615 
          iprot.skip(ftype)
9616 
      else:
9617 
        iprot.skip(ftype)
9618 
      iprot.readFieldEnd()
9619 
    iprot.readStructEnd()
9620 
 
9621 
  def write(self, oprot):
9622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9624 
      return
9625 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9626 
    if self.status is not None:
999 varun.gupt 9627 
      oprot.writeFieldBegin('status', TType.I32, 1)
9628 
      oprot.writeI32(self.status)
9629 
      oprot.writeFieldEnd()
3431 rajveer 9630 
    if self.start_billing_date is not None:
999 varun.gupt 9631 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9632 
      oprot.writeI64(self.start_billing_date)
9633 
      oprot.writeFieldEnd()
3431 rajveer 9634 
    if self.end_billing_date is not None:
999 varun.gupt 9635 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9636 
      oprot.writeI64(self.end_billing_date)
9637 
      oprot.writeFieldEnd()
3431 rajveer 9638 
    if self.warehouse_id is not None:
999 varun.gupt 9639 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9640 
      oprot.writeI64(self.warehouse_id)
9641 
      oprot.writeFieldEnd()
9642 
    oprot.writeFieldStop()
9643 
    oprot.writeStructEnd()
9644 
 
3431 rajveer 9645 
  def validate(self):
9646 
    return
9647 
 
9648 
 
999 varun.gupt 9649 
  def __repr__(self):
9650 
    L = ['%s=%r' % (key, value)
9651 
      for key, value in self.__dict__.iteritems()]
9652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9653 
 
9654 
  def __eq__(self, other):
9655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9656 
 
9657 
  def __ne__(self, other):
9658 
    return not (self == other)
9659 
 
9660 
class getOrdersByBillingDate_result:
9661 
  """
9662 
  Attributes:
9663 
   - success
9664 
   - ex
9665 
  """
9666 
 
9667 
  thrift_spec = (
9668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9670 
  )
9671 
 
9672 
  def __init__(self, success=None, ex=None,):
9673 
    self.success = success
9674 
    self.ex = ex
9675 
 
9676 
  def read(self, iprot):
9677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9679 
      return
9680 
    iprot.readStructBegin()
9681 
    while True:
9682 
      (fname, ftype, fid) = iprot.readFieldBegin()
9683 
      if ftype == TType.STOP:
9684 
        break
9685 
      if fid == 0:
9686 
        if ftype == TType.LIST:
9687 
          self.success = []
6031 rajveer 9688 
          (_etype115, _size112) = iprot.readListBegin()
9689 
          for _i116 in xrange(_size112):
9690 
            _elem117 = Order()
9691 
            _elem117.read(iprot)
9692 
            self.success.append(_elem117)
999 varun.gupt 9693 
          iprot.readListEnd()
9694 
        else:
9695 
          iprot.skip(ftype)
9696 
      elif fid == 1:
9697 
        if ftype == TType.STRUCT:
9698 
          self.ex = TransactionServiceException()
9699 
          self.ex.read(iprot)
9700 
        else:
9701 
          iprot.skip(ftype)
9702 
      else:
9703 
        iprot.skip(ftype)
9704 
      iprot.readFieldEnd()
9705 
    iprot.readStructEnd()
9706 
 
9707 
  def write(self, oprot):
9708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9710 
      return
9711 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9712 
    if self.success is not None:
999 varun.gupt 9713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9715 
      for iter118 in self.success:
9716 
        iter118.write(oprot)
999 varun.gupt 9717 
      oprot.writeListEnd()
9718 
      oprot.writeFieldEnd()
3431 rajveer 9719 
    if self.ex is not None:
999 varun.gupt 9720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9721 
      self.ex.write(oprot)
9722 
      oprot.writeFieldEnd()
9723 
    oprot.writeFieldStop()
9724 
    oprot.writeStructEnd()
9725 
 
3431 rajveer 9726 
  def validate(self):
9727 
    return
9728 
 
9729 
 
999 varun.gupt 9730 
  def __repr__(self):
9731 
    L = ['%s=%r' % (key, value)
9732 
      for key, value in self.__dict__.iteritems()]
9733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9734 
 
9735 
  def __eq__(self, other):
9736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9737 
 
9738 
  def __ne__(self, other):
9739 
    return not (self == other)
9740 
 
3427 chandransh 9741 
class getOrdersByShippingDate_args:
9742 
  """
9743 
  Attributes:
9744 
   - fromShippingDate
9745 
   - toShippingDate
9746 
   - providerId
9747 
   - warehouseId
3451 chandransh 9748 
   - cod
3427 chandransh 9749 
  """
9750 
 
9751 
  thrift_spec = (
9752 
    None, # 0
9753 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9754 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9755 
    (3, TType.I64, 'providerId', None, None, ), # 3
9756 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9757 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9758 
  )
9759 
 
3451 chandransh 9760 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9761 
    self.fromShippingDate = fromShippingDate
9762 
    self.toShippingDate = toShippingDate
9763 
    self.providerId = providerId
9764 
    self.warehouseId = warehouseId
3451 chandransh 9765 
    self.cod = cod
3427 chandransh 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 == 1:
9777 
        if ftype == TType.I64:
9778 
          self.fromShippingDate = iprot.readI64();
9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      elif fid == 2:
9782 
        if ftype == TType.I64:
9783 
          self.toShippingDate = iprot.readI64();
9784 
        else:
9785 
          iprot.skip(ftype)
9786 
      elif fid == 3:
9787 
        if ftype == TType.I64:
9788 
          self.providerId = iprot.readI64();
9789 
        else:
9790 
          iprot.skip(ftype)
9791 
      elif fid == 4:
9792 
        if ftype == TType.I64:
9793 
          self.warehouseId = iprot.readI64();
9794 
        else:
9795 
          iprot.skip(ftype)
3451 chandransh 9796 
      elif fid == 5:
9797 
        if ftype == TType.BOOL:
9798 
          self.cod = iprot.readBool();
9799 
        else:
9800 
          iprot.skip(ftype)
3427 chandransh 9801 
      else:
9802 
        iprot.skip(ftype)
9803 
      iprot.readFieldEnd()
9804 
    iprot.readStructEnd()
9805 
 
9806 
  def write(self, oprot):
9807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9809 
      return
9810 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9811 
    if self.fromShippingDate is not None:
3427 chandransh 9812 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9813 
      oprot.writeI64(self.fromShippingDate)
9814 
      oprot.writeFieldEnd()
3431 rajveer 9815 
    if self.toShippingDate is not None:
3427 chandransh 9816 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9817 
      oprot.writeI64(self.toShippingDate)
9818 
      oprot.writeFieldEnd()
3431 rajveer 9819 
    if self.providerId is not None:
3427 chandransh 9820 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9821 
      oprot.writeI64(self.providerId)
9822 
      oprot.writeFieldEnd()
3431 rajveer 9823 
    if self.warehouseId is not None:
3427 chandransh 9824 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9825 
      oprot.writeI64(self.warehouseId)
9826 
      oprot.writeFieldEnd()
3451 chandransh 9827 
    if self.cod is not None:
9828 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9829 
      oprot.writeBool(self.cod)
9830 
      oprot.writeFieldEnd()
3427 chandransh 9831 
    oprot.writeFieldStop()
9832 
    oprot.writeStructEnd()
9833 
 
3431 rajveer 9834 
  def validate(self):
9835 
    return
9836 
 
9837 
 
3427 chandransh 9838 
  def __repr__(self):
9839 
    L = ['%s=%r' % (key, value)
9840 
      for key, value in self.__dict__.iteritems()]
9841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9842 
 
9843 
  def __eq__(self, other):
9844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9845 
 
9846 
  def __ne__(self, other):
9847 
    return not (self == other)
9848 
 
9849 
class getOrdersByShippingDate_result:
9850 
  """
9851 
  Attributes:
9852 
   - success
9853 
   - ex
9854 
  """
9855 
 
9856 
  thrift_spec = (
9857 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9859 
  )
9860 
 
9861 
  def __init__(self, success=None, ex=None,):
9862 
    self.success = success
9863 
    self.ex = ex
9864 
 
9865 
  def read(self, iprot):
9866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9868 
      return
9869 
    iprot.readStructBegin()
9870 
    while True:
9871 
      (fname, ftype, fid) = iprot.readFieldBegin()
9872 
      if ftype == TType.STOP:
9873 
        break
9874 
      if fid == 0:
9875 
        if ftype == TType.LIST:
9876 
          self.success = []
6031 rajveer 9877 
          (_etype122, _size119) = iprot.readListBegin()
9878 
          for _i123 in xrange(_size119):
9879 
            _elem124 = Order()
9880 
            _elem124.read(iprot)
9881 
            self.success.append(_elem124)
3427 chandransh 9882 
          iprot.readListEnd()
9883 
        else:
9884 
          iprot.skip(ftype)
9885 
      elif fid == 1:
9886 
        if ftype == TType.STRUCT:
9887 
          self.ex = TransactionServiceException()
9888 
          self.ex.read(iprot)
9889 
        else:
9890 
          iprot.skip(ftype)
9891 
      else:
9892 
        iprot.skip(ftype)
9893 
      iprot.readFieldEnd()
9894 
    iprot.readStructEnd()
9895 
 
9896 
  def write(self, oprot):
9897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9899 
      return
9900 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9901 
    if self.success is not None:
3427 chandransh 9902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9904 
      for iter125 in self.success:
9905 
        iter125.write(oprot)
3427 chandransh 9906 
      oprot.writeListEnd()
9907 
      oprot.writeFieldEnd()
3431 rajveer 9908 
    if self.ex is not None:
3427 chandransh 9909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9910 
      self.ex.write(oprot)
9911 
      oprot.writeFieldEnd()
9912 
    oprot.writeFieldStop()
9913 
    oprot.writeStructEnd()
9914 
 
3431 rajveer 9915 
  def validate(self):
9916 
    return
9917 
 
9918 
 
3427 chandransh 9919 
  def __repr__(self):
9920 
    L = ['%s=%r' % (key, value)
9921 
      for key, value in self.__dict__.iteritems()]
9922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9923 
 
9924 
  def __eq__(self, other):
9925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9926 
 
9927 
  def __ne__(self, other):
9928 
    return not (self == other)
9929 
 
1382 varun.gupt 9930 
class getReturnableOrdersForCustomer_args:
9931 
  """
9932 
  Attributes:
9933 
   - customer_id
9934 
   - limit
9935 
  """
9936 
 
9937 
  thrift_spec = (
9938 
    None, # 0
9939 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9940 
    (2, TType.I64, 'limit', None, None, ), # 2
9941 
  )
9942 
 
9943 
  def __init__(self, customer_id=None, limit=None,):
9944 
    self.customer_id = customer_id
9945 
    self.limit = limit
9946 
 
9947 
  def read(self, iprot):
9948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9950 
      return
9951 
    iprot.readStructBegin()
9952 
    while True:
9953 
      (fname, ftype, fid) = iprot.readFieldBegin()
9954 
      if ftype == TType.STOP:
9955 
        break
9956 
      if fid == 1:
9957 
        if ftype == TType.I64:
9958 
          self.customer_id = iprot.readI64();
9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      elif fid == 2:
9962 
        if ftype == TType.I64:
9963 
          self.limit = iprot.readI64();
9964 
        else:
9965 
          iprot.skip(ftype)
9966 
      else:
9967 
        iprot.skip(ftype)
9968 
      iprot.readFieldEnd()
9969 
    iprot.readStructEnd()
9970 
 
9971 
  def write(self, oprot):
9972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9974 
      return
9975 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9976 
    if self.customer_id is not None:
1382 varun.gupt 9977 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9978 
      oprot.writeI64(self.customer_id)
9979 
      oprot.writeFieldEnd()
3431 rajveer 9980 
    if self.limit is not None:
1382 varun.gupt 9981 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9982 
      oprot.writeI64(self.limit)
9983 
      oprot.writeFieldEnd()
9984 
    oprot.writeFieldStop()
9985 
    oprot.writeStructEnd()
9986 
 
3431 rajveer 9987 
  def validate(self):
9988 
    return
9989 
 
9990 
 
1382 varun.gupt 9991 
  def __repr__(self):
9992 
    L = ['%s=%r' % (key, value)
9993 
      for key, value in self.__dict__.iteritems()]
9994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9995 
 
9996 
  def __eq__(self, other):
9997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9998 
 
9999 
  def __ne__(self, other):
10000 
    return not (self == other)
10001 
 
10002 
class getReturnableOrdersForCustomer_result:
10003 
  """
10004 
  Attributes:
10005 
   - success
10006 
   - ex
10007 
  """
10008 
 
10009 
  thrift_spec = (
10010 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10012 
  )
10013 
 
10014 
  def __init__(self, success=None, ex=None,):
10015 
    self.success = success
10016 
    self.ex = ex
10017 
 
10018 
  def read(self, iprot):
10019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10021 
      return
10022 
    iprot.readStructBegin()
10023 
    while True:
10024 
      (fname, ftype, fid) = iprot.readFieldBegin()
10025 
      if ftype == TType.STOP:
10026 
        break
10027 
      if fid == 0:
10028 
        if ftype == TType.LIST:
10029 
          self.success = []
6031 rajveer 10030 
          (_etype129, _size126) = iprot.readListBegin()
10031 
          for _i130 in xrange(_size126):
10032 
            _elem131 = iprot.readI64();
10033 
            self.success.append(_elem131)
1382 varun.gupt 10034 
          iprot.readListEnd()
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      elif fid == 1:
10038 
        if ftype == TType.STRUCT:
10039 
          self.ex = TransactionServiceException()
10040 
          self.ex.read(iprot)
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      else:
10044 
        iprot.skip(ftype)
10045 
      iprot.readFieldEnd()
10046 
    iprot.readStructEnd()
10047 
 
10048 
  def write(self, oprot):
10049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10051 
      return
10052 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10053 
    if self.success is not None:
1382 varun.gupt 10054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10055 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10056 
      for iter132 in self.success:
10057 
        oprot.writeI64(iter132)
1382 varun.gupt 10058 
      oprot.writeListEnd()
10059 
      oprot.writeFieldEnd()
3431 rajveer 10060 
    if self.ex is not None:
1382 varun.gupt 10061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10062 
      self.ex.write(oprot)
10063 
      oprot.writeFieldEnd()
10064 
    oprot.writeFieldStop()
10065 
    oprot.writeStructEnd()
10066 
 
3431 rajveer 10067 
  def validate(self):
10068 
    return
10069 
 
10070 
 
1382 varun.gupt 10071 
  def __repr__(self):
10072 
    L = ['%s=%r' % (key, value)
10073 
      for key, value in self.__dict__.iteritems()]
10074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10075 
 
10076 
  def __eq__(self, other):
10077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10078 
 
10079 
  def __ne__(self, other):
10080 
    return not (self == other)
10081 
 
10082 
class getCancellableOrdersForCustomer_args:
10083 
  """
10084 
  Attributes:
10085 
   - customer_id
10086 
   - limit
10087 
  """
10088 
 
10089 
  thrift_spec = (
10090 
    None, # 0
10091 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10092 
    (2, TType.I64, 'limit', None, None, ), # 2
10093 
  )
10094 
 
10095 
  def __init__(self, customer_id=None, limit=None,):
10096 
    self.customer_id = customer_id
10097 
    self.limit = limit
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 1:
10109 
        if ftype == TType.I64:
10110 
          self.customer_id = iprot.readI64();
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      elif fid == 2:
10114 
        if ftype == TType.I64:
10115 
          self.limit = iprot.readI64();
10116 
        else:
10117 
          iprot.skip(ftype)
10118 
      else:
10119 
        iprot.skip(ftype)
10120 
      iprot.readFieldEnd()
10121 
    iprot.readStructEnd()
10122 
 
10123 
  def write(self, oprot):
10124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10126 
      return
10127 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10128 
    if self.customer_id is not None:
1382 varun.gupt 10129 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10130 
      oprot.writeI64(self.customer_id)
10131 
      oprot.writeFieldEnd()
3431 rajveer 10132 
    if self.limit is not None:
1382 varun.gupt 10133 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10134 
      oprot.writeI64(self.limit)
10135 
      oprot.writeFieldEnd()
10136 
    oprot.writeFieldStop()
10137 
    oprot.writeStructEnd()
10138 
 
3431 rajveer 10139 
  def validate(self):
10140 
    return
10141 
 
10142 
 
1382 varun.gupt 10143 
  def __repr__(self):
10144 
    L = ['%s=%r' % (key, value)
10145 
      for key, value in self.__dict__.iteritems()]
10146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10147 
 
10148 
  def __eq__(self, other):
10149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10150 
 
10151 
  def __ne__(self, other):
10152 
    return not (self == other)
10153 
 
10154 
class getCancellableOrdersForCustomer_result:
10155 
  """
10156 
  Attributes:
10157 
   - success
10158 
   - ex
10159 
  """
10160 
 
10161 
  thrift_spec = (
10162 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10164 
  )
10165 
 
10166 
  def __init__(self, success=None, ex=None,):
10167 
    self.success = success
10168 
    self.ex = ex
10169 
 
10170 
  def read(self, iprot):
10171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10173 
      return
10174 
    iprot.readStructBegin()
10175 
    while True:
10176 
      (fname, ftype, fid) = iprot.readFieldBegin()
10177 
      if ftype == TType.STOP:
10178 
        break
10179 
      if fid == 0:
10180 
        if ftype == TType.LIST:
10181 
          self.success = []
6031 rajveer 10182 
          (_etype136, _size133) = iprot.readListBegin()
10183 
          for _i137 in xrange(_size133):
10184 
            _elem138 = iprot.readI64();
10185 
            self.success.append(_elem138)
1382 varun.gupt 10186 
          iprot.readListEnd()
10187 
        else:
10188 
          iprot.skip(ftype)
10189 
      elif fid == 1:
10190 
        if ftype == TType.STRUCT:
10191 
          self.ex = TransactionServiceException()
10192 
          self.ex.read(iprot)
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      else:
10196 
        iprot.skip(ftype)
10197 
      iprot.readFieldEnd()
10198 
    iprot.readStructEnd()
10199 
 
10200 
  def write(self, oprot):
10201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10203 
      return
10204 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10205 
    if self.success is not None:
1382 varun.gupt 10206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10207 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10208 
      for iter139 in self.success:
10209 
        oprot.writeI64(iter139)
1382 varun.gupt 10210 
      oprot.writeListEnd()
10211 
      oprot.writeFieldEnd()
3431 rajveer 10212 
    if self.ex is not None:
1382 varun.gupt 10213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10214 
      self.ex.write(oprot)
10215 
      oprot.writeFieldEnd()
10216 
    oprot.writeFieldStop()
10217 
    oprot.writeStructEnd()
10218 
 
3431 rajveer 10219 
  def validate(self):
10220 
    return
10221 
 
10222 
 
1382 varun.gupt 10223 
  def __repr__(self):
10224 
    L = ['%s=%r' % (key, value)
10225 
      for key, value in self.__dict__.iteritems()]
10226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10227 
 
10228 
  def __eq__(self, other):
10229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10230 
 
10231 
  def __ne__(self, other):
10232 
    return not (self == other)
10233 
 
483 rajveer 10234 
class changeOrderStatus_args:
94 ashish 10235 
  """
10236 
  Attributes:
483 rajveer 10237 
   - orderId
10238 
   - status
10239 
   - description
94 ashish 10240 
  """
10241 
 
10242 
  thrift_spec = (
10243 
    None, # 0
483 rajveer 10244 
    (1, TType.I64, 'orderId', None, None, ), # 1
10245 
    (2, TType.I32, 'status', None, None, ), # 2
10246 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10247 
  )
10248 
 
483 rajveer 10249 
  def __init__(self, orderId=None, status=None, description=None,):
10250 
    self.orderId = orderId
10251 
    self.status = status
10252 
    self.description = description
94 ashish 10253 
 
10254 
  def read(self, iprot):
10255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10257 
      return
10258 
    iprot.readStructBegin()
10259 
    while True:
10260 
      (fname, ftype, fid) = iprot.readFieldBegin()
10261 
      if ftype == TType.STOP:
10262 
        break
10263 
      if fid == 1:
10264 
        if ftype == TType.I64:
483 rajveer 10265 
          self.orderId = iprot.readI64();
94 ashish 10266 
        else:
10267 
          iprot.skip(ftype)
10268 
      elif fid == 2:
483 rajveer 10269 
        if ftype == TType.I32:
10270 
          self.status = iprot.readI32();
94 ashish 10271 
        else:
10272 
          iprot.skip(ftype)
483 rajveer 10273 
      elif fid == 3:
10274 
        if ftype == TType.STRING:
10275 
          self.description = iprot.readString();
10276 
        else:
10277 
          iprot.skip(ftype)
94 ashish 10278 
      else:
10279 
        iprot.skip(ftype)
10280 
      iprot.readFieldEnd()
10281 
    iprot.readStructEnd()
10282 
 
10283 
  def write(self, oprot):
10284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10286 
      return
483 rajveer 10287 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10288 
    if self.orderId is not None:
483 rajveer 10289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10290 
      oprot.writeI64(self.orderId)
94 ashish 10291 
      oprot.writeFieldEnd()
3431 rajveer 10292 
    if self.status is not None:
483 rajveer 10293 
      oprot.writeFieldBegin('status', TType.I32, 2)
10294 
      oprot.writeI32(self.status)
94 ashish 10295 
      oprot.writeFieldEnd()
3431 rajveer 10296 
    if self.description is not None:
483 rajveer 10297 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10298 
      oprot.writeString(self.description)
10299 
      oprot.writeFieldEnd()
94 ashish 10300 
    oprot.writeFieldStop()
10301 
    oprot.writeStructEnd()
10302 
 
3431 rajveer 10303 
  def validate(self):
10304 
    return
10305 
 
10306 
 
94 ashish 10307 
  def __repr__(self):
10308 
    L = ['%s=%r' % (key, value)
10309 
      for key, value in self.__dict__.iteritems()]
10310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10311 
 
10312 
  def __eq__(self, other):
10313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10314 
 
10315 
  def __ne__(self, other):
10316 
    return not (self == other)
10317 
 
483 rajveer 10318 
class changeOrderStatus_result:
94 ashish 10319 
  """
10320 
  Attributes:
10321 
   - success
10322 
   - ex
10323 
  """
10324 
 
10325 
  thrift_spec = (
10326 
    (0, TType.BOOL, 'success', None, None, ), # 0
10327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10328 
  )
10329 
 
10330 
  def __init__(self, success=None, ex=None,):
10331 
    self.success = success
10332 
    self.ex = ex
10333 
 
10334 
  def read(self, iprot):
10335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10337 
      return
10338 
    iprot.readStructBegin()
10339 
    while True:
10340 
      (fname, ftype, fid) = iprot.readFieldBegin()
10341 
      if ftype == TType.STOP:
10342 
        break
10343 
      if fid == 0:
10344 
        if ftype == TType.BOOL:
10345 
          self.success = iprot.readBool();
10346 
        else:
10347 
          iprot.skip(ftype)
10348 
      elif fid == 1:
10349 
        if ftype == TType.STRUCT:
10350 
          self.ex = TransactionServiceException()
10351 
          self.ex.read(iprot)
10352 
        else:
10353 
          iprot.skip(ftype)
10354 
      else:
10355 
        iprot.skip(ftype)
10356 
      iprot.readFieldEnd()
10357 
    iprot.readStructEnd()
10358 
 
10359 
  def write(self, oprot):
10360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10362 
      return
483 rajveer 10363 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10364 
    if self.success is not None:
94 ashish 10365 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10366 
      oprot.writeBool(self.success)
10367 
      oprot.writeFieldEnd()
3431 rajveer 10368 
    if self.ex is not None:
94 ashish 10369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10370 
      self.ex.write(oprot)
10371 
      oprot.writeFieldEnd()
10372 
    oprot.writeFieldStop()
10373 
    oprot.writeStructEnd()
10374 
 
3431 rajveer 10375 
  def validate(self):
10376 
    return
10377 
 
10378 
 
94 ashish 10379 
  def __repr__(self):
10380 
    L = ['%s=%r' % (key, value)
10381 
      for key, value in self.__dict__.iteritems()]
10382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10383 
 
10384 
  def __eq__(self, other):
10385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10386 
 
10387 
  def __ne__(self, other):
10388 
    return not (self == other)
10389 
 
3064 chandransh 10390 
class getOrdersForTransaction_args:
494 rajveer 10391 
  """
10392 
  Attributes:
3064 chandransh 10393 
   - transactionId
10394 
   - customerId
494 rajveer 10395 
  """
10396 
 
10397 
  thrift_spec = (
10398 
    None, # 0
3064 chandransh 10399 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10400 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10401 
  )
10402 
 
3064 chandransh 10403 
  def __init__(self, transactionId=None, customerId=None,):
10404 
    self.transactionId = transactionId
10405 
    self.customerId = customerId
494 rajveer 10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      if fid == 1:
10417 
        if ftype == TType.I64:
3064 chandransh 10418 
          self.transactionId = iprot.readI64();
494 rajveer 10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      elif fid == 2:
3064 chandransh 10422 
        if ftype == TType.I64:
10423 
          self.customerId = iprot.readI64();
494 rajveer 10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      else:
10427 
        iprot.skip(ftype)
10428 
      iprot.readFieldEnd()
10429 
    iprot.readStructEnd()
10430 
 
10431 
  def write(self, oprot):
10432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10434 
      return
3064 chandransh 10435 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10436 
    if self.transactionId is not None:
3064 chandransh 10437 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10438 
      oprot.writeI64(self.transactionId)
494 rajveer 10439 
      oprot.writeFieldEnd()
3431 rajveer 10440 
    if self.customerId is not None:
3064 chandransh 10441 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10442 
      oprot.writeI64(self.customerId)
494 rajveer 10443 
      oprot.writeFieldEnd()
10444 
    oprot.writeFieldStop()
10445 
    oprot.writeStructEnd()
10446 
 
3431 rajveer 10447 
  def validate(self):
10448 
    return
10449 
 
10450 
 
494 rajveer 10451 
  def __repr__(self):
10452 
    L = ['%s=%r' % (key, value)
10453 
      for key, value in self.__dict__.iteritems()]
10454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10455 
 
10456 
  def __eq__(self, other):
10457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10458 
 
10459 
  def __ne__(self, other):
10460 
    return not (self == other)
10461 
 
3064 chandransh 10462 
class getOrdersForTransaction_result:
494 rajveer 10463 
  """
10464 
  Attributes:
10465 
   - success
10466 
   - ex
10467 
  """
10468 
 
10469 
  thrift_spec = (
3064 chandransh 10470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10472 
  )
10473 
 
10474 
  def __init__(self, success=None, ex=None,):
10475 
    self.success = success
10476 
    self.ex = ex
10477 
 
10478 
  def read(self, iprot):
10479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10481 
      return
10482 
    iprot.readStructBegin()
10483 
    while True:
10484 
      (fname, ftype, fid) = iprot.readFieldBegin()
10485 
      if ftype == TType.STOP:
10486 
        break
10487 
      if fid == 0:
3064 chandransh 10488 
        if ftype == TType.LIST:
10489 
          self.success = []
6031 rajveer 10490 
          (_etype143, _size140) = iprot.readListBegin()
10491 
          for _i144 in xrange(_size140):
10492 
            _elem145 = Order()
10493 
            _elem145.read(iprot)
10494 
            self.success.append(_elem145)
3064 chandransh 10495 
          iprot.readListEnd()
494 rajveer 10496 
        else:
10497 
          iprot.skip(ftype)
10498 
      elif fid == 1:
10499 
        if ftype == TType.STRUCT:
10500 
          self.ex = TransactionServiceException()
10501 
          self.ex.read(iprot)
10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      else:
10505 
        iprot.skip(ftype)
10506 
      iprot.readFieldEnd()
10507 
    iprot.readStructEnd()
10508 
 
10509 
  def write(self, oprot):
10510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10512 
      return
3064 chandransh 10513 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10514 
    if self.success is not None:
3064 chandransh 10515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10517 
      for iter146 in self.success:
10518 
        iter146.write(oprot)
3064 chandransh 10519 
      oprot.writeListEnd()
494 rajveer 10520 
      oprot.writeFieldEnd()
3431 rajveer 10521 
    if self.ex is not None:
494 rajveer 10522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10523 
      self.ex.write(oprot)
10524 
      oprot.writeFieldEnd()
10525 
    oprot.writeFieldStop()
10526 
    oprot.writeStructEnd()
10527 
 
3431 rajveer 10528 
  def validate(self):
10529 
    return
10530 
 
10531 
 
494 rajveer 10532 
  def __repr__(self):
10533 
    L = ['%s=%r' % (key, value)
10534 
      for key, value in self.__dict__.iteritems()]
10535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10536 
 
10537 
  def __eq__(self, other):
10538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10539 
 
10540 
  def __ne__(self, other):
10541 
    return not (self == other)
10542 
 
3064 chandransh 10543 
class getOrdersForCustomer_args:
1149 chandransh 10544 
  """
10545 
  Attributes:
3064 chandransh 10546 
   - customerId
10547 
   - from_date
10548 
   - to_date
10549 
   - statuses
1149 chandransh 10550 
  """
10551 
 
10552 
  thrift_spec = (
10553 
    None, # 0
3064 chandransh 10554 
    (1, TType.I64, 'customerId', None, None, ), # 1
10555 
    (2, TType.I64, 'from_date', None, None, ), # 2
10556 
    (3, TType.I64, 'to_date', None, None, ), # 3
10557 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10558 
  )
10559 
 
3064 chandransh 10560 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10561 
    self.customerId = customerId
10562 
    self.from_date = from_date
10563 
    self.to_date = to_date
10564 
    self.statuses = statuses
1149 chandransh 10565 
 
10566 
  def read(self, iprot):
10567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10569 
      return
10570 
    iprot.readStructBegin()
10571 
    while True:
10572 
      (fname, ftype, fid) = iprot.readFieldBegin()
10573 
      if ftype == TType.STOP:
10574 
        break
10575 
      if fid == 1:
10576 
        if ftype == TType.I64:
3064 chandransh 10577 
          self.customerId = iprot.readI64();
1149 chandransh 10578 
        else:
10579 
          iprot.skip(ftype)
10580 
      elif fid == 2:
10581 
        if ftype == TType.I64:
3064 chandransh 10582 
          self.from_date = iprot.readI64();
1149 chandransh 10583 
        else:
10584 
          iprot.skip(ftype)
2783 chandransh 10585 
      elif fid == 3:
10586 
        if ftype == TType.I64:
3064 chandransh 10587 
          self.to_date = iprot.readI64();
2783 chandransh 10588 
        else:
10589 
          iprot.skip(ftype)
10590 
      elif fid == 4:
3064 chandransh 10591 
        if ftype == TType.LIST:
10592 
          self.statuses = []
6031 rajveer 10593 
          (_etype150, _size147) = iprot.readListBegin()
10594 
          for _i151 in xrange(_size147):
10595 
            _elem152 = iprot.readI32();
10596 
            self.statuses.append(_elem152)
3064 chandransh 10597 
          iprot.readListEnd()
2783 chandransh 10598 
        else:
10599 
          iprot.skip(ftype)
1149 chandransh 10600 
      else:
10601 
        iprot.skip(ftype)
10602 
      iprot.readFieldEnd()
10603 
    iprot.readStructEnd()
10604 
 
10605 
  def write(self, oprot):
10606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10608 
      return
3064 chandransh 10609 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10610 
    if self.customerId is not None:
3064 chandransh 10611 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10612 
      oprot.writeI64(self.customerId)
1149 chandransh 10613 
      oprot.writeFieldEnd()
3431 rajveer 10614 
    if self.from_date is not None:
3064 chandransh 10615 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10616 
      oprot.writeI64(self.from_date)
1149 chandransh 10617 
      oprot.writeFieldEnd()
3431 rajveer 10618 
    if self.to_date is not None:
3064 chandransh 10619 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10620 
      oprot.writeI64(self.to_date)
2783 chandransh 10621 
      oprot.writeFieldEnd()
3431 rajveer 10622 
    if self.statuses is not None:
3064 chandransh 10623 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10624 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10625 
      for iter153 in self.statuses:
10626 
        oprot.writeI32(iter153)
3064 chandransh 10627 
      oprot.writeListEnd()
2783 chandransh 10628 
      oprot.writeFieldEnd()
1149 chandransh 10629 
    oprot.writeFieldStop()
10630 
    oprot.writeStructEnd()
10631 
 
3431 rajveer 10632 
  def validate(self):
10633 
    return
10634 
 
10635 
 
1149 chandransh 10636 
  def __repr__(self):
10637 
    L = ['%s=%r' % (key, value)
10638 
      for key, value in self.__dict__.iteritems()]
10639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10640 
 
10641 
  def __eq__(self, other):
10642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10643 
 
10644 
  def __ne__(self, other):
10645 
    return not (self == other)
10646 
 
3064 chandransh 10647 
class getOrdersForCustomer_result:
1149 chandransh 10648 
  """
10649 
  Attributes:
10650 
   - success
10651 
   - ex
10652 
  """
10653 
 
10654 
  thrift_spec = (
3064 chandransh 10655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10656 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10657 
  )
10658 
 
10659 
  def __init__(self, success=None, ex=None,):
10660 
    self.success = success
10661 
    self.ex = ex
10662 
 
10663 
  def read(self, iprot):
10664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10666 
      return
10667 
    iprot.readStructBegin()
10668 
    while True:
10669 
      (fname, ftype, fid) = iprot.readFieldBegin()
10670 
      if ftype == TType.STOP:
10671 
        break
10672 
      if fid == 0:
3064 chandransh 10673 
        if ftype == TType.LIST:
10674 
          self.success = []
6031 rajveer 10675 
          (_etype157, _size154) = iprot.readListBegin()
10676 
          for _i158 in xrange(_size154):
10677 
            _elem159 = Order()
10678 
            _elem159.read(iprot)
10679 
            self.success.append(_elem159)
3064 chandransh 10680 
          iprot.readListEnd()
1149 chandransh 10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      elif fid == 1:
10684 
        if ftype == TType.STRUCT:
10685 
          self.ex = TransactionServiceException()
10686 
          self.ex.read(iprot)
10687 
        else:
10688 
          iprot.skip(ftype)
10689 
      else:
10690 
        iprot.skip(ftype)
10691 
      iprot.readFieldEnd()
10692 
    iprot.readStructEnd()
10693 
 
10694 
  def write(self, oprot):
10695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10697 
      return
3064 chandransh 10698 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10699 
    if self.success is not None:
3064 chandransh 10700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10702 
      for iter160 in self.success:
10703 
        iter160.write(oprot)
3064 chandransh 10704 
      oprot.writeListEnd()
1149 chandransh 10705 
      oprot.writeFieldEnd()
3431 rajveer 10706 
    if self.ex is not None:
1149 chandransh 10707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10708 
      self.ex.write(oprot)
10709 
      oprot.writeFieldEnd()
10710 
    oprot.writeFieldStop()
10711 
    oprot.writeStructEnd()
10712 
 
3431 rajveer 10713 
  def validate(self):
10714 
    return
10715 
 
10716 
 
1149 chandransh 10717 
  def __repr__(self):
10718 
    L = ['%s=%r' % (key, value)
10719 
      for key, value in self.__dict__.iteritems()]
10720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10721 
 
10722 
  def __eq__(self, other):
10723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10724 
 
10725 
  def __ne__(self, other):
10726 
    return not (self == other)
10727 
 
3064 chandransh 10728 
class createOrder_args:
921 rajveer 10729 
  """
10730 
  Attributes:
3064 chandransh 10731 
   - order
921 rajveer 10732 
  """
10733 
 
10734 
  thrift_spec = (
10735 
    None, # 0
3064 chandransh 10736 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10737 
  )
10738 
 
3064 chandransh 10739 
  def __init__(self, order=None,):
10740 
    self.order = order
921 rajveer 10741 
 
10742 
  def read(self, iprot):
10743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10745 
      return
10746 
    iprot.readStructBegin()
10747 
    while True:
10748 
      (fname, ftype, fid) = iprot.readFieldBegin()
10749 
      if ftype == TType.STOP:
10750 
        break
10751 
      if fid == 1:
3064 chandransh 10752 
        if ftype == TType.STRUCT:
10753 
          self.order = Order()
10754 
          self.order.read(iprot)
921 rajveer 10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      else:
10758 
        iprot.skip(ftype)
10759 
      iprot.readFieldEnd()
10760 
    iprot.readStructEnd()
10761 
 
10762 
  def write(self, oprot):
10763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10765 
      return
3064 chandransh 10766 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10767 
    if self.order is not None:
3064 chandransh 10768 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10769 
      self.order.write(oprot)
921 rajveer 10770 
      oprot.writeFieldEnd()
10771 
    oprot.writeFieldStop()
10772 
    oprot.writeStructEnd()
10773 
 
3431 rajveer 10774 
  def validate(self):
10775 
    return
10776 
 
10777 
 
921 rajveer 10778 
  def __repr__(self):
10779 
    L = ['%s=%r' % (key, value)
10780 
      for key, value in self.__dict__.iteritems()]
10781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10782 
 
10783 
  def __eq__(self, other):
10784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10785 
 
10786 
  def __ne__(self, other):
10787 
    return not (self == other)
10788 
 
3064 chandransh 10789 
class createOrder_result:
921 rajveer 10790 
  """
10791 
  Attributes:
10792 
   - success
10793 
   - ex
10794 
  """
10795 
 
10796 
  thrift_spec = (
3064 chandransh 10797 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10799 
  )
10800 
 
10801 
  def __init__(self, success=None, ex=None,):
10802 
    self.success = success
10803 
    self.ex = ex
10804 
 
10805 
  def read(self, iprot):
10806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10808 
      return
10809 
    iprot.readStructBegin()
10810 
    while True:
10811 
      (fname, ftype, fid) = iprot.readFieldBegin()
10812 
      if ftype == TType.STOP:
10813 
        break
10814 
      if fid == 0:
3064 chandransh 10815 
        if ftype == TType.I64:
10816 
          self.success = iprot.readI64();
921 rajveer 10817 
        else:
10818 
          iprot.skip(ftype)
10819 
      elif fid == 1:
10820 
        if ftype == TType.STRUCT:
10821 
          self.ex = TransactionServiceException()
10822 
          self.ex.read(iprot)
10823 
        else:
10824 
          iprot.skip(ftype)
10825 
      else:
10826 
        iprot.skip(ftype)
10827 
      iprot.readFieldEnd()
10828 
    iprot.readStructEnd()
10829 
 
10830 
  def write(self, oprot):
10831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10833 
      return
3064 chandransh 10834 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10835 
    if self.success is not None:
3064 chandransh 10836 
      oprot.writeFieldBegin('success', TType.I64, 0)
10837 
      oprot.writeI64(self.success)
921 rajveer 10838 
      oprot.writeFieldEnd()
3431 rajveer 10839 
    if self.ex is not None:
921 rajveer 10840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10841 
      self.ex.write(oprot)
10842 
      oprot.writeFieldEnd()
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
3431 rajveer 10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
921 rajveer 10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
3064 chandransh 10861 
class getOrder_args:
921 rajveer 10862 
  """
10863 
  Attributes:
3064 chandransh 10864 
   - id
921 rajveer 10865 
  """
10866 
 
10867 
  thrift_spec = (
10868 
    None, # 0
3064 chandransh 10869 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10870 
  )
10871 
 
3064 chandransh 10872 
  def __init__(self, id=None,):
10873 
    self.id = id
921 rajveer 10874 
 
10875 
  def read(self, iprot):
10876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10878 
      return
10879 
    iprot.readStructBegin()
10880 
    while True:
10881 
      (fname, ftype, fid) = iprot.readFieldBegin()
10882 
      if ftype == TType.STOP:
10883 
        break
10884 
      if fid == 1:
10885 
        if ftype == TType.I64:
3064 chandransh 10886 
          self.id = iprot.readI64();
921 rajveer 10887 
        else:
10888 
          iprot.skip(ftype)
10889 
      else:
10890 
        iprot.skip(ftype)
10891 
      iprot.readFieldEnd()
10892 
    iprot.readStructEnd()
10893 
 
10894 
  def write(self, oprot):
10895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10897 
      return
3064 chandransh 10898 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10899 
    if self.id is not None:
3064 chandransh 10900 
      oprot.writeFieldBegin('id', TType.I64, 1)
10901 
      oprot.writeI64(self.id)
921 rajveer 10902 
      oprot.writeFieldEnd()
10903 
    oprot.writeFieldStop()
10904 
    oprot.writeStructEnd()
10905 
 
3431 rajveer 10906 
  def validate(self):
10907 
    return
10908 
 
10909 
 
921 rajveer 10910 
  def __repr__(self):
10911 
    L = ['%s=%r' % (key, value)
10912 
      for key, value in self.__dict__.iteritems()]
10913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10914 
 
10915 
  def __eq__(self, other):
10916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10917 
 
10918 
  def __ne__(self, other):
10919 
    return not (self == other)
10920 
 
3064 chandransh 10921 
class getOrder_result:
921 rajveer 10922 
  """
10923 
  Attributes:
10924 
   - success
10925 
   - ex
10926 
  """
10927 
 
10928 
  thrift_spec = (
3064 chandransh 10929 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10931 
  )
10932 
 
10933 
  def __init__(self, success=None, ex=None,):
10934 
    self.success = success
10935 
    self.ex = ex
10936 
 
10937 
  def read(self, iprot):
10938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10940 
      return
10941 
    iprot.readStructBegin()
10942 
    while True:
10943 
      (fname, ftype, fid) = iprot.readFieldBegin()
10944 
      if ftype == TType.STOP:
10945 
        break
10946 
      if fid == 0:
3064 chandransh 10947 
        if ftype == TType.STRUCT:
10948 
          self.success = Order()
10949 
          self.success.read(iprot)
921 rajveer 10950 
        else:
10951 
          iprot.skip(ftype)
10952 
      elif fid == 1:
10953 
        if ftype == TType.STRUCT:
10954 
          self.ex = TransactionServiceException()
10955 
          self.ex.read(iprot)
10956 
        else:
10957 
          iprot.skip(ftype)
10958 
      else:
10959 
        iprot.skip(ftype)
10960 
      iprot.readFieldEnd()
10961 
    iprot.readStructEnd()
10962 
 
10963 
  def write(self, oprot):
10964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10966 
      return
3064 chandransh 10967 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10968 
    if self.success is not None:
3064 chandransh 10969 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10970 
      self.success.write(oprot)
921 rajveer 10971 
      oprot.writeFieldEnd()
3431 rajveer 10972 
    if self.ex is not None:
921 rajveer 10973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10974 
      self.ex.write(oprot)
10975 
      oprot.writeFieldEnd()
10976 
    oprot.writeFieldStop()
10977 
    oprot.writeStructEnd()
10978 
 
3431 rajveer 10979 
  def validate(self):
10980 
    return
10981 
 
10982 
 
921 rajveer 10983 
  def __repr__(self):
10984 
    L = ['%s=%r' % (key, value)
10985 
      for key, value in self.__dict__.iteritems()]
10986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10987 
 
10988 
  def __eq__(self, other):
10989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10990 
 
10991 
  def __ne__(self, other):
10992 
    return not (self == other)
10993 
 
3064 chandransh 10994 
class getLineItemsForOrder_args:
94 ashish 10995 
  """
10996 
  Attributes:
3064 chandransh 10997 
   - orderId
94 ashish 10998 
  """
10999 
 
11000 
  thrift_spec = (
11001 
    None, # 0
3064 chandransh 11002 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11003 
  )
11004 
 
3064 chandransh 11005 
  def __init__(self, orderId=None,):
11006 
    self.orderId = orderId
94 ashish 11007 
 
11008 
  def read(self, iprot):
11009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11011 
      return
11012 
    iprot.readStructBegin()
11013 
    while True:
11014 
      (fname, ftype, fid) = iprot.readFieldBegin()
11015 
      if ftype == TType.STOP:
11016 
        break
11017 
      if fid == 1:
11018 
        if ftype == TType.I64:
3064 chandransh 11019 
          self.orderId = iprot.readI64();
94 ashish 11020 
        else:
11021 
          iprot.skip(ftype)
11022 
      else:
11023 
        iprot.skip(ftype)
11024 
      iprot.readFieldEnd()
11025 
    iprot.readStructEnd()
11026 
 
11027 
  def write(self, oprot):
11028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11030 
      return
3064 chandransh 11031 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11032 
    if self.orderId is not None:
3064 chandransh 11033 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11034 
      oprot.writeI64(self.orderId)
94 ashish 11035 
      oprot.writeFieldEnd()
11036 
    oprot.writeFieldStop()
11037 
    oprot.writeStructEnd()
11038 
 
3431 rajveer 11039 
  def validate(self):
11040 
    return
11041 
 
11042 
 
94 ashish 11043 
  def __repr__(self):
11044 
    L = ['%s=%r' % (key, value)
11045 
      for key, value in self.__dict__.iteritems()]
11046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11047 
 
11048 
  def __eq__(self, other):
11049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11050 
 
11051 
  def __ne__(self, other):
11052 
    return not (self == other)
11053 
 
3064 chandransh 11054 
class getLineItemsForOrder_result:
94 ashish 11055 
  """
11056 
  Attributes:
11057 
   - success
11058 
   - ex
11059 
  """
11060 
 
11061 
  thrift_spec = (
3064 chandransh 11062 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11064 
  )
11065 
 
11066 
  def __init__(self, success=None, ex=None,):
11067 
    self.success = success
11068 
    self.ex = ex
11069 
 
11070 
  def read(self, iprot):
11071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11073 
      return
11074 
    iprot.readStructBegin()
11075 
    while True:
11076 
      (fname, ftype, fid) = iprot.readFieldBegin()
11077 
      if ftype == TType.STOP:
11078 
        break
11079 
      if fid == 0:
483 rajveer 11080 
        if ftype == TType.LIST:
11081 
          self.success = []
6031 rajveer 11082 
          (_etype164, _size161) = iprot.readListBegin()
11083 
          for _i165 in xrange(_size161):
11084 
            _elem166 = LineItem()
11085 
            _elem166.read(iprot)
11086 
            self.success.append(_elem166)
483 rajveer 11087 
          iprot.readListEnd()
94 ashish 11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      elif fid == 1:
11091 
        if ftype == TType.STRUCT:
11092 
          self.ex = TransactionServiceException()
11093 
          self.ex.read(iprot)
11094 
        else:
11095 
          iprot.skip(ftype)
11096 
      else:
11097 
        iprot.skip(ftype)
11098 
      iprot.readFieldEnd()
11099 
    iprot.readStructEnd()
11100 
 
11101 
  def write(self, oprot):
11102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11104 
      return
3064 chandransh 11105 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11106 
    if self.success is not None:
483 rajveer 11107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11109 
      for iter167 in self.success:
11110 
        iter167.write(oprot)
483 rajveer 11111 
      oprot.writeListEnd()
94 ashish 11112 
      oprot.writeFieldEnd()
3431 rajveer 11113 
    if self.ex is not None:
94 ashish 11114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11115 
      self.ex.write(oprot)
11116 
      oprot.writeFieldEnd()
11117 
    oprot.writeFieldStop()
11118 
    oprot.writeStructEnd()
11119 
 
3431 rajveer 11120 
  def validate(self):
11121 
    return
11122 
 
11123 
 
94 ashish 11124 
  def __repr__(self):
11125 
    L = ['%s=%r' % (key, value)
11126 
      for key, value in self.__dict__.iteritems()]
11127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11128 
 
11129 
  def __eq__(self, other):
11130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11131 
 
11132 
  def __ne__(self, other):
11133 
    return not (self == other)
11134 
 
4999 phani.kuma 11135 
class getOrderList_args:
11136 
  """
11137 
  Attributes:
11138 
   - order_ids
11139 
  """
11140 
 
11141 
  thrift_spec = (
11142 
    None, # 0
11143 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11144 
  )
11145 
 
11146 
  def __init__(self, order_ids=None,):
11147 
    self.order_ids = order_ids
11148 
 
11149 
  def read(self, iprot):
11150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11152 
      return
11153 
    iprot.readStructBegin()
11154 
    while True:
11155 
      (fname, ftype, fid) = iprot.readFieldBegin()
11156 
      if ftype == TType.STOP:
11157 
        break
11158 
      if fid == 1:
11159 
        if ftype == TType.LIST:
11160 
          self.order_ids = []
6031 rajveer 11161 
          (_etype171, _size168) = iprot.readListBegin()
11162 
          for _i172 in xrange(_size168):
11163 
            _elem173 = iprot.readI64();
11164 
            self.order_ids.append(_elem173)
4999 phani.kuma 11165 
          iprot.readListEnd()
11166 
        else:
11167 
          iprot.skip(ftype)
11168 
      else:
11169 
        iprot.skip(ftype)
11170 
      iprot.readFieldEnd()
11171 
    iprot.readStructEnd()
11172 
 
11173 
  def write(self, oprot):
11174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11176 
      return
11177 
    oprot.writeStructBegin('getOrderList_args')
11178 
    if self.order_ids is not None:
11179 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11180 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11181 
      for iter174 in self.order_ids:
11182 
        oprot.writeI64(iter174)
4999 phani.kuma 11183 
      oprot.writeListEnd()
11184 
      oprot.writeFieldEnd()
11185 
    oprot.writeFieldStop()
11186 
    oprot.writeStructEnd()
11187 
 
11188 
  def validate(self):
11189 
    return
11190 
 
11191 
 
11192 
  def __repr__(self):
11193 
    L = ['%s=%r' % (key, value)
11194 
      for key, value in self.__dict__.iteritems()]
11195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11196 
 
11197 
  def __eq__(self, other):
11198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11199 
 
11200 
  def __ne__(self, other):
11201 
    return not (self == other)
11202 
 
11203 
class getOrderList_result:
11204 
  """
11205 
  Attributes:
11206 
   - success
11207 
  """
11208 
 
11209 
  thrift_spec = (
11210 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11211 
  )
11212 
 
11213 
  def __init__(self, success=None,):
11214 
    self.success = success
11215 
 
11216 
  def read(self, iprot):
11217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11219 
      return
11220 
    iprot.readStructBegin()
11221 
    while True:
11222 
      (fname, ftype, fid) = iprot.readFieldBegin()
11223 
      if ftype == TType.STOP:
11224 
        break
11225 
      if fid == 0:
11226 
        if ftype == TType.LIST:
11227 
          self.success = []
6031 rajveer 11228 
          (_etype178, _size175) = iprot.readListBegin()
11229 
          for _i179 in xrange(_size175):
11230 
            _elem180 = Order()
11231 
            _elem180.read(iprot)
11232 
            self.success.append(_elem180)
4999 phani.kuma 11233 
          iprot.readListEnd()
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      else:
11237 
        iprot.skip(ftype)
11238 
      iprot.readFieldEnd()
11239 
    iprot.readStructEnd()
11240 
 
11241 
  def write(self, oprot):
11242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11244 
      return
11245 
    oprot.writeStructBegin('getOrderList_result')
11246 
    if self.success is not None:
11247 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11248 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11249 
      for iter181 in self.success:
11250 
        iter181.write(oprot)
4999 phani.kuma 11251 
      oprot.writeListEnd()
11252 
      oprot.writeFieldEnd()
11253 
    oprot.writeFieldStop()
11254 
    oprot.writeStructEnd()
11255 
 
11256 
  def validate(self):
11257 
    return
11258 
 
11259 
 
11260 
  def __repr__(self):
11261 
    L = ['%s=%r' % (key, value)
11262 
      for key, value in self.__dict__.iteritems()]
11263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11264 
 
11265 
  def __eq__(self, other):
11266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11267 
 
11268 
  def __ne__(self, other):
11269 
    return not (self == other)
11270 
 
5386 phani.kuma 11271 
class getOrderListForVendor_args:
11272 
  """
11273 
  Attributes:
11274 
   - order_ids
11275 
   - vendorId
11276 
  """
11277 
 
11278 
  thrift_spec = (
11279 
    None, # 0
11280 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11281 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11282 
  )
11283 
 
11284 
  def __init__(self, order_ids=None, vendorId=None,):
11285 
    self.order_ids = order_ids
11286 
    self.vendorId = vendorId
11287 
 
11288 
  def read(self, iprot):
11289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11291 
      return
11292 
    iprot.readStructBegin()
11293 
    while True:
11294 
      (fname, ftype, fid) = iprot.readFieldBegin()
11295 
      if ftype == TType.STOP:
11296 
        break
11297 
      if fid == 1:
11298 
        if ftype == TType.LIST:
11299 
          self.order_ids = []
6031 rajveer 11300 
          (_etype185, _size182) = iprot.readListBegin()
11301 
          for _i186 in xrange(_size182):
11302 
            _elem187 = iprot.readI64();
11303 
            self.order_ids.append(_elem187)
5386 phani.kuma 11304 
          iprot.readListEnd()
11305 
        else:
11306 
          iprot.skip(ftype)
11307 
      elif fid == 2:
11308 
        if ftype == TType.I64:
11309 
          self.vendorId = iprot.readI64();
11310 
        else:
11311 
          iprot.skip(ftype)
11312 
      else:
11313 
        iprot.skip(ftype)
11314 
      iprot.readFieldEnd()
11315 
    iprot.readStructEnd()
11316 
 
11317 
  def write(self, oprot):
11318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11320 
      return
11321 
    oprot.writeStructBegin('getOrderListForVendor_args')
11322 
    if self.order_ids is not None:
11323 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11324 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11325 
      for iter188 in self.order_ids:
11326 
        oprot.writeI64(iter188)
5386 phani.kuma 11327 
      oprot.writeListEnd()
11328 
      oprot.writeFieldEnd()
11329 
    if self.vendorId is not None:
11330 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11331 
      oprot.writeI64(self.vendorId)
11332 
      oprot.writeFieldEnd()
11333 
    oprot.writeFieldStop()
11334 
    oprot.writeStructEnd()
11335 
 
11336 
  def validate(self):
11337 
    return
11338 
 
11339 
 
11340 
  def __repr__(self):
11341 
    L = ['%s=%r' % (key, value)
11342 
      for key, value in self.__dict__.iteritems()]
11343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11344 
 
11345 
  def __eq__(self, other):
11346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11347 
 
11348 
  def __ne__(self, other):
11349 
    return not (self == other)
11350 
 
11351 
class getOrderListForVendor_result:
11352 
  """
11353 
  Attributes:
11354 
   - success
11355 
  """
11356 
 
11357 
  thrift_spec = (
11358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11359 
  )
11360 
 
11361 
  def __init__(self, success=None,):
11362 
    self.success = success
11363 
 
11364 
  def read(self, iprot):
11365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11367 
      return
11368 
    iprot.readStructBegin()
11369 
    while True:
11370 
      (fname, ftype, fid) = iprot.readFieldBegin()
11371 
      if ftype == TType.STOP:
11372 
        break
11373 
      if fid == 0:
11374 
        if ftype == TType.LIST:
11375 
          self.success = []
6031 rajveer 11376 
          (_etype192, _size189) = iprot.readListBegin()
11377 
          for _i193 in xrange(_size189):
11378 
            _elem194 = Order()
11379 
            _elem194.read(iprot)
11380 
            self.success.append(_elem194)
5386 phani.kuma 11381 
          iprot.readListEnd()
11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      else:
11385 
        iprot.skip(ftype)
11386 
      iprot.readFieldEnd()
11387 
    iprot.readStructEnd()
11388 
 
11389 
  def write(self, oprot):
11390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11392 
      return
11393 
    oprot.writeStructBegin('getOrderListForVendor_result')
11394 
    if self.success is not None:
11395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11397 
      for iter195 in self.success:
11398 
        iter195.write(oprot)
5386 phani.kuma 11399 
      oprot.writeListEnd()
11400 
      oprot.writeFieldEnd()
11401 
    oprot.writeFieldStop()
11402 
    oprot.writeStructEnd()
11403 
 
11404 
  def validate(self):
11405 
    return
11406 
 
11407 
 
11408 
  def __repr__(self):
11409 
    L = ['%s=%r' % (key, value)
11410 
      for key, value in self.__dict__.iteritems()]
11411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11412 
 
11413 
  def __eq__(self, other):
11414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11415 
 
11416 
  def __ne__(self, other):
11417 
    return not (self == other)
11418 
 
3064 chandransh 11419 
class getOrderForCustomer_args:
94 ashish 11420 
  """
11421 
  Attributes:
3064 chandransh 11422 
   - orderId
483 rajveer 11423 
   - customerId
94 ashish 11424 
  """
11425 
 
11426 
  thrift_spec = (
11427 
    None, # 0
3064 chandransh 11428 
    (1, TType.I64, 'orderId', None, None, ), # 1
11429 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11430 
  )
11431 
 
3064 chandransh 11432 
  def __init__(self, orderId=None, customerId=None,):
11433 
    self.orderId = orderId
483 rajveer 11434 
    self.customerId = customerId
94 ashish 11435 
 
11436 
  def read(self, iprot):
11437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11439 
      return
11440 
    iprot.readStructBegin()
11441 
    while True:
11442 
      (fname, ftype, fid) = iprot.readFieldBegin()
11443 
      if ftype == TType.STOP:
11444 
        break
11445 
      if fid == 1:
11446 
        if ftype == TType.I64:
3064 chandransh 11447 
          self.orderId = iprot.readI64();
94 ashish 11448 
        else:
11449 
          iprot.skip(ftype)
11450 
      elif fid == 2:
11451 
        if ftype == TType.I64:
3064 chandransh 11452 
          self.customerId = iprot.readI64();
94 ashish 11453 
        else:
11454 
          iprot.skip(ftype)
11455 
      else:
11456 
        iprot.skip(ftype)
11457 
      iprot.readFieldEnd()
11458 
    iprot.readStructEnd()
11459 
 
11460 
  def write(self, oprot):
11461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11463 
      return
3064 chandransh 11464 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11465 
    if self.orderId is not None:
3064 chandransh 11466 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11467 
      oprot.writeI64(self.orderId)
11468 
      oprot.writeFieldEnd()
3431 rajveer 11469 
    if self.customerId is not None:
3064 chandransh 11470 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11471 
      oprot.writeI64(self.customerId)
94 ashish 11472 
      oprot.writeFieldEnd()
11473 
    oprot.writeFieldStop()
11474 
    oprot.writeStructEnd()
11475 
 
3431 rajveer 11476 
  def validate(self):
11477 
    return
11478 
 
11479 
 
94 ashish 11480 
  def __repr__(self):
11481 
    L = ['%s=%r' % (key, value)
11482 
      for key, value in self.__dict__.iteritems()]
11483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11484 
 
11485 
  def __eq__(self, other):
11486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11487 
 
11488 
  def __ne__(self, other):
11489 
    return not (self == other)
11490 
 
3064 chandransh 11491 
class getOrderForCustomer_result:
94 ashish 11492 
  """
11493 
  Attributes:
11494 
   - success
11495 
   - ex
11496 
  """
11497 
 
11498 
  thrift_spec = (
3064 chandransh 11499 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11501 
  )
11502 
 
11503 
  def __init__(self, success=None, ex=None,):
11504 
    self.success = success
11505 
    self.ex = ex
11506 
 
11507 
  def read(self, iprot):
11508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11510 
      return
11511 
    iprot.readStructBegin()
11512 
    while True:
11513 
      (fname, ftype, fid) = iprot.readFieldBegin()
11514 
      if ftype == TType.STOP:
11515 
        break
11516 
      if fid == 0:
3064 chandransh 11517 
        if ftype == TType.STRUCT:
11518 
          self.success = Order()
11519 
          self.success.read(iprot)
94 ashish 11520 
        else:
11521 
          iprot.skip(ftype)
11522 
      elif fid == 1:
11523 
        if ftype == TType.STRUCT:
11524 
          self.ex = TransactionServiceException()
11525 
          self.ex.read(iprot)
11526 
        else:
11527 
          iprot.skip(ftype)
11528 
      else:
11529 
        iprot.skip(ftype)
11530 
      iprot.readFieldEnd()
11531 
    iprot.readStructEnd()
11532 
 
11533 
  def write(self, oprot):
11534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11536 
      return
3064 chandransh 11537 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11538 
    if self.success is not None:
3064 chandransh 11539 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11540 
      self.success.write(oprot)
94 ashish 11541 
      oprot.writeFieldEnd()
3431 rajveer 11542 
    if self.ex is not None:
94 ashish 11543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11544 
      self.ex.write(oprot)
11545 
      oprot.writeFieldEnd()
11546 
    oprot.writeFieldStop()
11547 
    oprot.writeStructEnd()
11548 
 
3431 rajveer 11549 
  def validate(self):
11550 
    return
11551 
 
11552 
 
94 ashish 11553 
  def __repr__(self):
11554 
    L = ['%s=%r' % (key, value)
11555 
      for key, value in self.__dict__.iteritems()]
11556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11557 
 
11558 
  def __eq__(self, other):
11559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11560 
 
11561 
  def __ne__(self, other):
11562 
    return not (self == other)
11563 
 
3064 chandransh 11564 
class getAlerts_args:
94 ashish 11565 
  """
11566 
  Attributes:
4394 rajveer 11567 
   - type
4444 rajveer 11568 
   - warehouseId
4394 rajveer 11569 
   - status
11570 
   - timestamp
94 ashish 11571 
  """
11572 
 
11573 
  thrift_spec = (
11574 
    None, # 0
4394 rajveer 11575 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11576 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11577 
    (3, TType.I64, 'status', None, None, ), # 3
11578 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11579 
  )
11580 
 
4444 rajveer 11581 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11582 
    self.type = type
4444 rajveer 11583 
    self.warehouseId = warehouseId
4394 rajveer 11584 
    self.status = status
11585 
    self.timestamp = timestamp
94 ashish 11586 
 
11587 
  def read(self, iprot):
11588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11590 
      return
11591 
    iprot.readStructBegin()
11592 
    while True:
11593 
      (fname, ftype, fid) = iprot.readFieldBegin()
11594 
      if ftype == TType.STOP:
11595 
        break
11596 
      if fid == 1:
3064 chandransh 11597 
        if ftype == TType.I64:
4394 rajveer 11598 
          self.type = iprot.readI64();
94 ashish 11599 
        else:
11600 
          iprot.skip(ftype)
3064 chandransh 11601 
      elif fid == 2:
4394 rajveer 11602 
        if ftype == TType.I64:
4444 rajveer 11603 
          self.warehouseId = iprot.readI64();
3064 chandransh 11604 
        else:
11605 
          iprot.skip(ftype)
4394 rajveer 11606 
      elif fid == 3:
11607 
        if ftype == TType.I64:
4444 rajveer 11608 
          self.status = iprot.readI64();
11609 
        else:
11610 
          iprot.skip(ftype)
11611 
      elif fid == 4:
11612 
        if ftype == TType.I64:
4394 rajveer 11613 
          self.timestamp = iprot.readI64();
11614 
        else:
11615 
          iprot.skip(ftype)
94 ashish 11616 
      else:
11617 
        iprot.skip(ftype)
11618 
      iprot.readFieldEnd()
11619 
    iprot.readStructEnd()
11620 
 
11621 
  def write(self, oprot):
11622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11624 
      return
3064 chandransh 11625 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11626 
    if self.type is not None:
11627 
      oprot.writeFieldBegin('type', TType.I64, 1)
11628 
      oprot.writeI64(self.type)
94 ashish 11629 
      oprot.writeFieldEnd()
4444 rajveer 11630 
    if self.warehouseId is not None:
11631 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11632 
      oprot.writeI64(self.warehouseId)
11633 
      oprot.writeFieldEnd()
4394 rajveer 11634 
    if self.status is not None:
4444 rajveer 11635 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11636 
      oprot.writeI64(self.status)
3064 chandransh 11637 
      oprot.writeFieldEnd()
4394 rajveer 11638 
    if self.timestamp is not None:
4444 rajveer 11639 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11640 
      oprot.writeI64(self.timestamp)
11641 
      oprot.writeFieldEnd()
94 ashish 11642 
    oprot.writeFieldStop()
11643 
    oprot.writeStructEnd()
11644 
 
3431 rajveer 11645 
  def validate(self):
11646 
    return
11647 
 
11648 
 
94 ashish 11649 
  def __repr__(self):
11650 
    L = ['%s=%r' % (key, value)
11651 
      for key, value in self.__dict__.iteritems()]
11652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11653 
 
11654 
  def __eq__(self, other):
11655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11656 
 
11657 
  def __ne__(self, other):
11658 
    return not (self == other)
11659 
 
3064 chandransh 11660 
class getAlerts_result:
94 ashish 11661 
  """
11662 
  Attributes:
11663 
   - success
11664 
  """
11665 
 
11666 
  thrift_spec = (
3064 chandransh 11667 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11668 
  )
11669 
 
3064 chandransh 11670 
  def __init__(self, success=None,):
94 ashish 11671 
    self.success = success
11672 
 
11673 
  def read(self, iprot):
11674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11676 
      return
11677 
    iprot.readStructBegin()
11678 
    while True:
11679 
      (fname, ftype, fid) = iprot.readFieldBegin()
11680 
      if ftype == TType.STOP:
11681 
        break
11682 
      if fid == 0:
3064 chandransh 11683 
        if ftype == TType.LIST:
11684 
          self.success = []
6031 rajveer 11685 
          (_etype199, _size196) = iprot.readListBegin()
11686 
          for _i200 in xrange(_size196):
11687 
            _elem201 = Alert()
11688 
            _elem201.read(iprot)
11689 
            self.success.append(_elem201)
3064 chandransh 11690 
          iprot.readListEnd()
94 ashish 11691 
        else:
11692 
          iprot.skip(ftype)
11693 
      else:
11694 
        iprot.skip(ftype)
11695 
      iprot.readFieldEnd()
11696 
    iprot.readStructEnd()
11697 
 
11698 
  def write(self, oprot):
11699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11701 
      return
3064 chandransh 11702 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11703 
    if self.success is not None:
3064 chandransh 11704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11706 
      for iter202 in self.success:
11707 
        iter202.write(oprot)
3064 chandransh 11708 
      oprot.writeListEnd()
94 ashish 11709 
      oprot.writeFieldEnd()
11710 
    oprot.writeFieldStop()
11711 
    oprot.writeStructEnd()
11712 
 
3431 rajveer 11713 
  def validate(self):
11714 
    return
11715 
 
11716 
 
94 ashish 11717 
  def __repr__(self):
11718 
    L = ['%s=%r' % (key, value)
11719 
      for key, value in self.__dict__.iteritems()]
11720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11721 
 
11722 
  def __eq__(self, other):
11723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11724 
 
11725 
  def __ne__(self, other):
11726 
    return not (self == other)
11727 
 
4394 rajveer 11728 
class addAlert_args:
94 ashish 11729 
  """
11730 
  Attributes:
3064 chandransh 11731 
   - type
4444 rajveer 11732 
   - warehouseId
4394 rajveer 11733 
   - description
94 ashish 11734 
  """
11735 
 
11736 
  thrift_spec = (
11737 
    None, # 0
4394 rajveer 11738 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11739 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11740 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11741 
  )
11742 
 
4444 rajveer 11743 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11744 
    self.type = type
4444 rajveer 11745 
    self.warehouseId = warehouseId
4394 rajveer 11746 
    self.description = description
94 ashish 11747 
 
11748 
  def read(self, iprot):
11749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11751 
      return
11752 
    iprot.readStructBegin()
11753 
    while True:
11754 
      (fname, ftype, fid) = iprot.readFieldBegin()
11755 
      if ftype == TType.STOP:
11756 
        break
11757 
      if fid == 1:
11758 
        if ftype == TType.I64:
4394 rajveer 11759 
          self.type = iprot.readI64();
94 ashish 11760 
        else:
11761 
          iprot.skip(ftype)
3064 chandransh 11762 
      elif fid == 2:
4444 rajveer 11763 
        if ftype == TType.I64:
11764 
          self.warehouseId = iprot.readI64();
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      elif fid == 3:
3064 chandransh 11768 
        if ftype == TType.STRING:
4394 rajveer 11769 
          self.description = iprot.readString();
3064 chandransh 11770 
        else:
11771 
          iprot.skip(ftype)
94 ashish 11772 
      else:
11773 
        iprot.skip(ftype)
11774 
      iprot.readFieldEnd()
11775 
    iprot.readStructEnd()
11776 
 
11777 
  def write(self, oprot):
11778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11780 
      return
4394 rajveer 11781 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11782 
    if self.type is not None:
4394 rajveer 11783 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11784 
      oprot.writeI64(self.type)
11785 
      oprot.writeFieldEnd()
4444 rajveer 11786 
    if self.warehouseId is not None:
11787 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11788 
      oprot.writeI64(self.warehouseId)
11789 
      oprot.writeFieldEnd()
4394 rajveer 11790 
    if self.description is not None:
4444 rajveer 11791 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11792 
      oprot.writeString(self.description)
3064 chandransh 11793 
      oprot.writeFieldEnd()
94 ashish 11794 
    oprot.writeFieldStop()
11795 
    oprot.writeStructEnd()
11796 
 
3431 rajveer 11797 
  def validate(self):
11798 
    return
11799 
 
11800 
 
94 ashish 11801 
  def __repr__(self):
11802 
    L = ['%s=%r' % (key, value)
11803 
      for key, value in self.__dict__.iteritems()]
11804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11805 
 
11806 
  def __eq__(self, other):
11807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11808 
 
11809 
  def __ne__(self, other):
11810 
    return not (self == other)
11811 
 
4394 rajveer 11812 
class addAlert_result:
3064 chandransh 11813 
 
11814 
  thrift_spec = (
11815 
  )
11816 
 
11817 
  def read(self, iprot):
11818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11820 
      return
11821 
    iprot.readStructBegin()
11822 
    while True:
11823 
      (fname, ftype, fid) = iprot.readFieldBegin()
11824 
      if ftype == TType.STOP:
11825 
        break
11826 
      else:
11827 
        iprot.skip(ftype)
11828 
      iprot.readFieldEnd()
11829 
    iprot.readStructEnd()
11830 
 
11831 
  def write(self, oprot):
11832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11834 
      return
4394 rajveer 11835 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11836 
    oprot.writeFieldStop()
11837 
    oprot.writeStructEnd()
11838 
 
3431 rajveer 11839 
  def validate(self):
11840 
    return
11841 
 
11842 
 
3064 chandransh 11843 
  def __repr__(self):
11844 
    L = ['%s=%r' % (key, value)
11845 
      for key, value in self.__dict__.iteritems()]
11846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11847 
 
11848 
  def __eq__(self, other):
11849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11850 
 
11851 
  def __ne__(self, other):
11852 
    return not (self == other)
11853 
 
4444 rajveer 11854 
class markAlertsAsSeen_args:
11855 
  """
11856 
  Attributes:
11857 
   - warehouseId
11858 
  """
11859 
 
11860 
  thrift_spec = (
11861 
    None, # 0
11862 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11863 
  )
11864 
 
11865 
  def __init__(self, warehouseId=None,):
11866 
    self.warehouseId = warehouseId
11867 
 
11868 
  def read(self, iprot):
11869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11871 
      return
11872 
    iprot.readStructBegin()
11873 
    while True:
11874 
      (fname, ftype, fid) = iprot.readFieldBegin()
11875 
      if ftype == TType.STOP:
11876 
        break
11877 
      if fid == 1:
11878 
        if ftype == TType.I64:
11879 
          self.warehouseId = iprot.readI64();
11880 
        else:
11881 
          iprot.skip(ftype)
11882 
      else:
11883 
        iprot.skip(ftype)
11884 
      iprot.readFieldEnd()
11885 
    iprot.readStructEnd()
11886 
 
11887 
  def write(self, oprot):
11888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11890 
      return
11891 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11892 
    if self.warehouseId is not None:
11893 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11894 
      oprot.writeI64(self.warehouseId)
11895 
      oprot.writeFieldEnd()
11896 
    oprot.writeFieldStop()
11897 
    oprot.writeStructEnd()
11898 
 
11899 
  def validate(self):
11900 
    return
11901 
 
11902 
 
11903 
  def __repr__(self):
11904 
    L = ['%s=%r' % (key, value)
11905 
      for key, value in self.__dict__.iteritems()]
11906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11907 
 
11908 
  def __eq__(self, other):
11909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11910 
 
11911 
  def __ne__(self, other):
11912 
    return not (self == other)
11913 
 
11914 
class markAlertsAsSeen_result:
11915 
 
11916 
  thrift_spec = (
11917 
  )
11918 
 
11919 
  def read(self, iprot):
11920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11922 
      return
11923 
    iprot.readStructBegin()
11924 
    while True:
11925 
      (fname, ftype, fid) = iprot.readFieldBegin()
11926 
      if ftype == TType.STOP:
11927 
        break
11928 
      else:
11929 
        iprot.skip(ftype)
11930 
      iprot.readFieldEnd()
11931 
    iprot.readStructEnd()
11932 
 
11933 
  def write(self, oprot):
11934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11936 
      return
11937 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11938 
    oprot.writeFieldStop()
11939 
    oprot.writeStructEnd()
11940 
 
11941 
  def validate(self):
11942 
    return
11943 
 
11944 
 
11945 
  def __repr__(self):
11946 
    L = ['%s=%r' % (key, value)
11947 
      for key, value in self.__dict__.iteritems()]
11948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11949 
 
11950 
  def __eq__(self, other):
11951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11952 
 
11953 
  def __ne__(self, other):
11954 
    return not (self == other)
11955 
 
3064 chandransh 11956 
class getValidOrderCount_args:
11957 
 
11958 
  thrift_spec = (
11959 
  )
11960 
 
11961 
  def read(self, iprot):
11962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11964 
      return
11965 
    iprot.readStructBegin()
11966 
    while True:
11967 
      (fname, ftype, fid) = iprot.readFieldBegin()
11968 
      if ftype == TType.STOP:
11969 
        break
11970 
      else:
11971 
        iprot.skip(ftype)
11972 
      iprot.readFieldEnd()
11973 
    iprot.readStructEnd()
11974 
 
11975 
  def write(self, oprot):
11976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11978 
      return
11979 
    oprot.writeStructBegin('getValidOrderCount_args')
11980 
    oprot.writeFieldStop()
11981 
    oprot.writeStructEnd()
11982 
 
3431 rajveer 11983 
  def validate(self):
11984 
    return
11985 
 
11986 
 
3064 chandransh 11987 
  def __repr__(self):
11988 
    L = ['%s=%r' % (key, value)
11989 
      for key, value in self.__dict__.iteritems()]
11990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11991 
 
11992 
  def __eq__(self, other):
11993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11994 
 
11995 
  def __ne__(self, other):
11996 
    return not (self == other)
11997 
 
11998 
class getValidOrderCount_result:
94 ashish 11999 
  """
12000 
  Attributes:
12001 
   - success
12002 
  """
12003 
 
12004 
  thrift_spec = (
3064 chandransh 12005 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12006 
  )
12007 
 
3064 chandransh 12008 
  def __init__(self, success=None,):
94 ashish 12009 
    self.success = success
12010 
 
12011 
  def read(self, iprot):
12012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12014 
      return
12015 
    iprot.readStructBegin()
12016 
    while True:
12017 
      (fname, ftype, fid) = iprot.readFieldBegin()
12018 
      if ftype == TType.STOP:
12019 
        break
12020 
      if fid == 0:
3064 chandransh 12021 
        if ftype == TType.I64:
12022 
          self.success = iprot.readI64();
94 ashish 12023 
        else:
12024 
          iprot.skip(ftype)
12025 
      else:
12026 
        iprot.skip(ftype)
12027 
      iprot.readFieldEnd()
12028 
    iprot.readStructEnd()
12029 
 
12030 
  def write(self, oprot):
12031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12033 
      return
3064 chandransh 12034 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12035 
    if self.success is not None:
3064 chandransh 12036 
      oprot.writeFieldBegin('success', TType.I64, 0)
12037 
      oprot.writeI64(self.success)
94 ashish 12038 
      oprot.writeFieldEnd()
12039 
    oprot.writeFieldStop()
12040 
    oprot.writeStructEnd()
12041 
 
3431 rajveer 12042 
  def validate(self):
12043 
    return
12044 
 
12045 
 
94 ashish 12046 
  def __repr__(self):
12047 
    L = ['%s=%r' % (key, value)
12048 
      for key, value in self.__dict__.iteritems()]
12049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12050 
 
12051 
  def __eq__(self, other):
12052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12053 
 
12054 
  def __ne__(self, other):
12055 
    return not (self == other)
12056 
 
3064 chandransh 12057 
class getNoOfCustomersWithSuccessfulTransaction_args:
12058 
 
12059 
  thrift_spec = (
12060 
  )
12061 
 
12062 
  def read(self, iprot):
12063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12065 
      return
12066 
    iprot.readStructBegin()
12067 
    while True:
12068 
      (fname, ftype, fid) = iprot.readFieldBegin()
12069 
      if ftype == TType.STOP:
12070 
        break
12071 
      else:
12072 
        iprot.skip(ftype)
12073 
      iprot.readFieldEnd()
12074 
    iprot.readStructEnd()
12075 
 
12076 
  def write(self, oprot):
12077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12079 
      return
12080 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12081 
    oprot.writeFieldStop()
12082 
    oprot.writeStructEnd()
12083 
 
3431 rajveer 12084 
  def validate(self):
12085 
    return
12086 
 
12087 
 
3064 chandransh 12088 
  def __repr__(self):
12089 
    L = ['%s=%r' % (key, value)
12090 
      for key, value in self.__dict__.iteritems()]
12091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12092 
 
12093 
  def __eq__(self, other):
12094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12095 
 
12096 
  def __ne__(self, other):
12097 
    return not (self == other)
12098 
 
12099 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12100 
  """
12101 
  Attributes:
3064 chandransh 12102 
   - success
94 ashish 12103 
  """
12104 
 
12105 
  thrift_spec = (
3064 chandransh 12106 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12107 
  )
12108 
 
3064 chandransh 12109 
  def __init__(self, success=None,):
12110 
    self.success = success
94 ashish 12111 
 
12112 
  def read(self, iprot):
12113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12115 
      return
12116 
    iprot.readStructBegin()
12117 
    while True:
12118 
      (fname, ftype, fid) = iprot.readFieldBegin()
12119 
      if ftype == TType.STOP:
12120 
        break
3064 chandransh 12121 
      if fid == 0:
94 ashish 12122 
        if ftype == TType.I64:
3064 chandransh 12123 
          self.success = iprot.readI64();
94 ashish 12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      else:
12127 
        iprot.skip(ftype)
12128 
      iprot.readFieldEnd()
12129 
    iprot.readStructEnd()
12130 
 
12131 
  def write(self, oprot):
12132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12134 
      return
3064 chandransh 12135 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12136 
    if self.success is not None:
3064 chandransh 12137 
      oprot.writeFieldBegin('success', TType.I64, 0)
12138 
      oprot.writeI64(self.success)
94 ashish 12139 
      oprot.writeFieldEnd()
12140 
    oprot.writeFieldStop()
12141 
    oprot.writeStructEnd()
12142 
 
3431 rajveer 12143 
  def validate(self):
12144 
    return
12145 
 
12146 
 
94 ashish 12147 
  def __repr__(self):
12148 
    L = ['%s=%r' % (key, value)
12149 
      for key, value in self.__dict__.iteritems()]
12150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12151 
 
12152 
  def __eq__(self, other):
12153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12154 
 
12155 
  def __ne__(self, other):
12156 
    return not (self == other)
12157 
 
3064 chandransh 12158 
class getValidOrdersAmountRange_args:
12159 
 
12160 
  thrift_spec = (
12161 
  )
12162 
 
12163 
  def read(self, iprot):
12164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12166 
      return
12167 
    iprot.readStructBegin()
12168 
    while True:
12169 
      (fname, ftype, fid) = iprot.readFieldBegin()
12170 
      if ftype == TType.STOP:
12171 
        break
12172 
      else:
12173 
        iprot.skip(ftype)
12174 
      iprot.readFieldEnd()
12175 
    iprot.readStructEnd()
12176 
 
12177 
  def write(self, oprot):
12178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12180 
      return
12181 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12182 
    oprot.writeFieldStop()
12183 
    oprot.writeStructEnd()
12184 
 
3431 rajveer 12185 
  def validate(self):
12186 
    return
12187 
 
12188 
 
3064 chandransh 12189 
  def __repr__(self):
12190 
    L = ['%s=%r' % (key, value)
12191 
      for key, value in self.__dict__.iteritems()]
12192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12193 
 
12194 
  def __eq__(self, other):
12195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12196 
 
12197 
  def __ne__(self, other):
12198 
    return not (self == other)
12199 
 
12200 
class getValidOrdersAmountRange_result:
94 ashish 12201 
  """
12202 
  Attributes:
12203 
   - success
12204 
  """
12205 
 
12206 
  thrift_spec = (
3064 chandransh 12207 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12208 
  )
12209 
 
3064 chandransh 12210 
  def __init__(self, success=None,):
94 ashish 12211 
    self.success = success
12212 
 
12213 
  def read(self, iprot):
12214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12216 
      return
12217 
    iprot.readStructBegin()
12218 
    while True:
12219 
      (fname, ftype, fid) = iprot.readFieldBegin()
12220 
      if ftype == TType.STOP:
12221 
        break
12222 
      if fid == 0:
483 rajveer 12223 
        if ftype == TType.LIST:
12224 
          self.success = []
6031 rajveer 12225 
          (_etype206, _size203) = iprot.readListBegin()
12226 
          for _i207 in xrange(_size203):
12227 
            _elem208 = iprot.readDouble();
12228 
            self.success.append(_elem208)
483 rajveer 12229 
          iprot.readListEnd()
94 ashish 12230 
        else:
12231 
          iprot.skip(ftype)
12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
3064 chandransh 12241 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12242 
    if self.success is not None:
483 rajveer 12243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12244 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12245 
      for iter209 in self.success:
12246 
        oprot.writeDouble(iter209)
483 rajveer 12247 
      oprot.writeListEnd()
94 ashish 12248 
      oprot.writeFieldEnd()
12249 
    oprot.writeFieldStop()
12250 
    oprot.writeStructEnd()
12251 
 
3431 rajveer 12252 
  def validate(self):
12253 
    return
12254 
 
12255 
 
94 ashish 12256 
  def __repr__(self):
12257 
    L = ['%s=%r' % (key, value)
12258 
      for key, value in self.__dict__.iteritems()]
12259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12260 
 
12261 
  def __eq__(self, other):
12262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12263 
 
12264 
  def __ne__(self, other):
12265 
    return not (self == other)
12266 
 
3064 chandransh 12267 
class getValidOrders_args:
1528 ankur.sing 12268 
  """
12269 
  Attributes:
3064 chandransh 12270 
   - limit
5874 rajveer 12271 
   - onlyStore
1528 ankur.sing 12272 
  """
12273 
 
12274 
  thrift_spec = (
12275 
    None, # 0
3064 chandransh 12276 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12277 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12278 
  )
12279 
 
5874 rajveer 12280 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12281 
    self.limit = limit
5874 rajveer 12282 
    self.onlyStore = onlyStore
1528 ankur.sing 12283 
 
12284 
  def read(self, iprot):
12285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12287 
      return
12288 
    iprot.readStructBegin()
12289 
    while True:
12290 
      (fname, ftype, fid) = iprot.readFieldBegin()
12291 
      if ftype == TType.STOP:
12292 
        break
12293 
      if fid == 1:
12294 
        if ftype == TType.I64:
3064 chandransh 12295 
          self.limit = iprot.readI64();
1528 ankur.sing 12296 
        else:
12297 
          iprot.skip(ftype)
5874 rajveer 12298 
      elif fid == 2:
12299 
        if ftype == TType.BOOL:
12300 
          self.onlyStore = iprot.readBool();
12301 
        else:
12302 
          iprot.skip(ftype)
1528 ankur.sing 12303 
      else:
12304 
        iprot.skip(ftype)
12305 
      iprot.readFieldEnd()
12306 
    iprot.readStructEnd()
12307 
 
12308 
  def write(self, oprot):
12309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12311 
      return
3064 chandransh 12312 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12313 
    if self.limit is not None:
3064 chandransh 12314 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12315 
      oprot.writeI64(self.limit)
1528 ankur.sing 12316 
      oprot.writeFieldEnd()
5874 rajveer 12317 
    if self.onlyStore is not None:
12318 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12319 
      oprot.writeBool(self.onlyStore)
12320 
      oprot.writeFieldEnd()
1528 ankur.sing 12321 
    oprot.writeFieldStop()
12322 
    oprot.writeStructEnd()
12323 
 
3431 rajveer 12324 
  def validate(self):
12325 
    return
12326 
 
12327 
 
1528 ankur.sing 12328 
  def __repr__(self):
12329 
    L = ['%s=%r' % (key, value)
12330 
      for key, value in self.__dict__.iteritems()]
12331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12332 
 
12333 
  def __eq__(self, other):
12334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12335 
 
12336 
  def __ne__(self, other):
12337 
    return not (self == other)
12338 
 
3064 chandransh 12339 
class getValidOrders_result:
1528 ankur.sing 12340 
  """
12341 
  Attributes:
12342 
   - success
12343 
  """
12344 
 
12345 
  thrift_spec = (
3064 chandransh 12346 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12347 
  )
12348 
 
3064 chandransh 12349 
  def __init__(self, success=None,):
1528 ankur.sing 12350 
    self.success = success
12351 
 
12352 
  def read(self, iprot):
12353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12355 
      return
12356 
    iprot.readStructBegin()
12357 
    while True:
12358 
      (fname, ftype, fid) = iprot.readFieldBegin()
12359 
      if ftype == TType.STOP:
12360 
        break
12361 
      if fid == 0:
3064 chandransh 12362 
        if ftype == TType.LIST:
12363 
          self.success = []
6031 rajveer 12364 
          (_etype213, _size210) = iprot.readListBegin()
12365 
          for _i214 in xrange(_size210):
12366 
            _elem215 = Order()
12367 
            _elem215.read(iprot)
12368 
            self.success.append(_elem215)
3064 chandransh 12369 
          iprot.readListEnd()
1528 ankur.sing 12370 
        else:
12371 
          iprot.skip(ftype)
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
3064 chandransh 12381 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12382 
    if self.success is not None:
3064 chandransh 12383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12385 
      for iter216 in self.success:
12386 
        iter216.write(oprot)
3064 chandransh 12387 
      oprot.writeListEnd()
1528 ankur.sing 12388 
      oprot.writeFieldEnd()
12389 
    oprot.writeFieldStop()
12390 
    oprot.writeStructEnd()
12391 
 
3431 rajveer 12392 
  def validate(self):
12393 
    return
12394 
 
12395 
 
1528 ankur.sing 12396 
  def __repr__(self):
12397 
    L = ['%s=%r' % (key, value)
12398 
      for key, value in self.__dict__.iteritems()]
12399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12400 
 
12401 
  def __eq__(self, other):
12402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12403 
 
12404 
  def __ne__(self, other):
12405 
    return not (self == other)
12406 
 
1220 chandransh 12407 
class batchOrders_args:
12408 
  """
12409 
  Attributes:
12410 
   - warehouseId
12411 
  """
12412 
 
12413 
  thrift_spec = (
12414 
    None, # 0
12415 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12416 
  )
12417 
 
12418 
  def __init__(self, warehouseId=None,):
12419 
    self.warehouseId = warehouseId
12420 
 
12421 
  def read(self, iprot):
12422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12424 
      return
12425 
    iprot.readStructBegin()
12426 
    while True:
12427 
      (fname, ftype, fid) = iprot.readFieldBegin()
12428 
      if ftype == TType.STOP:
12429 
        break
12430 
      if fid == 1:
12431 
        if ftype == TType.I64:
12432 
          self.warehouseId = iprot.readI64();
12433 
        else:
12434 
          iprot.skip(ftype)
12435 
      else:
12436 
        iprot.skip(ftype)
12437 
      iprot.readFieldEnd()
12438 
    iprot.readStructEnd()
12439 
 
12440 
  def write(self, oprot):
12441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12443 
      return
12444 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12445 
    if self.warehouseId is not None:
1220 chandransh 12446 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12447 
      oprot.writeI64(self.warehouseId)
12448 
      oprot.writeFieldEnd()
12449 
    oprot.writeFieldStop()
12450 
    oprot.writeStructEnd()
12451 
 
3431 rajveer 12452 
  def validate(self):
12453 
    return
12454 
 
12455 
 
1220 chandransh 12456 
  def __repr__(self):
12457 
    L = ['%s=%r' % (key, value)
12458 
      for key, value in self.__dict__.iteritems()]
12459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12460 
 
12461 
  def __eq__(self, other):
12462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12463 
 
12464 
  def __ne__(self, other):
12465 
    return not (self == other)
12466 
 
12467 
class batchOrders_result:
12468 
  """
12469 
  Attributes:
12470 
   - success
12471 
   - ex
12472 
  """
12473 
 
12474 
  thrift_spec = (
12475 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12477 
  )
12478 
 
12479 
  def __init__(self, success=None, ex=None,):
12480 
    self.success = success
12481 
    self.ex = ex
12482 
 
12483 
  def read(self, iprot):
12484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12486 
      return
12487 
    iprot.readStructBegin()
12488 
    while True:
12489 
      (fname, ftype, fid) = iprot.readFieldBegin()
12490 
      if ftype == TType.STOP:
12491 
        break
12492 
      if fid == 0:
12493 
        if ftype == TType.LIST:
12494 
          self.success = []
6031 rajveer 12495 
          (_etype220, _size217) = iprot.readListBegin()
12496 
          for _i221 in xrange(_size217):
12497 
            _elem222 = Order()
12498 
            _elem222.read(iprot)
12499 
            self.success.append(_elem222)
1220 chandransh 12500 
          iprot.readListEnd()
12501 
        else:
12502 
          iprot.skip(ftype)
12503 
      elif fid == 1:
12504 
        if ftype == TType.STRUCT:
12505 
          self.ex = TransactionServiceException()
12506 
          self.ex.read(iprot)
12507 
        else:
12508 
          iprot.skip(ftype)
12509 
      else:
12510 
        iprot.skip(ftype)
12511 
      iprot.readFieldEnd()
12512 
    iprot.readStructEnd()
12513 
 
12514 
  def write(self, oprot):
12515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12517 
      return
12518 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12519 
    if self.success is not None:
1220 chandransh 12520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12522 
      for iter223 in self.success:
12523 
        iter223.write(oprot)
1220 chandransh 12524 
      oprot.writeListEnd()
12525 
      oprot.writeFieldEnd()
3431 rajveer 12526 
    if self.ex is not None:
1220 chandransh 12527 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12528 
      self.ex.write(oprot)
12529 
      oprot.writeFieldEnd()
12530 
    oprot.writeFieldStop()
12531 
    oprot.writeStructEnd()
12532 
 
3431 rajveer 12533 
  def validate(self):
12534 
    return
12535 
 
12536 
 
1220 chandransh 12537 
  def __repr__(self):
12538 
    L = ['%s=%r' % (key, value)
12539 
      for key, value in self.__dict__.iteritems()]
12540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12541 
 
12542 
  def __eq__(self, other):
12543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12544 
 
12545 
  def __ne__(self, other):
12546 
    return not (self == other)
12547 
 
1208 chandransh 12548 
class markOrderAsOutOfStock_args:
12549 
  """
12550 
  Attributes:
12551 
   - orderId
12552 
  """
12553 
 
12554 
  thrift_spec = (
12555 
    None, # 0
12556 
    (1, TType.I64, 'orderId', None, None, ), # 1
12557 
  )
12558 
 
12559 
  def __init__(self, orderId=None,):
12560 
    self.orderId = orderId
12561 
 
12562 
  def read(self, iprot):
12563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12565 
      return
12566 
    iprot.readStructBegin()
12567 
    while True:
12568 
      (fname, ftype, fid) = iprot.readFieldBegin()
12569 
      if ftype == TType.STOP:
12570 
        break
12571 
      if fid == 1:
12572 
        if ftype == TType.I64:
12573 
          self.orderId = iprot.readI64();
12574 
        else:
12575 
          iprot.skip(ftype)
12576 
      else:
12577 
        iprot.skip(ftype)
12578 
      iprot.readFieldEnd()
12579 
    iprot.readStructEnd()
12580 
 
12581 
  def write(self, oprot):
12582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12584 
      return
12585 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12586 
    if self.orderId is not None:
1208 chandransh 12587 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12588 
      oprot.writeI64(self.orderId)
12589 
      oprot.writeFieldEnd()
12590 
    oprot.writeFieldStop()
12591 
    oprot.writeStructEnd()
12592 
 
3431 rajveer 12593 
  def validate(self):
12594 
    return
12595 
 
12596 
 
1208 chandransh 12597 
  def __repr__(self):
12598 
    L = ['%s=%r' % (key, value)
12599 
      for key, value in self.__dict__.iteritems()]
12600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12601 
 
12602 
  def __eq__(self, other):
12603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12604 
 
12605 
  def __ne__(self, other):
12606 
    return not (self == other)
12607 
 
12608 
class markOrderAsOutOfStock_result:
12609 
  """
12610 
  Attributes:
12611 
   - success
12612 
   - ex
12613 
  """
12614 
 
12615 
  thrift_spec = (
12616 
    (0, TType.BOOL, 'success', None, None, ), # 0
12617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12618 
  )
12619 
 
12620 
  def __init__(self, success=None, ex=None,):
12621 
    self.success = success
12622 
    self.ex = ex
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      if fid == 0:
12634 
        if ftype == TType.BOOL:
12635 
          self.success = iprot.readBool();
12636 
        else:
12637 
          iprot.skip(ftype)
12638 
      elif fid == 1:
12639 
        if ftype == TType.STRUCT:
12640 
          self.ex = TransactionServiceException()
12641 
          self.ex.read(iprot)
12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12654 
    if self.success is not None:
1208 chandransh 12655 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12656 
      oprot.writeBool(self.success)
12657 
      oprot.writeFieldEnd()
3431 rajveer 12658 
    if self.ex is not None:
1208 chandransh 12659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12660 
      self.ex.write(oprot)
12661 
      oprot.writeFieldEnd()
12662 
    oprot.writeFieldStop()
12663 
    oprot.writeStructEnd()
12664 
 
3431 rajveer 12665 
  def validate(self):
12666 
    return
12667 
 
12668 
 
1208 chandransh 12669 
  def __repr__(self):
12670 
    L = ['%s=%r' % (key, value)
12671 
      for key, value in self.__dict__.iteritems()]
12672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12673 
 
12674 
  def __eq__(self, other):
12675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12676 
 
12677 
  def __ne__(self, other):
12678 
    return not (self == other)
12679 
 
3064 chandransh 12680 
class verifyOrder_args:
759 chandransh 12681 
  """
12682 
  Attributes:
3064 chandransh 12683 
   - orderId
759 chandransh 12684 
  """
12685 
 
12686 
  thrift_spec = (
12687 
    None, # 0
3064 chandransh 12688 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12689 
  )
12690 
 
3064 chandransh 12691 
  def __init__(self, orderId=None,):
12692 
    self.orderId = orderId
759 chandransh 12693 
 
12694 
  def read(self, iprot):
12695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12697 
      return
12698 
    iprot.readStructBegin()
12699 
    while True:
12700 
      (fname, ftype, fid) = iprot.readFieldBegin()
12701 
      if ftype == TType.STOP:
12702 
        break
12703 
      if fid == 1:
12704 
        if ftype == TType.I64:
3064 chandransh 12705 
          self.orderId = iprot.readI64();
759 chandransh 12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
3064 chandransh 12717 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12718 
    if self.orderId is not None:
3064 chandransh 12719 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12720 
      oprot.writeI64(self.orderId)
759 chandransh 12721 
      oprot.writeFieldEnd()
12722 
    oprot.writeFieldStop()
12723 
    oprot.writeStructEnd()
12724 
 
3431 rajveer 12725 
  def validate(self):
12726 
    return
12727 
 
12728 
 
759 chandransh 12729 
  def __repr__(self):
12730 
    L = ['%s=%r' % (key, value)
12731 
      for key, value in self.__dict__.iteritems()]
12732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12733 
 
12734 
  def __eq__(self, other):
12735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12736 
 
12737 
  def __ne__(self, other):
12738 
    return not (self == other)
12739 
 
3064 chandransh 12740 
class verifyOrder_result:
759 chandransh 12741 
  """
12742 
  Attributes:
12743 
   - success
12744 
   - ex
12745 
  """
12746 
 
12747 
  thrift_spec = (
12748 
    (0, TType.BOOL, 'success', None, None, ), # 0
12749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12750 
  )
12751 
 
12752 
  def __init__(self, success=None, ex=None,):
12753 
    self.success = success
12754 
    self.ex = ex
12755 
 
12756 
  def read(self, iprot):
12757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12759 
      return
12760 
    iprot.readStructBegin()
12761 
    while True:
12762 
      (fname, ftype, fid) = iprot.readFieldBegin()
12763 
      if ftype == TType.STOP:
12764 
        break
12765 
      if fid == 0:
12766 
        if ftype == TType.BOOL:
12767 
          self.success = iprot.readBool();
12768 
        else:
12769 
          iprot.skip(ftype)
12770 
      elif fid == 1:
12771 
        if ftype == TType.STRUCT:
12772 
          self.ex = TransactionServiceException()
12773 
          self.ex.read(iprot)
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      else:
12777 
        iprot.skip(ftype)
12778 
      iprot.readFieldEnd()
12779 
    iprot.readStructEnd()
12780 
 
12781 
  def write(self, oprot):
12782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12784 
      return
3064 chandransh 12785 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12786 
    if self.success is not None:
759 chandransh 12787 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12788 
      oprot.writeBool(self.success)
12789 
      oprot.writeFieldEnd()
3431 rajveer 12790 
    if self.ex is not None:
759 chandransh 12791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12792 
      self.ex.write(oprot)
12793 
      oprot.writeFieldEnd()
12794 
    oprot.writeFieldStop()
12795 
    oprot.writeStructEnd()
12796 
 
3431 rajveer 12797 
  def validate(self):
12798 
    return
12799 
 
12800 
 
759 chandransh 12801 
  def __repr__(self):
12802 
    L = ['%s=%r' % (key, value)
12803 
      for key, value in self.__dict__.iteritems()]
12804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12805 
 
12806 
  def __eq__(self, other):
12807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12808 
 
12809 
  def __ne__(self, other):
12810 
    return not (self == other)
12811 
 
3064 chandransh 12812 
class acceptOrder_args:
1113 chandransh 12813 
  """
12814 
  Attributes:
3064 chandransh 12815 
   - orderId
1113 chandransh 12816 
  """
12817 
 
12818 
  thrift_spec = (
12819 
    None, # 0
3064 chandransh 12820 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12821 
  )
12822 
 
3064 chandransh 12823 
  def __init__(self, orderId=None,):
12824 
    self.orderId = orderId
1113 chandransh 12825 
 
12826 
  def read(self, iprot):
12827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12829 
      return
12830 
    iprot.readStructBegin()
12831 
    while True:
12832 
      (fname, ftype, fid) = iprot.readFieldBegin()
12833 
      if ftype == TType.STOP:
12834 
        break
12835 
      if fid == 1:
12836 
        if ftype == TType.I64:
3064 chandransh 12837 
          self.orderId = iprot.readI64();
1113 chandransh 12838 
        else:
12839 
          iprot.skip(ftype)
12840 
      else:
12841 
        iprot.skip(ftype)
12842 
      iprot.readFieldEnd()
12843 
    iprot.readStructEnd()
12844 
 
12845 
  def write(self, oprot):
12846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12848 
      return
3064 chandransh 12849 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12850 
    if self.orderId is not None:
3064 chandransh 12851 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12852 
      oprot.writeI64(self.orderId)
1113 chandransh 12853 
      oprot.writeFieldEnd()
12854 
    oprot.writeFieldStop()
12855 
    oprot.writeStructEnd()
12856 
 
3431 rajveer 12857 
  def validate(self):
12858 
    return
12859 
 
12860 
 
1113 chandransh 12861 
  def __repr__(self):
12862 
    L = ['%s=%r' % (key, value)
12863 
      for key, value in self.__dict__.iteritems()]
12864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12865 
 
12866 
  def __eq__(self, other):
12867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12868 
 
12869 
  def __ne__(self, other):
12870 
    return not (self == other)
12871 
 
3064 chandransh 12872 
class acceptOrder_result:
1113 chandransh 12873 
  """
12874 
  Attributes:
12875 
   - success
12876 
   - ex
12877 
  """
12878 
 
12879 
  thrift_spec = (
3064 chandransh 12880 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12882 
  )
12883 
 
12884 
  def __init__(self, success=None, ex=None,):
12885 
    self.success = success
12886 
    self.ex = ex
12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 0:
3064 chandransh 12898 
        if ftype == TType.BOOL:
12899 
          self.success = iprot.readBool();
1113 chandransh 12900 
        else:
12901 
          iprot.skip(ftype)
12902 
      elif fid == 1:
12903 
        if ftype == TType.STRUCT:
12904 
          self.ex = TransactionServiceException()
12905 
          self.ex.read(iprot)
12906 
        else:
12907 
          iprot.skip(ftype)
12908 
      else:
12909 
        iprot.skip(ftype)
12910 
      iprot.readFieldEnd()
12911 
    iprot.readStructEnd()
12912 
 
12913 
  def write(self, oprot):
12914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12916 
      return
3064 chandransh 12917 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12918 
    if self.success is not None:
3064 chandransh 12919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12920 
      oprot.writeBool(self.success)
1113 chandransh 12921 
      oprot.writeFieldEnd()
3431 rajveer 12922 
    if self.ex is not None:
1113 chandransh 12923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12924 
      self.ex.write(oprot)
12925 
      oprot.writeFieldEnd()
12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
3431 rajveer 12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
1113 chandransh 12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
3064 chandransh 12944 
class addBillingDetails_args:
1135 chandransh 12945 
  """
12946 
  Attributes:
3064 chandransh 12947 
   - orderId
12948 
   - invoice_number
4658 mandeep.dh 12949 
   - serialNumber
4283 anupam.sin 12950 
   - itemNumber
3064 chandransh 12951 
   - billed_by
4264 rajveer 12952 
   - jacketNumber
4283 anupam.sin 12953 
   - billingType
5110 mandeep.dh 12954 
   - fulfilmentWarehouseId
4763 rajveer 12955 
   - authorize
1135 chandransh 12956 
  """
12957 
 
12958 
  thrift_spec = (
12959 
    None, # 0
3064 chandransh 12960 
    (1, TType.I64, 'orderId', None, None, ), # 1
12961 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12962 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12963 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12964 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12965 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12966 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12967 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12968 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12969 
  )
12970 
 
5110 mandeep.dh 12971 
  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 12972 
    self.orderId = orderId
12973 
    self.invoice_number = invoice_number
4658 mandeep.dh 12974 
    self.serialNumber = serialNumber
4283 anupam.sin 12975 
    self.itemNumber = itemNumber
3064 chandransh 12976 
    self.billed_by = billed_by
4264 rajveer 12977 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12978 
    self.billingType = billingType
5110 mandeep.dh 12979 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12980 
    self.authorize = authorize
1135 chandransh 12981 
 
12982 
  def read(self, iprot):
12983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12985 
      return
12986 
    iprot.readStructBegin()
12987 
    while True:
12988 
      (fname, ftype, fid) = iprot.readFieldBegin()
12989 
      if ftype == TType.STOP:
12990 
        break
12991 
      if fid == 1:
12992 
        if ftype == TType.I64:
3064 chandransh 12993 
          self.orderId = iprot.readI64();
1135 chandransh 12994 
        else:
12995 
          iprot.skip(ftype)
12996 
      elif fid == 2:
3064 chandransh 12997 
        if ftype == TType.STRING:
12998 
          self.invoice_number = iprot.readString();
1135 chandransh 12999 
        else:
13000 
          iprot.skip(ftype)
3064 chandransh 13001 
      elif fid == 3:
5411 rajveer 13002 
        if ftype == TType.LIST:
13003 
          self.serialNumber = []
6031 rajveer 13004 
          (_etype227, _size224) = iprot.readListBegin()
13005 
          for _i228 in xrange(_size224):
13006 
            _elem229 = iprot.readString();
13007 
            self.serialNumber.append(_elem229)
5411 rajveer 13008 
          iprot.readListEnd()
3064 chandransh 13009 
        else:
13010 
          iprot.skip(ftype)
13011 
      elif fid == 4:
5411 rajveer 13012 
        if ftype == TType.LIST:
13013 
          self.itemNumber = []
6031 rajveer 13014 
          (_etype233, _size230) = iprot.readListBegin()
13015 
          for _i234 in xrange(_size230):
13016 
            _elem235 = iprot.readString();
13017 
            self.itemNumber.append(_elem235)
5411 rajveer 13018 
          iprot.readListEnd()
3064 chandransh 13019 
        else:
13020 
          iprot.skip(ftype)
13021 
      elif fid == 5:
13022 
        if ftype == TType.STRING:
4283 anupam.sin 13023 
          self.billed_by = iprot.readString();
3064 chandransh 13024 
        else:
13025 
          iprot.skip(ftype)
13026 
      elif fid == 6:
13027 
        if ftype == TType.I64:
4283 anupam.sin 13028 
          self.jacketNumber = iprot.readI64();
13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      elif fid == 7:
13032 
        if ftype == TType.I64:
3064 chandransh 13033 
          self.billingType = iprot.readI64();
13034 
        else:
13035 
          iprot.skip(ftype)
4283 anupam.sin 13036 
      elif fid == 8:
13037 
        if ftype == TType.I64:
5110 mandeep.dh 13038 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13039 
        else:
13040 
          iprot.skip(ftype)
4763 rajveer 13041 
      elif fid == 9:
13042 
        if ftype == TType.BOOL:
13043 
          self.authorize = iprot.readBool();
13044 
        else:
13045 
          iprot.skip(ftype)
1246 chandransh 13046 
      else:
13047 
        iprot.skip(ftype)
13048 
      iprot.readFieldEnd()
13049 
    iprot.readStructEnd()
13050 
 
13051 
  def write(self, oprot):
13052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13054 
      return
4283 anupam.sin 13055 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13056 
    if self.orderId is not None:
3064 chandransh 13057 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13058 
      oprot.writeI64(self.orderId)
1246 chandransh 13059 
      oprot.writeFieldEnd()
4283 anupam.sin 13060 
    if self.invoice_number is not None:
13061 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13062 
      oprot.writeString(self.invoice_number)
1246 chandransh 13063 
      oprot.writeFieldEnd()
4658 mandeep.dh 13064 
    if self.serialNumber is not None:
5411 rajveer 13065 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13066 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 13067 
      for iter236 in self.serialNumber:
13068 
        oprot.writeString(iter236)
5411 rajveer 13069 
      oprot.writeListEnd()
3064 chandransh 13070 
      oprot.writeFieldEnd()
3431 rajveer 13071 
    if self.itemNumber is not None:
5411 rajveer 13072 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13073 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 13074 
      for iter237 in self.itemNumber:
13075 
        oprot.writeString(iter237)
5411 rajveer 13076 
      oprot.writeListEnd()
3064 chandransh 13077 
      oprot.writeFieldEnd()
4283 anupam.sin 13078 
    if self.billed_by is not None:
13079 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13080 
      oprot.writeString(self.billed_by)
3064 chandransh 13081 
      oprot.writeFieldEnd()
4283 anupam.sin 13082 
    if self.jacketNumber is not None:
13083 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13084 
      oprot.writeI64(self.jacketNumber)
13085 
      oprot.writeFieldEnd()
3431 rajveer 13086 
    if self.billingType is not None:
4283 anupam.sin 13087 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13088 
      oprot.writeI64(self.billingType)
13089 
      oprot.writeFieldEnd()
5110 mandeep.dh 13090 
    if self.fulfilmentWarehouseId is not None:
13091 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13092 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13093 
      oprot.writeFieldEnd()
4763 rajveer 13094 
    if self.authorize is not None:
13095 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13096 
      oprot.writeBool(self.authorize)
13097 
      oprot.writeFieldEnd()
1246 chandransh 13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
3431 rajveer 13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
1246 chandransh 13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
4283 anupam.sin 13116 
class addBillingDetails_result:
1246 chandransh 13117 
  """
13118 
  Attributes:
3064 chandransh 13119 
   - success
1246 chandransh 13120 
   - ex
13121 
  """
13122 
 
13123 
  thrift_spec = (
3064 chandransh 13124 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13126 
  )
13127 
 
3064 chandransh 13128 
  def __init__(self, success=None, ex=None,):
13129 
    self.success = success
1246 chandransh 13130 
    self.ex = ex
13131 
 
13132 
  def read(self, iprot):
13133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13135 
      return
13136 
    iprot.readStructBegin()
13137 
    while True:
13138 
      (fname, ftype, fid) = iprot.readFieldBegin()
13139 
      if ftype == TType.STOP:
13140 
        break
3064 chandransh 13141 
      if fid == 0:
13142 
        if ftype == TType.BOOL:
13143 
          self.success = iprot.readBool();
13144 
        else:
13145 
          iprot.skip(ftype)
13146 
      elif fid == 1:
1246 chandransh 13147 
        if ftype == TType.STRUCT:
13148 
          self.ex = TransactionServiceException()
13149 
          self.ex.read(iprot)
13150 
        else:
13151 
          iprot.skip(ftype)
13152 
      else:
13153 
        iprot.skip(ftype)
13154 
      iprot.readFieldEnd()
13155 
    iprot.readStructEnd()
13156 
 
13157 
  def write(self, oprot):
13158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13160 
      return
4283 anupam.sin 13161 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13162 
    if self.success is not None:
3064 chandransh 13163 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13164 
      oprot.writeBool(self.success)
13165 
      oprot.writeFieldEnd()
3431 rajveer 13166 
    if self.ex is not None:
1246 chandransh 13167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13168 
      self.ex.write(oprot)
13169 
      oprot.writeFieldEnd()
13170 
    oprot.writeFieldStop()
13171 
    oprot.writeStructEnd()
13172 
 
3431 rajveer 13173 
  def validate(self):
13174 
    return
13175 
 
13176 
 
1246 chandransh 13177 
  def __repr__(self):
13178 
    L = ['%s=%r' % (key, value)
13179 
      for key, value in self.__dict__.iteritems()]
13180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13181 
 
13182 
  def __eq__(self, other):
13183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13184 
 
13185 
  def __ne__(self, other):
13186 
    return not (self == other)
13187 
 
4579 rajveer 13188 
class addInvoiceNumber_args:
13189 
  """
13190 
  Attributes:
13191 
   - orderId
13192 
   - invoiceNumber
4763 rajveer 13193 
   - color
4579 rajveer 13194 
  """
13195 
 
13196 
  thrift_spec = (
13197 
    None, # 0
13198 
    (1, TType.I64, 'orderId', None, None, ), # 1
13199 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13200 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13201 
  )
13202 
 
4763 rajveer 13203 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13204 
    self.orderId = orderId
13205 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13206 
    self.color = color
4579 rajveer 13207 
 
13208 
  def read(self, iprot):
13209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13211 
      return
13212 
    iprot.readStructBegin()
13213 
    while True:
13214 
      (fname, ftype, fid) = iprot.readFieldBegin()
13215 
      if ftype == TType.STOP:
13216 
        break
13217 
      if fid == 1:
13218 
        if ftype == TType.I64:
13219 
          self.orderId = iprot.readI64();
13220 
        else:
13221 
          iprot.skip(ftype)
13222 
      elif fid == 2:
13223 
        if ftype == TType.STRING:
13224 
          self.invoiceNumber = iprot.readString();
13225 
        else:
13226 
          iprot.skip(ftype)
4763 rajveer 13227 
      elif fid == 3:
13228 
        if ftype == TType.STRING:
13229 
          self.color = iprot.readString();
13230 
        else:
13231 
          iprot.skip(ftype)
4579 rajveer 13232 
      else:
13233 
        iprot.skip(ftype)
13234 
      iprot.readFieldEnd()
13235 
    iprot.readStructEnd()
13236 
 
13237 
  def write(self, oprot):
13238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13240 
      return
13241 
    oprot.writeStructBegin('addInvoiceNumber_args')
13242 
    if self.orderId is not None:
13243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13244 
      oprot.writeI64(self.orderId)
13245 
      oprot.writeFieldEnd()
13246 
    if self.invoiceNumber is not None:
13247 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13248 
      oprot.writeString(self.invoiceNumber)
13249 
      oprot.writeFieldEnd()
4763 rajveer 13250 
    if self.color is not None:
13251 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13252 
      oprot.writeString(self.color)
13253 
      oprot.writeFieldEnd()
4579 rajveer 13254 
    oprot.writeFieldStop()
13255 
    oprot.writeStructEnd()
13256 
 
13257 
  def validate(self):
13258 
    return
13259 
 
13260 
 
13261 
  def __repr__(self):
13262 
    L = ['%s=%r' % (key, value)
13263 
      for key, value in self.__dict__.iteritems()]
13264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13265 
 
13266 
  def __eq__(self, other):
13267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13268 
 
13269 
  def __ne__(self, other):
13270 
    return not (self == other)
13271 
 
13272 
class addInvoiceNumber_result:
13273 
  """
13274 
  Attributes:
13275 
   - ex
13276 
  """
13277 
 
13278 
  thrift_spec = (
13279 
    None, # 0
13280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13281 
  )
13282 
 
13283 
  def __init__(self, ex=None,):
13284 
    self.ex = ex
13285 
 
13286 
  def read(self, iprot):
13287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13289 
      return
13290 
    iprot.readStructBegin()
13291 
    while True:
13292 
      (fname, ftype, fid) = iprot.readFieldBegin()
13293 
      if ftype == TType.STOP:
13294 
        break
13295 
      if fid == 1:
13296 
        if ftype == TType.STRUCT:
13297 
          self.ex = TransactionServiceException()
13298 
          self.ex.read(iprot)
13299 
        else:
13300 
          iprot.skip(ftype)
13301 
      else:
13302 
        iprot.skip(ftype)
13303 
      iprot.readFieldEnd()
13304 
    iprot.readStructEnd()
13305 
 
13306 
  def write(self, oprot):
13307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13309 
      return
13310 
    oprot.writeStructBegin('addInvoiceNumber_result')
13311 
    if self.ex is not None:
13312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13313 
      self.ex.write(oprot)
13314 
      oprot.writeFieldEnd()
13315 
    oprot.writeFieldStop()
13316 
    oprot.writeStructEnd()
13317 
 
13318 
  def validate(self):
13319 
    return
13320 
 
13321 
 
13322 
  def __repr__(self):
13323 
    L = ['%s=%r' % (key, value)
13324 
      for key, value in self.__dict__.iteritems()]
13325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13326 
 
13327 
  def __eq__(self, other):
13328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13329 
 
13330 
  def __ne__(self, other):
13331 
    return not (self == other)
13332 
 
4910 phani.kuma 13333 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13334 
  """
13335 
  Attributes:
3064 chandransh 13336 
   - warehouseId
1408 ankur.sing 13337 
   - providerId
3064 chandransh 13338 
   - cod
4910 phani.kuma 13339 
   - orderIds
1408 ankur.sing 13340 
  """
13341 
 
13342 
  thrift_spec = (
13343 
    None, # 0
3064 chandransh 13344 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13345 
    (2, TType.I64, 'providerId', None, None, ), # 2
13346 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13347 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13348 
  )
13349 
 
4910 phani.kuma 13350 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13351 
    self.warehouseId = warehouseId
1408 ankur.sing 13352 
    self.providerId = providerId
3064 chandransh 13353 
    self.cod = cod
4910 phani.kuma 13354 
    self.orderIds = orderIds
1408 ankur.sing 13355 
 
13356 
  def read(self, iprot):
13357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13359 
      return
13360 
    iprot.readStructBegin()
13361 
    while True:
13362 
      (fname, ftype, fid) = iprot.readFieldBegin()
13363 
      if ftype == TType.STOP:
13364 
        break
13365 
      if fid == 1:
13366 
        if ftype == TType.I64:
3064 chandransh 13367 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13368 
        else:
13369 
          iprot.skip(ftype)
13370 
      elif fid == 2:
13371 
        if ftype == TType.I64:
3064 chandransh 13372 
          self.providerId = iprot.readI64();
1408 ankur.sing 13373 
        else:
13374 
          iprot.skip(ftype)
3064 chandransh 13375 
      elif fid == 3:
13376 
        if ftype == TType.BOOL:
13377 
          self.cod = iprot.readBool();
13378 
        else:
13379 
          iprot.skip(ftype)
4910 phani.kuma 13380 
      elif fid == 4:
13381 
        if ftype == TType.LIST:
13382 
          self.orderIds = []
6031 rajveer 13383 
          (_etype241, _size238) = iprot.readListBegin()
13384 
          for _i242 in xrange(_size238):
13385 
            _elem243 = iprot.readI64();
13386 
            self.orderIds.append(_elem243)
4910 phani.kuma 13387 
          iprot.readListEnd()
13388 
        else:
13389 
          iprot.skip(ftype)
1408 ankur.sing 13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
4910 phani.kuma 13399 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13400 
    if self.warehouseId is not None:
3064 chandransh 13401 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13402 
      oprot.writeI64(self.warehouseId)
13403 
      oprot.writeFieldEnd()
3431 rajveer 13404 
    if self.providerId is not None:
3064 chandransh 13405 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13406 
      oprot.writeI64(self.providerId)
13407 
      oprot.writeFieldEnd()
3431 rajveer 13408 
    if self.cod is not None:
3064 chandransh 13409 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13410 
      oprot.writeBool(self.cod)
1408 ankur.sing 13411 
      oprot.writeFieldEnd()
4910 phani.kuma 13412 
    if self.orderIds is not None:
13413 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13414 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13415 
      for iter244 in self.orderIds:
13416 
        oprot.writeI64(iter244)
4910 phani.kuma 13417 
      oprot.writeListEnd()
13418 
      oprot.writeFieldEnd()
1408 ankur.sing 13419 
    oprot.writeFieldStop()
13420 
    oprot.writeStructEnd()
13421 
 
3431 rajveer 13422 
  def validate(self):
13423 
    return
13424 
 
13425 
 
1408 ankur.sing 13426 
  def __repr__(self):
13427 
    L = ['%s=%r' % (key, value)
13428 
      for key, value in self.__dict__.iteritems()]
13429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13430 
 
13431 
  def __eq__(self, other):
13432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13433 
 
13434 
  def __ne__(self, other):
13435 
    return not (self == other)
13436 
 
4910 phani.kuma 13437 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13438 
  """
13439 
  Attributes:
13440 
   - success
3064 chandransh 13441 
   - ex
1408 ankur.sing 13442 
  """
13443 
 
13444 
  thrift_spec = (
3064 chandransh 13445 
    (0, TType.BOOL, 'success', None, None, ), # 0
13446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13447 
  )
13448 
 
3064 chandransh 13449 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13450 
    self.success = success
3064 chandransh 13451 
    self.ex = ex
1408 ankur.sing 13452 
 
13453 
  def read(self, iprot):
13454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13456 
      return
13457 
    iprot.readStructBegin()
13458 
    while True:
13459 
      (fname, ftype, fid) = iprot.readFieldBegin()
13460 
      if ftype == TType.STOP:
13461 
        break
13462 
      if fid == 0:
3064 chandransh 13463 
        if ftype == TType.BOOL:
13464 
          self.success = iprot.readBool();
1408 ankur.sing 13465 
        else:
13466 
          iprot.skip(ftype)
3064 chandransh 13467 
      elif fid == 1:
13468 
        if ftype == TType.STRUCT:
13469 
          self.ex = TransactionServiceException()
13470 
          self.ex.read(iprot)
13471 
        else:
13472 
          iprot.skip(ftype)
1408 ankur.sing 13473 
      else:
13474 
        iprot.skip(ftype)
13475 
      iprot.readFieldEnd()
13476 
    iprot.readStructEnd()
13477 
 
13478 
  def write(self, oprot):
13479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13481 
      return
4910 phani.kuma 13482 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13483 
    if self.success is not None:
3064 chandransh 13484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13485 
      oprot.writeBool(self.success)
1408 ankur.sing 13486 
      oprot.writeFieldEnd()
3431 rajveer 13487 
    if self.ex is not None:
3064 chandransh 13488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13489 
      self.ex.write(oprot)
13490 
      oprot.writeFieldEnd()
1408 ankur.sing 13491 
    oprot.writeFieldStop()
13492 
    oprot.writeStructEnd()
13493 
 
3431 rajveer 13494 
  def validate(self):
13495 
    return
13496 
 
13497 
 
1408 ankur.sing 13498 
  def __repr__(self):
13499 
    L = ['%s=%r' % (key, value)
13500 
      for key, value in self.__dict__.iteritems()]
13501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13502 
 
13503 
  def __eq__(self, other):
13504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13505 
 
13506 
  def __ne__(self, other):
13507 
    return not (self == other)
13508 
 
5676 rajveer 13509 
class markOrdersAsReturnedFromStore_args:
13510 
  """
13511 
  Attributes:
13512 
   - providerId
13513 
   - orderIds
5713 rajveer 13514 
   - awbs
5676 rajveer 13515 
  """
13516 
 
13517 
  thrift_spec = (
13518 
    None, # 0
13519 
    (1, TType.I64, 'providerId', None, None, ), # 1
13520 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13521 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13522 
  )
13523 
 
5713 rajveer 13524 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13525 
    self.providerId = providerId
13526 
    self.orderIds = orderIds
5713 rajveer 13527 
    self.awbs = awbs
5676 rajveer 13528 
 
13529 
  def read(self, iprot):
13530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13532 
      return
13533 
    iprot.readStructBegin()
13534 
    while True:
13535 
      (fname, ftype, fid) = iprot.readFieldBegin()
13536 
      if ftype == TType.STOP:
13537 
        break
13538 
      if fid == 1:
13539 
        if ftype == TType.I64:
13540 
          self.providerId = iprot.readI64();
13541 
        else:
13542 
          iprot.skip(ftype)
13543 
      elif fid == 2:
13544 
        if ftype == TType.LIST:
13545 
          self.orderIds = []
6031 rajveer 13546 
          (_etype248, _size245) = iprot.readListBegin()
13547 
          for _i249 in xrange(_size245):
13548 
            _elem250 = iprot.readI64();
13549 
            self.orderIds.append(_elem250)
5676 rajveer 13550 
          iprot.readListEnd()
13551 
        else:
13552 
          iprot.skip(ftype)
5713 rajveer 13553 
      elif fid == 3:
13554 
        if ftype == TType.LIST:
13555 
          self.awbs = []
6031 rajveer 13556 
          (_etype254, _size251) = iprot.readListBegin()
13557 
          for _i255 in xrange(_size251):
13558 
            _elem256 = iprot.readString();
13559 
            self.awbs.append(_elem256)
5713 rajveer 13560 
          iprot.readListEnd()
13561 
        else:
13562 
          iprot.skip(ftype)
5676 rajveer 13563 
      else:
13564 
        iprot.skip(ftype)
13565 
      iprot.readFieldEnd()
13566 
    iprot.readStructEnd()
13567 
 
13568 
  def write(self, oprot):
13569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13571 
      return
13572 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13573 
    if self.providerId is not None:
13574 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13575 
      oprot.writeI64(self.providerId)
13576 
      oprot.writeFieldEnd()
13577 
    if self.orderIds is not None:
13578 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13579 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13580 
      for iter257 in self.orderIds:
13581 
        oprot.writeI64(iter257)
5676 rajveer 13582 
      oprot.writeListEnd()
13583 
      oprot.writeFieldEnd()
5713 rajveer 13584 
    if self.awbs is not None:
13585 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13586 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13587 
      for iter258 in self.awbs:
13588 
        oprot.writeString(iter258)
5713 rajveer 13589 
      oprot.writeListEnd()
13590 
      oprot.writeFieldEnd()
5676 rajveer 13591 
    oprot.writeFieldStop()
13592 
    oprot.writeStructEnd()
13593 
 
13594 
  def validate(self):
13595 
    return
13596 
 
13597 
 
13598 
  def __repr__(self):
13599 
    L = ['%s=%r' % (key, value)
13600 
      for key, value in self.__dict__.iteritems()]
13601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13602 
 
13603 
  def __eq__(self, other):
13604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13605 
 
13606 
  def __ne__(self, other):
13607 
    return not (self == other)
13608 
 
13609 
class markOrdersAsReturnedFromStore_result:
13610 
  """
13611 
  Attributes:
13612 
   - success
13613 
   - ex
13614 
  """
13615 
 
13616 
  thrift_spec = (
13617 
    (0, TType.BOOL, 'success', None, None, ), # 0
13618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13619 
  )
13620 
 
13621 
  def __init__(self, success=None, ex=None,):
13622 
    self.success = success
13623 
    self.ex = ex
13624 
 
13625 
  def read(self, iprot):
13626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13628 
      return
13629 
    iprot.readStructBegin()
13630 
    while True:
13631 
      (fname, ftype, fid) = iprot.readFieldBegin()
13632 
      if ftype == TType.STOP:
13633 
        break
13634 
      if fid == 0:
13635 
        if ftype == TType.BOOL:
13636 
          self.success = iprot.readBool();
13637 
        else:
13638 
          iprot.skip(ftype)
13639 
      elif fid == 1:
13640 
        if ftype == TType.STRUCT:
13641 
          self.ex = TransactionServiceException()
13642 
          self.ex.read(iprot)
13643 
        else:
13644 
          iprot.skip(ftype)
13645 
      else:
13646 
        iprot.skip(ftype)
13647 
      iprot.readFieldEnd()
13648 
    iprot.readStructEnd()
13649 
 
13650 
  def write(self, oprot):
13651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13653 
      return
13654 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13655 
    if self.success is not None:
13656 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13657 
      oprot.writeBool(self.success)
13658 
      oprot.writeFieldEnd()
13659 
    if self.ex is not None:
13660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13661 
      self.ex.write(oprot)
13662 
      oprot.writeFieldEnd()
13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
4910 phani.kuma 13681 
class markOrdersAsPickedUp_args:
4410 rajveer 13682 
  """
13683 
  Attributes:
13684 
   - providerId
4910 phani.kuma 13685 
   - pickupDetails
4410 rajveer 13686 
  """
13687 
 
13688 
  thrift_spec = (
13689 
    None, # 0
4910 phani.kuma 13690 
    (1, TType.I64, 'providerId', None, None, ), # 1
13691 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13692 
  )
13693 
 
4910 phani.kuma 13694 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13695 
    self.providerId = providerId
4910 phani.kuma 13696 
    self.pickupDetails = pickupDetails
4410 rajveer 13697 
 
13698 
  def read(self, iprot):
13699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13701 
      return
13702 
    iprot.readStructBegin()
13703 
    while True:
13704 
      (fname, ftype, fid) = iprot.readFieldBegin()
13705 
      if ftype == TType.STOP:
13706 
        break
13707 
      if fid == 1:
13708 
        if ftype == TType.I64:
4910 phani.kuma 13709 
          self.providerId = iprot.readI64();
4410 rajveer 13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      elif fid == 2:
4910 phani.kuma 13713 
        if ftype == TType.MAP:
13714 
          self.pickupDetails = {}
6031 rajveer 13715 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13716 
          for _i263 in xrange(_size259):
13717 
            _key264 = iprot.readString();
13718 
            _val265 = iprot.readString();
13719 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13720 
          iprot.readMapEnd()
4410 rajveer 13721 
        else:
13722 
          iprot.skip(ftype)
13723 
      else:
13724 
        iprot.skip(ftype)
13725 
      iprot.readFieldEnd()
13726 
    iprot.readStructEnd()
13727 
 
13728 
  def write(self, oprot):
13729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13731 
      return
4910 phani.kuma 13732 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13733 
    if self.providerId is not None:
4910 phani.kuma 13734 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13735 
      oprot.writeI64(self.providerId)
13736 
      oprot.writeFieldEnd()
4910 phani.kuma 13737 
    if self.pickupDetails is not None:
13738 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13739 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 13740 
      for kiter266,viter267 in self.pickupDetails.items():
13741 
        oprot.writeString(kiter266)
13742 
        oprot.writeString(viter267)
4910 phani.kuma 13743 
      oprot.writeMapEnd()
4410 rajveer 13744 
      oprot.writeFieldEnd()
13745 
    oprot.writeFieldStop()
13746 
    oprot.writeStructEnd()
13747 
 
13748 
  def validate(self):
13749 
    return
13750 
 
13751 
 
13752 
  def __repr__(self):
13753 
    L = ['%s=%r' % (key, value)
13754 
      for key, value in self.__dict__.iteritems()]
13755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13756 
 
13757 
  def __eq__(self, other):
13758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13759 
 
13760 
  def __ne__(self, other):
13761 
    return not (self == other)
13762 
 
4910 phani.kuma 13763 
class markOrdersAsPickedUp_result:
4410 rajveer 13764 
  """
13765 
  Attributes:
13766 
   - ex
13767 
  """
13768 
 
13769 
  thrift_spec = (
4910 phani.kuma 13770 
    None, # 0
4410 rajveer 13771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13772 
  )
13773 
 
4910 phani.kuma 13774 
  def __init__(self, ex=None,):
4410 rajveer 13775 
    self.ex = ex
13776 
 
13777 
  def read(self, iprot):
13778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13780 
      return
13781 
    iprot.readStructBegin()
13782 
    while True:
13783 
      (fname, ftype, fid) = iprot.readFieldBegin()
13784 
      if ftype == TType.STOP:
13785 
        break
4910 phani.kuma 13786 
      if fid == 1:
4410 rajveer 13787 
        if ftype == TType.STRUCT:
13788 
          self.ex = TransactionServiceException()
13789 
          self.ex.read(iprot)
13790 
        else:
13791 
          iprot.skip(ftype)
13792 
      else:
13793 
        iprot.skip(ftype)
13794 
      iprot.readFieldEnd()
13795 
    iprot.readStructEnd()
13796 
 
13797 
  def write(self, oprot):
13798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13800 
      return
4910 phani.kuma 13801 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13802 
    if self.ex is not None:
13803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13804 
      self.ex.write(oprot)
13805 
      oprot.writeFieldEnd()
13806 
    oprot.writeFieldStop()
13807 
    oprot.writeStructEnd()
13808 
 
13809 
  def validate(self):
13810 
    return
13811 
 
13812 
 
13813 
  def __repr__(self):
13814 
    L = ['%s=%r' % (key, value)
13815 
      for key, value in self.__dict__.iteritems()]
13816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13817 
 
13818 
  def __eq__(self, other):
13819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13820 
 
13821 
  def __ne__(self, other):
13822 
    return not (self == other)
13823 
 
4910 phani.kuma 13824 
class getOrdersNotPickedUp_args:
304 ashish 13825 
  """
13826 
  Attributes:
3064 chandransh 13827 
   - providerId
304 ashish 13828 
  """
94 ashish 13829 
 
304 ashish 13830 
  thrift_spec = (
13831 
    None, # 0
3064 chandransh 13832 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13833 
  )
13834 
 
4910 phani.kuma 13835 
  def __init__(self, providerId=None,):
3064 chandransh 13836 
    self.providerId = providerId
304 ashish 13837 
 
13838 
  def read(self, iprot):
13839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13841 
      return
13842 
    iprot.readStructBegin()
13843 
    while True:
13844 
      (fname, ftype, fid) = iprot.readFieldBegin()
13845 
      if ftype == TType.STOP:
13846 
        break
13847 
      if fid == 1:
13848 
        if ftype == TType.I64:
3064 chandransh 13849 
          self.providerId = iprot.readI64();
304 ashish 13850 
        else:
13851 
          iprot.skip(ftype)
13852 
      else:
13853 
        iprot.skip(ftype)
13854 
      iprot.readFieldEnd()
13855 
    iprot.readStructEnd()
13856 
 
13857 
  def write(self, oprot):
13858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13860 
      return
4910 phani.kuma 13861 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13862 
    if self.providerId is not None:
3064 chandransh 13863 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13864 
      oprot.writeI64(self.providerId)
304 ashish 13865 
      oprot.writeFieldEnd()
13866 
    oprot.writeFieldStop()
13867 
    oprot.writeStructEnd()
13868 
 
3431 rajveer 13869 
  def validate(self):
13870 
    return
13871 
 
13872 
 
304 ashish 13873 
  def __repr__(self):
13874 
    L = ['%s=%r' % (key, value)
13875 
      for key, value in self.__dict__.iteritems()]
13876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13877 
 
13878 
  def __eq__(self, other):
13879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13880 
 
13881 
  def __ne__(self, other):
13882 
    return not (self == other)
13883 
 
4910 phani.kuma 13884 
class getOrdersNotPickedUp_result:
304 ashish 13885 
  """
13886 
  Attributes:
13887 
   - success
13888 
  """
13889 
 
13890 
  thrift_spec = (
3064 chandransh 13891 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13892 
  )
13893 
 
4910 phani.kuma 13894 
  def __init__(self, success=None,):
304 ashish 13895 
    self.success = success
13896 
 
13897 
  def read(self, iprot):
13898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13900 
      return
13901 
    iprot.readStructBegin()
13902 
    while True:
13903 
      (fname, ftype, fid) = iprot.readFieldBegin()
13904 
      if ftype == TType.STOP:
13905 
        break
13906 
      if fid == 0:
13907 
        if ftype == TType.LIST:
13908 
          self.success = []
6031 rajveer 13909 
          (_etype271, _size268) = iprot.readListBegin()
13910 
          for _i272 in xrange(_size268):
13911 
            _elem273 = Order()
13912 
            _elem273.read(iprot)
13913 
            self.success.append(_elem273)
304 ashish 13914 
          iprot.readListEnd()
13915 
        else:
13916 
          iprot.skip(ftype)
13917 
      else:
13918 
        iprot.skip(ftype)
13919 
      iprot.readFieldEnd()
13920 
    iprot.readStructEnd()
13921 
 
13922 
  def write(self, oprot):
13923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13925 
      return
4910 phani.kuma 13926 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13927 
    if self.success is not None:
304 ashish 13928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 13930 
      for iter274 in self.success:
13931 
        iter274.write(oprot)
304 ashish 13932 
      oprot.writeListEnd()
13933 
      oprot.writeFieldEnd()
13934 
    oprot.writeFieldStop()
13935 
    oprot.writeStructEnd()
13936 
 
3431 rajveer 13937 
  def validate(self):
13938 
    return
13939 
 
13940 
 
304 ashish 13941 
  def __repr__(self):
13942 
    L = ['%s=%r' % (key, value)
13943 
      for key, value in self.__dict__.iteritems()]
13944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13945 
 
13946 
  def __eq__(self, other):
13947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13948 
 
13949 
  def __ne__(self, other):
13950 
    return not (self == other)
13951 
 
3064 chandransh 13952 
class markOrdersAsDelivered_args:
304 ashish 13953 
  """
13954 
  Attributes:
3064 chandransh 13955 
   - providerId
13956 
   - deliveredOrders
304 ashish 13957 
  """
13958 
 
13959 
  thrift_spec = (
13960 
    None, # 0
3064 chandransh 13961 
    (1, TType.I64, 'providerId', None, None, ), # 1
13962 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13963 
  )
13964 
 
3064 chandransh 13965 
  def __init__(self, providerId=None, deliveredOrders=None,):
13966 
    self.providerId = providerId
13967 
    self.deliveredOrders = deliveredOrders
304 ashish 13968 
 
13969 
  def read(self, iprot):
13970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13972 
      return
13973 
    iprot.readStructBegin()
13974 
    while True:
13975 
      (fname, ftype, fid) = iprot.readFieldBegin()
13976 
      if ftype == TType.STOP:
13977 
        break
13978 
      if fid == 1:
13979 
        if ftype == TType.I64:
3064 chandransh 13980 
          self.providerId = iprot.readI64();
304 ashish 13981 
        else:
13982 
          iprot.skip(ftype)
13983 
      elif fid == 2:
3064 chandransh 13984 
        if ftype == TType.MAP:
13985 
          self.deliveredOrders = {}
6031 rajveer 13986 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13987 
          for _i279 in xrange(_size275):
13988 
            _key280 = iprot.readString();
13989 
            _val281 = iprot.readString();
13990 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13991 
          iprot.readMapEnd()
304 ashish 13992 
        else:
13993 
          iprot.skip(ftype)
13994 
      else:
13995 
        iprot.skip(ftype)
13996 
      iprot.readFieldEnd()
13997 
    iprot.readStructEnd()
13998 
 
13999 
  def write(self, oprot):
14000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14002 
      return
3064 chandransh 14003 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14004 
    if self.providerId is not None:
3064 chandransh 14005 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14006 
      oprot.writeI64(self.providerId)
304 ashish 14007 
      oprot.writeFieldEnd()
3431 rajveer 14008 
    if self.deliveredOrders is not None:
3064 chandransh 14009 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14010 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 14011 
      for kiter282,viter283 in self.deliveredOrders.items():
14012 
        oprot.writeString(kiter282)
14013 
        oprot.writeString(viter283)
3064 chandransh 14014 
      oprot.writeMapEnd()
304 ashish 14015 
      oprot.writeFieldEnd()
14016 
    oprot.writeFieldStop()
14017 
    oprot.writeStructEnd()
14018 
 
3431 rajveer 14019 
  def validate(self):
14020 
    return
14021 
 
14022 
 
304 ashish 14023 
  def __repr__(self):
14024 
    L = ['%s=%r' % (key, value)
14025 
      for key, value in self.__dict__.iteritems()]
14026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14027 
 
14028 
  def __eq__(self, other):
14029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14030 
 
14031 
  def __ne__(self, other):
14032 
    return not (self == other)
14033 
 
3064 chandransh 14034 
class markOrdersAsDelivered_result:
14035 
  """
14036 
  Attributes:
14037 
   - ex
14038 
  """
304 ashish 14039 
 
14040 
  thrift_spec = (
3064 chandransh 14041 
    None, # 0
14042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14043 
  )
14044 
 
3064 chandransh 14045 
  def __init__(self, ex=None,):
14046 
    self.ex = ex
304 ashish 14047 
 
1596 ankur.sing 14048 
  def read(self, iprot):
14049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14051 
      return
14052 
    iprot.readStructBegin()
14053 
    while True:
14054 
      (fname, ftype, fid) = iprot.readFieldBegin()
14055 
      if ftype == TType.STOP:
14056 
        break
3064 chandransh 14057 
      if fid == 1:
14058 
        if ftype == TType.STRUCT:
14059 
          self.ex = TransactionServiceException()
14060 
          self.ex.read(iprot)
14061 
        else:
14062 
          iprot.skip(ftype)
1596 ankur.sing 14063 
      else:
14064 
        iprot.skip(ftype)
14065 
      iprot.readFieldEnd()
14066 
    iprot.readStructEnd()
14067 
 
14068 
  def write(self, oprot):
14069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14071 
      return
3064 chandransh 14072 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14073 
    if self.ex is not None:
3064 chandransh 14074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14075 
      self.ex.write(oprot)
14076 
      oprot.writeFieldEnd()
1596 ankur.sing 14077 
    oprot.writeFieldStop()
14078 
    oprot.writeStructEnd()
14079 
 
3431 rajveer 14080 
  def validate(self):
14081 
    return
14082 
 
14083 
 
1596 ankur.sing 14084 
  def __repr__(self):
14085 
    L = ['%s=%r' % (key, value)
14086 
      for key, value in self.__dict__.iteritems()]
14087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14088 
 
14089 
  def __eq__(self, other):
14090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14091 
 
14092 
  def __ne__(self, other):
14093 
    return not (self == other)
14094 
 
4910 phani.kuma 14095 
class markAsRTOrders_args:
1596 ankur.sing 14096 
  """
14097 
  Attributes:
3064 chandransh 14098 
   - providerId
14099 
   - returnedOrders
1596 ankur.sing 14100 
  """
14101 
 
14102 
  thrift_spec = (
3064 chandransh 14103 
    None, # 0
14104 
    (1, TType.I64, 'providerId', None, None, ), # 1
14105 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14106 
  )
14107 
 
3064 chandransh 14108 
  def __init__(self, providerId=None, returnedOrders=None,):
14109 
    self.providerId = providerId
14110 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
3064 chandransh 14121 
      if fid == 1:
1596 ankur.sing 14122 
        if ftype == TType.I64:
3064 chandransh 14123 
          self.providerId = iprot.readI64();
1596 ankur.sing 14124 
        else:
14125 
          iprot.skip(ftype)
3064 chandransh 14126 
      elif fid == 2:
14127 
        if ftype == TType.MAP:
14128 
          self.returnedOrders = {}
6031 rajveer 14129 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14130 
          for _i288 in xrange(_size284):
14131 
            _key289 = iprot.readString();
14132 
            _val290 = iprot.readString();
14133 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14134 
          iprot.readMapEnd()
14135 
        else:
14136 
          iprot.skip(ftype)
1596 ankur.sing 14137 
      else:
14138 
        iprot.skip(ftype)
14139 
      iprot.readFieldEnd()
14140 
    iprot.readStructEnd()
14141 
 
14142 
  def write(self, oprot):
14143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14145 
      return
4910 phani.kuma 14146 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14147 
    if self.providerId is not None:
3064 chandransh 14148 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14149 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14150 
      oprot.writeFieldEnd()
3431 rajveer 14151 
    if self.returnedOrders is not None:
3064 chandransh 14152 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14153 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14154 
      for kiter291,viter292 in self.returnedOrders.items():
14155 
        oprot.writeString(kiter291)
14156 
        oprot.writeString(viter292)
3064 chandransh 14157 
      oprot.writeMapEnd()
14158 
      oprot.writeFieldEnd()
1596 ankur.sing 14159 
    oprot.writeFieldStop()
14160 
    oprot.writeStructEnd()
14161 
 
3431 rajveer 14162 
  def validate(self):
14163 
    return
14164 
 
14165 
 
1596 ankur.sing 14166 
  def __repr__(self):
14167 
    L = ['%s=%r' % (key, value)
14168 
      for key, value in self.__dict__.iteritems()]
14169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14170 
 
14171 
  def __eq__(self, other):
14172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14173 
 
14174 
  def __ne__(self, other):
14175 
    return not (self == other)
14176 
 
4910 phani.kuma 14177 
class markAsRTOrders_result:
3064 chandransh 14178 
  """
14179 
  Attributes:
14180 
   - ex
14181 
  """
1596 ankur.sing 14182 
 
1627 ankur.sing 14183 
  thrift_spec = (
3064 chandransh 14184 
    None, # 0
14185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14186 
  )
14187 
 
3064 chandransh 14188 
  def __init__(self, ex=None,):
14189 
    self.ex = ex
14190 
 
1627 ankur.sing 14191 
  def read(self, iprot):
14192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14194 
      return
14195 
    iprot.readStructBegin()
14196 
    while True:
14197 
      (fname, ftype, fid) = iprot.readFieldBegin()
14198 
      if ftype == TType.STOP:
14199 
        break
3064 chandransh 14200 
      if fid == 1:
14201 
        if ftype == TType.STRUCT:
14202 
          self.ex = TransactionServiceException()
14203 
          self.ex.read(iprot)
14204 
        else:
14205 
          iprot.skip(ftype)
1627 ankur.sing 14206 
      else:
14207 
        iprot.skip(ftype)
14208 
      iprot.readFieldEnd()
14209 
    iprot.readStructEnd()
14210 
 
14211 
  def write(self, oprot):
14212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14214 
      return
4910 phani.kuma 14215 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14216 
    if self.ex is not None:
3064 chandransh 14217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14218 
      self.ex.write(oprot)
14219 
      oprot.writeFieldEnd()
1627 ankur.sing 14220 
    oprot.writeFieldStop()
14221 
    oprot.writeStructEnd()
14222 
 
3431 rajveer 14223 
  def validate(self):
14224 
    return
14225 
 
14226 
 
1627 ankur.sing 14227 
  def __repr__(self):
14228 
    L = ['%s=%r' % (key, value)
14229 
      for key, value in self.__dict__.iteritems()]
14230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14231 
 
14232 
  def __eq__(self, other):
14233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14234 
 
14235 
  def __ne__(self, other):
14236 
    return not (self == other)
14237 
 
4910 phani.kuma 14238 
class getRTOrders_args:
14239 
  """
14240 
  Attributes:
14241 
   - providerId
14242 
  """
14243 
 
14244 
  thrift_spec = (
14245 
    None, # 0
14246 
    (1, TType.I64, 'providerId', None, None, ), # 1
14247 
  )
14248 
 
14249 
  def __init__(self, providerId=None,):
14250 
    self.providerId = providerId
14251 
 
14252 
  def read(self, iprot):
14253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14255 
      return
14256 
    iprot.readStructBegin()
14257 
    while True:
14258 
      (fname, ftype, fid) = iprot.readFieldBegin()
14259 
      if ftype == TType.STOP:
14260 
        break
14261 
      if fid == 1:
14262 
        if ftype == TType.I64:
14263 
          self.providerId = iprot.readI64();
14264 
        else:
14265 
          iprot.skip(ftype)
14266 
      else:
14267 
        iprot.skip(ftype)
14268 
      iprot.readFieldEnd()
14269 
    iprot.readStructEnd()
14270 
 
14271 
  def write(self, oprot):
14272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14274 
      return
14275 
    oprot.writeStructBegin('getRTOrders_args')
14276 
    if self.providerId is not None:
14277 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14278 
      oprot.writeI64(self.providerId)
14279 
      oprot.writeFieldEnd()
14280 
    oprot.writeFieldStop()
14281 
    oprot.writeStructEnd()
14282 
 
14283 
  def validate(self):
14284 
    return
14285 
 
14286 
 
14287 
  def __repr__(self):
14288 
    L = ['%s=%r' % (key, value)
14289 
      for key, value in self.__dict__.iteritems()]
14290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14291 
 
14292 
  def __eq__(self, other):
14293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14294 
 
14295 
  def __ne__(self, other):
14296 
    return not (self == other)
14297 
 
14298 
class getRTOrders_result:
14299 
  """
14300 
  Attributes:
14301 
   - success
14302 
  """
14303 
 
14304 
  thrift_spec = (
14305 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14306 
  )
14307 
 
14308 
  def __init__(self, success=None,):
14309 
    self.success = success
14310 
 
14311 
  def read(self, iprot):
14312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14314 
      return
14315 
    iprot.readStructBegin()
14316 
    while True:
14317 
      (fname, ftype, fid) = iprot.readFieldBegin()
14318 
      if ftype == TType.STOP:
14319 
        break
14320 
      if fid == 0:
14321 
        if ftype == TType.LIST:
14322 
          self.success = []
6031 rajveer 14323 
          (_etype296, _size293) = iprot.readListBegin()
14324 
          for _i297 in xrange(_size293):
14325 
            _elem298 = Order()
14326 
            _elem298.read(iprot)
14327 
            self.success.append(_elem298)
4910 phani.kuma 14328 
          iprot.readListEnd()
14329 
        else:
14330 
          iprot.skip(ftype)
14331 
      else:
14332 
        iprot.skip(ftype)
14333 
      iprot.readFieldEnd()
14334 
    iprot.readStructEnd()
14335 
 
14336 
  def write(self, oprot):
14337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14339 
      return
14340 
    oprot.writeStructBegin('getRTOrders_result')
14341 
    if self.success is not None:
14342 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14343 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14344 
      for iter299 in self.success:
14345 
        iter299.write(oprot)
4910 phani.kuma 14346 
      oprot.writeListEnd()
14347 
      oprot.writeFieldEnd()
14348 
    oprot.writeFieldStop()
14349 
    oprot.writeStructEnd()
14350 
 
14351 
  def validate(self):
14352 
    return
14353 
 
14354 
 
14355 
  def __repr__(self):
14356 
    L = ['%s=%r' % (key, value)
14357 
      for key, value in self.__dict__.iteritems()]
14358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14359 
 
14360 
  def __eq__(self, other):
14361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14362 
 
14363 
  def __ne__(self, other):
14364 
    return not (self == other)
14365 
 
3064 chandransh 14366 
class updateNonDeliveryReason_args:
1627 ankur.sing 14367 
  """
14368 
  Attributes:
3064 chandransh 14369 
   - providerId
14370 
   - undeliveredOrders
1627 ankur.sing 14371 
  """
14372 
 
14373 
  thrift_spec = (
3064 chandransh 14374 
    None, # 0
14375 
    (1, TType.I64, 'providerId', None, None, ), # 1
14376 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14377 
  )
14378 
 
3064 chandransh 14379 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14380 
    self.providerId = providerId
14381 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14382 
 
14383 
  def read(self, iprot):
14384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14386 
      return
14387 
    iprot.readStructBegin()
14388 
    while True:
14389 
      (fname, ftype, fid) = iprot.readFieldBegin()
14390 
      if ftype == TType.STOP:
14391 
        break
3064 chandransh 14392 
      if fid == 1:
1627 ankur.sing 14393 
        if ftype == TType.I64:
3064 chandransh 14394 
          self.providerId = iprot.readI64();
1627 ankur.sing 14395 
        else:
14396 
          iprot.skip(ftype)
3064 chandransh 14397 
      elif fid == 2:
14398 
        if ftype == TType.MAP:
14399 
          self.undeliveredOrders = {}
6031 rajveer 14400 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14401 
          for _i304 in xrange(_size300):
14402 
            _key305 = iprot.readString();
14403 
            _val306 = iprot.readString();
14404 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14405 
          iprot.readMapEnd()
14406 
        else:
14407 
          iprot.skip(ftype)
1627 ankur.sing 14408 
      else:
14409 
        iprot.skip(ftype)
14410 
      iprot.readFieldEnd()
14411 
    iprot.readStructEnd()
14412 
 
14413 
  def write(self, oprot):
14414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14416 
      return
3064 chandransh 14417 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14418 
    if self.providerId is not None:
3064 chandransh 14419 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14420 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14421 
      oprot.writeFieldEnd()
3431 rajveer 14422 
    if self.undeliveredOrders is not None:
3064 chandransh 14423 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14424 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14425 
      for kiter307,viter308 in self.undeliveredOrders.items():
14426 
        oprot.writeString(kiter307)
14427 
        oprot.writeString(viter308)
3064 chandransh 14428 
      oprot.writeMapEnd()
14429 
      oprot.writeFieldEnd()
1627 ankur.sing 14430 
    oprot.writeFieldStop()
14431 
    oprot.writeStructEnd()
14432 
 
3431 rajveer 14433 
  def validate(self):
14434 
    return
14435 
 
14436 
 
1627 ankur.sing 14437 
  def __repr__(self):
14438 
    L = ['%s=%r' % (key, value)
14439 
      for key, value in self.__dict__.iteritems()]
14440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14441 
 
14442 
  def __eq__(self, other):
14443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14444 
 
14445 
  def __ne__(self, other):
14446 
    return not (self == other)
14447 
 
3064 chandransh 14448 
class updateNonDeliveryReason_result:
1627 ankur.sing 14449 
  """
14450 
  Attributes:
3064 chandransh 14451 
   - ex
1627 ankur.sing 14452 
  """
14453 
 
14454 
  thrift_spec = (
4910 phani.kuma 14455 
    None, # 0
3064 chandransh 14456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14457 
  )
14458 
 
4910 phani.kuma 14459 
  def __init__(self, ex=None,):
3064 chandransh 14460 
    self.ex = ex
1627 ankur.sing 14461 
 
14462 
  def read(self, iprot):
14463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14465 
      return
14466 
    iprot.readStructBegin()
14467 
    while True:
14468 
      (fname, ftype, fid) = iprot.readFieldBegin()
14469 
      if ftype == TType.STOP:
14470 
        break
4910 phani.kuma 14471 
      if fid == 1:
14472 
        if ftype == TType.STRUCT:
14473 
          self.ex = TransactionServiceException()
14474 
          self.ex.read(iprot)
14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      else:
14478 
        iprot.skip(ftype)
14479 
      iprot.readFieldEnd()
14480 
    iprot.readStructEnd()
14481 
 
14482 
  def write(self, oprot):
14483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14485 
      return
14486 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14487 
    if self.ex is not None:
14488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14489 
      self.ex.write(oprot)
14490 
      oprot.writeFieldEnd()
14491 
    oprot.writeFieldStop()
14492 
    oprot.writeStructEnd()
14493 
 
14494 
  def validate(self):
14495 
    return
14496 
 
14497 
 
14498 
  def __repr__(self):
14499 
    L = ['%s=%r' % (key, value)
14500 
      for key, value in self.__dict__.iteritems()]
14501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14502 
 
14503 
  def __eq__(self, other):
14504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14505 
 
14506 
  def __ne__(self, other):
14507 
    return not (self == other)
14508 
 
14509 
class getNonDeliveredOrdersbyCourier_args:
14510 
  """
14511 
  Attributes:
14512 
   - providerId
14513 
  """
14514 
 
14515 
  thrift_spec = (
14516 
    None, # 0
14517 
    (1, TType.I64, 'providerId', None, None, ), # 1
14518 
  )
14519 
 
14520 
  def __init__(self, providerId=None,):
14521 
    self.providerId = providerId
14522 
 
14523 
  def read(self, iprot):
14524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14526 
      return
14527 
    iprot.readStructBegin()
14528 
    while True:
14529 
      (fname, ftype, fid) = iprot.readFieldBegin()
14530 
      if ftype == TType.STOP:
14531 
        break
14532 
      if fid == 1:
14533 
        if ftype == TType.I64:
14534 
          self.providerId = iprot.readI64();
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14547 
    if self.providerId is not None:
14548 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14549 
      oprot.writeI64(self.providerId)
14550 
      oprot.writeFieldEnd()
14551 
    oprot.writeFieldStop()
14552 
    oprot.writeStructEnd()
14553 
 
14554 
  def validate(self):
14555 
    return
14556 
 
14557 
 
14558 
  def __repr__(self):
14559 
    L = ['%s=%r' % (key, value)
14560 
      for key, value in self.__dict__.iteritems()]
14561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14562 
 
14563 
  def __eq__(self, other):
14564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14565 
 
14566 
  def __ne__(self, other):
14567 
    return not (self == other)
14568 
 
14569 
class getNonDeliveredOrdersbyCourier_result:
14570 
  """
14571 
  Attributes:
14572 
   - success
14573 
  """
14574 
 
14575 
  thrift_spec = (
14576 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14577 
  )
14578 
 
14579 
  def __init__(self, success=None,):
14580 
    self.success = success
14581 
 
14582 
  def read(self, iprot):
14583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14585 
      return
14586 
    iprot.readStructBegin()
14587 
    while True:
14588 
      (fname, ftype, fid) = iprot.readFieldBegin()
14589 
      if ftype == TType.STOP:
14590 
        break
4581 phani.kuma 14591 
      if fid == 0:
14592 
        if ftype == TType.LIST:
14593 
          self.success = []
6031 rajveer 14594 
          (_etype312, _size309) = iprot.readListBegin()
14595 
          for _i313 in xrange(_size309):
14596 
            _elem314 = Order()
14597 
            _elem314.read(iprot)
14598 
            self.success.append(_elem314)
4581 phani.kuma 14599 
          iprot.readListEnd()
14600 
        else:
14601 
          iprot.skip(ftype)
4910 phani.kuma 14602 
      else:
14603 
        iprot.skip(ftype)
14604 
      iprot.readFieldEnd()
14605 
    iprot.readStructEnd()
14606 
 
14607 
  def write(self, oprot):
14608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14610 
      return
14611 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14612 
    if self.success is not None:
14613 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14614 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14615 
      for iter315 in self.success:
14616 
        iter315.write(oprot)
4910 phani.kuma 14617 
      oprot.writeListEnd()
14618 
      oprot.writeFieldEnd()
14619 
    oprot.writeFieldStop()
14620 
    oprot.writeStructEnd()
14621 
 
14622 
  def validate(self):
14623 
    return
14624 
 
14625 
 
14626 
  def __repr__(self):
14627 
    L = ['%s=%r' % (key, value)
14628 
      for key, value in self.__dict__.iteritems()]
14629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14630 
 
14631 
  def __eq__(self, other):
14632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14633 
 
14634 
  def __ne__(self, other):
14635 
    return not (self == other)
14636 
 
14637 
class markOrdersAsLocalConnected_args:
14638 
  """
14639 
  Attributes:
14640 
   - providerId
14641 
   - local_connected_orders
14642 
  """
14643 
 
14644 
  thrift_spec = (
14645 
    None, # 0
14646 
    (1, TType.I64, 'providerId', None, None, ), # 1
14647 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14648 
  )
14649 
 
14650 
  def __init__(self, providerId=None, local_connected_orders=None,):
14651 
    self.providerId = providerId
14652 
    self.local_connected_orders = local_connected_orders
14653 
 
14654 
  def read(self, iprot):
14655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14657 
      return
14658 
    iprot.readStructBegin()
14659 
    while True:
14660 
      (fname, ftype, fid) = iprot.readFieldBegin()
14661 
      if ftype == TType.STOP:
14662 
        break
14663 
      if fid == 1:
14664 
        if ftype == TType.I64:
14665 
          self.providerId = iprot.readI64();
14666 
        else:
14667 
          iprot.skip(ftype)
14668 
      elif fid == 2:
14669 
        if ftype == TType.MAP:
14670 
          self.local_connected_orders = {}
6031 rajveer 14671 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14672 
          for _i320 in xrange(_size316):
14673 
            _key321 = iprot.readString();
14674 
            _val322 = iprot.readString();
14675 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14676 
          iprot.readMapEnd()
14677 
        else:
14678 
          iprot.skip(ftype)
14679 
      else:
14680 
        iprot.skip(ftype)
14681 
      iprot.readFieldEnd()
14682 
    iprot.readStructEnd()
14683 
 
14684 
  def write(self, oprot):
14685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14687 
      return
14688 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14689 
    if self.providerId is not None:
14690 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14691 
      oprot.writeI64(self.providerId)
14692 
      oprot.writeFieldEnd()
14693 
    if self.local_connected_orders is not None:
14694 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14695 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14696 
      for kiter323,viter324 in self.local_connected_orders.items():
14697 
        oprot.writeString(kiter323)
14698 
        oprot.writeString(viter324)
4910 phani.kuma 14699 
      oprot.writeMapEnd()
14700 
      oprot.writeFieldEnd()
14701 
    oprot.writeFieldStop()
14702 
    oprot.writeStructEnd()
14703 
 
14704 
  def validate(self):
14705 
    return
14706 
 
14707 
 
14708 
  def __repr__(self):
14709 
    L = ['%s=%r' % (key, value)
14710 
      for key, value in self.__dict__.iteritems()]
14711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14712 
 
14713 
  def __eq__(self, other):
14714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14715 
 
14716 
  def __ne__(self, other):
14717 
    return not (self == other)
14718 
 
14719 
class markOrdersAsLocalConnected_result:
14720 
  """
14721 
  Attributes:
14722 
   - ex
14723 
  """
14724 
 
14725 
  thrift_spec = (
14726 
    None, # 0
14727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14728 
  )
14729 
 
14730 
  def __init__(self, ex=None,):
14731 
    self.ex = ex
14732 
 
14733 
  def read(self, iprot):
14734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14736 
      return
14737 
    iprot.readStructBegin()
14738 
    while True:
14739 
      (fname, ftype, fid) = iprot.readFieldBegin()
14740 
      if ftype == TType.STOP:
14741 
        break
14742 
      if fid == 1:
3064 chandransh 14743 
        if ftype == TType.STRUCT:
14744 
          self.ex = TransactionServiceException()
14745 
          self.ex.read(iprot)
1627 ankur.sing 14746 
        else:
14747 
          iprot.skip(ftype)
14748 
      else:
14749 
        iprot.skip(ftype)
14750 
      iprot.readFieldEnd()
14751 
    iprot.readStructEnd()
14752 
 
14753 
  def write(self, oprot):
14754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14756 
      return
4910 phani.kuma 14757 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14758 
    if self.ex is not None:
14759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14760 
      self.ex.write(oprot)
14761 
      oprot.writeFieldEnd()
14762 
    oprot.writeFieldStop()
14763 
    oprot.writeStructEnd()
14764 
 
14765 
  def validate(self):
14766 
    return
14767 
 
14768 
 
14769 
  def __repr__(self):
14770 
    L = ['%s=%r' % (key, value)
14771 
      for key, value in self.__dict__.iteritems()]
14772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14773 
 
14774 
  def __eq__(self, other):
14775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14776 
 
14777 
  def __ne__(self, other):
14778 
    return not (self == other)
14779 
 
14780 
class getOrdersNotLocalConnected_args:
14781 
  """
14782 
  Attributes:
14783 
   - providerId
14784 
  """
14785 
 
14786 
  thrift_spec = (
14787 
    None, # 0
14788 
    (1, TType.I64, 'providerId', None, None, ), # 1
14789 
  )
14790 
 
14791 
  def __init__(self, providerId=None,):
14792 
    self.providerId = providerId
14793 
 
14794 
  def read(self, iprot):
14795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14797 
      return
14798 
    iprot.readStructBegin()
14799 
    while True:
14800 
      (fname, ftype, fid) = iprot.readFieldBegin()
14801 
      if ftype == TType.STOP:
14802 
        break
14803 
      if fid == 1:
14804 
        if ftype == TType.I64:
14805 
          self.providerId = iprot.readI64();
14806 
        else:
14807 
          iprot.skip(ftype)
14808 
      else:
14809 
        iprot.skip(ftype)
14810 
      iprot.readFieldEnd()
14811 
    iprot.readStructEnd()
14812 
 
14813 
  def write(self, oprot):
14814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14816 
      return
14817 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14818 
    if self.providerId is not None:
14819 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14820 
      oprot.writeI64(self.providerId)
14821 
      oprot.writeFieldEnd()
14822 
    oprot.writeFieldStop()
14823 
    oprot.writeStructEnd()
14824 
 
14825 
  def validate(self):
14826 
    return
14827 
 
14828 
 
14829 
  def __repr__(self):
14830 
    L = ['%s=%r' % (key, value)
14831 
      for key, value in self.__dict__.iteritems()]
14832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14833 
 
14834 
  def __eq__(self, other):
14835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14836 
 
14837 
  def __ne__(self, other):
14838 
    return not (self == other)
14839 
 
14840 
class getOrdersNotLocalConnected_result:
14841 
  """
14842 
  Attributes:
14843 
   - success
14844 
  """
14845 
 
14846 
  thrift_spec = (
14847 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14848 
  )
14849 
 
14850 
  def __init__(self, success=None,):
14851 
    self.success = success
14852 
 
14853 
  def read(self, iprot):
14854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14856 
      return
14857 
    iprot.readStructBegin()
14858 
    while True:
14859 
      (fname, ftype, fid) = iprot.readFieldBegin()
14860 
      if ftype == TType.STOP:
14861 
        break
14862 
      if fid == 0:
14863 
        if ftype == TType.LIST:
14864 
          self.success = []
6031 rajveer 14865 
          (_etype328, _size325) = iprot.readListBegin()
14866 
          for _i329 in xrange(_size325):
14867 
            _elem330 = Order()
14868 
            _elem330.read(iprot)
14869 
            self.success.append(_elem330)
4910 phani.kuma 14870 
          iprot.readListEnd()
14871 
        else:
14872 
          iprot.skip(ftype)
14873 
      else:
14874 
        iprot.skip(ftype)
14875 
      iprot.readFieldEnd()
14876 
    iprot.readStructEnd()
14877 
 
14878 
  def write(self, oprot):
14879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14881 
      return
14882 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14883 
    if self.success is not None:
14884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14886 
      for iter331 in self.success:
14887 
        iter331.write(oprot)
4581 phani.kuma 14888 
      oprot.writeListEnd()
14889 
      oprot.writeFieldEnd()
4910 phani.kuma 14890 
    oprot.writeFieldStop()
14891 
    oprot.writeStructEnd()
14892 
 
14893 
  def validate(self):
14894 
    return
14895 
 
14896 
 
14897 
  def __repr__(self):
14898 
    L = ['%s=%r' % (key, value)
14899 
      for key, value in self.__dict__.iteritems()]
14900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14901 
 
14902 
  def __eq__(self, other):
14903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14904 
 
14905 
  def __ne__(self, other):
14906 
    return not (self == other)
14907 
 
14908 
class markOrdersAsDestinationCityReached_args:
14909 
  """
14910 
  Attributes:
14911 
   - providerId
14912 
   - destination_city_reached_orders
14913 
  """
14914 
 
14915 
  thrift_spec = (
14916 
    None, # 0
14917 
    (1, TType.I64, 'providerId', None, None, ), # 1
14918 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14919 
  )
14920 
 
14921 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14922 
    self.providerId = providerId
14923 
    self.destination_city_reached_orders = destination_city_reached_orders
14924 
 
14925 
  def read(self, iprot):
14926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14928 
      return
14929 
    iprot.readStructBegin()
14930 
    while True:
14931 
      (fname, ftype, fid) = iprot.readFieldBegin()
14932 
      if ftype == TType.STOP:
14933 
        break
14934 
      if fid == 1:
14935 
        if ftype == TType.I64:
14936 
          self.providerId = iprot.readI64();
14937 
        else:
14938 
          iprot.skip(ftype)
14939 
      elif fid == 2:
14940 
        if ftype == TType.MAP:
14941 
          self.destination_city_reached_orders = {}
6031 rajveer 14942 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14943 
          for _i336 in xrange(_size332):
14944 
            _key337 = iprot.readString();
14945 
            _val338 = iprot.readString();
14946 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14947 
          iprot.readMapEnd()
14948 
        else:
14949 
          iprot.skip(ftype)
14950 
      else:
14951 
        iprot.skip(ftype)
14952 
      iprot.readFieldEnd()
14953 
    iprot.readStructEnd()
14954 
 
14955 
  def write(self, oprot):
14956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14958 
      return
14959 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14960 
    if self.providerId is not None:
14961 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14962 
      oprot.writeI64(self.providerId)
14963 
      oprot.writeFieldEnd()
14964 
    if self.destination_city_reached_orders is not None:
14965 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14966 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 14967 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14968 
        oprot.writeString(kiter339)
14969 
        oprot.writeString(viter340)
4910 phani.kuma 14970 
      oprot.writeMapEnd()
14971 
      oprot.writeFieldEnd()
14972 
    oprot.writeFieldStop()
14973 
    oprot.writeStructEnd()
14974 
 
14975 
  def validate(self):
14976 
    return
14977 
 
14978 
 
14979 
  def __repr__(self):
14980 
    L = ['%s=%r' % (key, value)
14981 
      for key, value in self.__dict__.iteritems()]
14982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14983 
 
14984 
  def __eq__(self, other):
14985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14986 
 
14987 
  def __ne__(self, other):
14988 
    return not (self == other)
14989 
 
14990 
class markOrdersAsDestinationCityReached_result:
14991 
  """
14992 
  Attributes:
14993 
   - ex
14994 
  """
14995 
 
14996 
  thrift_spec = (
14997 
    None, # 0
14998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14999 
  )
15000 
 
15001 
  def __init__(self, ex=None,):
15002 
    self.ex = ex
15003 
 
15004 
  def read(self, iprot):
15005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15007 
      return
15008 
    iprot.readStructBegin()
15009 
    while True:
15010 
      (fname, ftype, fid) = iprot.readFieldBegin()
15011 
      if ftype == TType.STOP:
15012 
        break
15013 
      if fid == 1:
15014 
        if ftype == TType.STRUCT:
15015 
          self.ex = TransactionServiceException()
15016 
          self.ex.read(iprot)
15017 
        else:
15018 
          iprot.skip(ftype)
15019 
      else:
15020 
        iprot.skip(ftype)
15021 
      iprot.readFieldEnd()
15022 
    iprot.readStructEnd()
15023 
 
15024 
  def write(self, oprot):
15025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15027 
      return
15028 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15029 
    if self.ex is not None:
3064 chandransh 15030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15031 
      self.ex.write(oprot)
1627 ankur.sing 15032 
      oprot.writeFieldEnd()
15033 
    oprot.writeFieldStop()
15034 
    oprot.writeStructEnd()
15035 
 
3431 rajveer 15036 
  def validate(self):
15037 
    return
15038 
 
15039 
 
1627 ankur.sing 15040 
  def __repr__(self):
15041 
    L = ['%s=%r' % (key, value)
15042 
      for key, value in self.__dict__.iteritems()]
15043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15044 
 
15045 
  def __eq__(self, other):
15046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15047 
 
15048 
  def __ne__(self, other):
15049 
    return not (self == other)
15050 
 
4910 phani.kuma 15051 
class markOrdersAsFirstDeliveryAttempted_args:
15052 
  """
15053 
  Attributes:
15054 
   - providerId
15055 
   - first_atdl_orders
15056 
  """
15057 
 
15058 
  thrift_spec = (
15059 
    None, # 0
15060 
    (1, TType.I64, 'providerId', None, None, ), # 1
15061 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15062 
  )
15063 
 
15064 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15065 
    self.providerId = providerId
15066 
    self.first_atdl_orders = first_atdl_orders
15067 
 
15068 
  def read(self, iprot):
15069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15071 
      return
15072 
    iprot.readStructBegin()
15073 
    while True:
15074 
      (fname, ftype, fid) = iprot.readFieldBegin()
15075 
      if ftype == TType.STOP:
15076 
        break
15077 
      if fid == 1:
15078 
        if ftype == TType.I64:
15079 
          self.providerId = iprot.readI64();
15080 
        else:
15081 
          iprot.skip(ftype)
15082 
      elif fid == 2:
15083 
        if ftype == TType.MAP:
15084 
          self.first_atdl_orders = {}
6031 rajveer 15085 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
15086 
          for _i345 in xrange(_size341):
15087 
            _key346 = iprot.readString();
15088 
            _val347 = iprot.readString();
15089 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 15090 
          iprot.readMapEnd()
15091 
        else:
15092 
          iprot.skip(ftype)
15093 
      else:
15094 
        iprot.skip(ftype)
15095 
      iprot.readFieldEnd()
15096 
    iprot.readStructEnd()
15097 
 
15098 
  def write(self, oprot):
15099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15101 
      return
15102 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15103 
    if self.providerId is not None:
15104 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15105 
      oprot.writeI64(self.providerId)
15106 
      oprot.writeFieldEnd()
15107 
    if self.first_atdl_orders is not None:
15108 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15109 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15110 
      for kiter348,viter349 in self.first_atdl_orders.items():
15111 
        oprot.writeString(kiter348)
15112 
        oprot.writeString(viter349)
4910 phani.kuma 15113 
      oprot.writeMapEnd()
15114 
      oprot.writeFieldEnd()
15115 
    oprot.writeFieldStop()
15116 
    oprot.writeStructEnd()
15117 
 
15118 
  def validate(self):
15119 
    return
15120 
 
15121 
 
15122 
  def __repr__(self):
15123 
    L = ['%s=%r' % (key, value)
15124 
      for key, value in self.__dict__.iteritems()]
15125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15126 
 
15127 
  def __eq__(self, other):
15128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15129 
 
15130 
  def __ne__(self, other):
15131 
    return not (self == other)
15132 
 
15133 
class markOrdersAsFirstDeliveryAttempted_result:
15134 
  """
15135 
  Attributes:
15136 
   - ex
15137 
  """
15138 
 
15139 
  thrift_spec = (
15140 
    None, # 0
15141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15142 
  )
15143 
 
15144 
  def __init__(self, ex=None,):
15145 
    self.ex = ex
15146 
 
15147 
  def read(self, iprot):
15148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15150 
      return
15151 
    iprot.readStructBegin()
15152 
    while True:
15153 
      (fname, ftype, fid) = iprot.readFieldBegin()
15154 
      if ftype == TType.STOP:
15155 
        break
15156 
      if fid == 1:
15157 
        if ftype == TType.STRUCT:
15158 
          self.ex = TransactionServiceException()
15159 
          self.ex.read(iprot)
15160 
        else:
15161 
          iprot.skip(ftype)
15162 
      else:
15163 
        iprot.skip(ftype)
15164 
      iprot.readFieldEnd()
15165 
    iprot.readStructEnd()
15166 
 
15167 
  def write(self, oprot):
15168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15170 
      return
15171 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15172 
    if self.ex is not None:
15173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15174 
      self.ex.write(oprot)
15175 
      oprot.writeFieldEnd()
15176 
    oprot.writeFieldStop()
15177 
    oprot.writeStructEnd()
15178 
 
15179 
  def validate(self):
15180 
    return
15181 
 
15182 
 
15183 
  def __repr__(self):
15184 
    L = ['%s=%r' % (key, value)
15185 
      for key, value in self.__dict__.iteritems()]
15186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15187 
 
15188 
  def __eq__(self, other):
15189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15190 
 
15191 
  def __ne__(self, other):
15192 
    return not (self == other)
15193 
 
3064 chandransh 15194 
class getUndeliveredOrders_args:
1886 ankur.sing 15195 
  """
15196 
  Attributes:
3064 chandransh 15197 
   - providerId
15198 
   - warehouseId
1886 ankur.sing 15199 
  """
1627 ankur.sing 15200 
 
1886 ankur.sing 15201 
  thrift_spec = (
15202 
    None, # 0
3064 chandransh 15203 
    (1, TType.I64, 'providerId', None, None, ), # 1
15204 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15205 
  )
15206 
 
3064 chandransh 15207 
  def __init__(self, providerId=None, warehouseId=None,):
15208 
    self.providerId = providerId
15209 
    self.warehouseId = warehouseId
1886 ankur.sing 15210 
 
15211 
  def read(self, iprot):
15212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15214 
      return
15215 
    iprot.readStructBegin()
15216 
    while True:
15217 
      (fname, ftype, fid) = iprot.readFieldBegin()
15218 
      if ftype == TType.STOP:
15219 
        break
15220 
      if fid == 1:
15221 
        if ftype == TType.I64:
3064 chandransh 15222 
          self.providerId = iprot.readI64();
1886 ankur.sing 15223 
        else:
15224 
          iprot.skip(ftype)
3064 chandransh 15225 
      elif fid == 2:
15226 
        if ftype == TType.I64:
15227 
          self.warehouseId = iprot.readI64();
15228 
        else:
15229 
          iprot.skip(ftype)
1886 ankur.sing 15230 
      else:
15231 
        iprot.skip(ftype)
15232 
      iprot.readFieldEnd()
15233 
    iprot.readStructEnd()
15234 
 
15235 
  def write(self, oprot):
15236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15238 
      return
3064 chandransh 15239 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15240 
    if self.providerId is not None:
3064 chandransh 15241 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15242 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15243 
      oprot.writeFieldEnd()
3431 rajveer 15244 
    if self.warehouseId is not None:
3064 chandransh 15245 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15246 
      oprot.writeI64(self.warehouseId)
15247 
      oprot.writeFieldEnd()
1886 ankur.sing 15248 
    oprot.writeFieldStop()
15249 
    oprot.writeStructEnd()
15250 
 
3431 rajveer 15251 
  def validate(self):
15252 
    return
15253 
 
15254 
 
1886 ankur.sing 15255 
  def __repr__(self):
15256 
    L = ['%s=%r' % (key, value)
15257 
      for key, value in self.__dict__.iteritems()]
15258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15259 
 
15260 
  def __eq__(self, other):
15261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15262 
 
15263 
  def __ne__(self, other):
15264 
    return not (self == other)
15265 
 
3064 chandransh 15266 
class getUndeliveredOrders_result:
1886 ankur.sing 15267 
  """
15268 
  Attributes:
15269 
   - success
15270 
  """
15271 
 
15272 
  thrift_spec = (
15273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15274 
  )
15275 
 
15276 
  def __init__(self, success=None,):
15277 
    self.success = success
15278 
 
15279 
  def read(self, iprot):
15280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15282 
      return
15283 
    iprot.readStructBegin()
15284 
    while True:
15285 
      (fname, ftype, fid) = iprot.readFieldBegin()
15286 
      if ftype == TType.STOP:
15287 
        break
15288 
      if fid == 0:
15289 
        if ftype == TType.LIST:
15290 
          self.success = []
6031 rajveer 15291 
          (_etype353, _size350) = iprot.readListBegin()
15292 
          for _i354 in xrange(_size350):
15293 
            _elem355 = Order()
15294 
            _elem355.read(iprot)
15295 
            self.success.append(_elem355)
1886 ankur.sing 15296 
          iprot.readListEnd()
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      else:
15300 
        iprot.skip(ftype)
15301 
      iprot.readFieldEnd()
15302 
    iprot.readStructEnd()
15303 
 
15304 
  def write(self, oprot):
15305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15307 
      return
3064 chandransh 15308 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15309 
    if self.success is not None:
1886 ankur.sing 15310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15312 
      for iter356 in self.success:
15313 
        iter356.write(oprot)
1886 ankur.sing 15314 
      oprot.writeListEnd()
15315 
      oprot.writeFieldEnd()
15316 
    oprot.writeFieldStop()
15317 
    oprot.writeStructEnd()
15318 
 
3431 rajveer 15319 
  def validate(self):
15320 
    return
15321 
 
15322 
 
1886 ankur.sing 15323 
  def __repr__(self):
15324 
    L = ['%s=%r' % (key, value)
15325 
      for key, value in self.__dict__.iteritems()]
15326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15327 
 
15328 
  def __eq__(self, other):
15329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15330 
 
15331 
  def __ne__(self, other):
15332 
    return not (self == other)
15333 
 
4783 phani.kuma 15334 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15335 
 
15336 
  thrift_spec = (
15337 
  )
15338 
 
15339 
  def read(self, iprot):
15340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15342 
      return
15343 
    iprot.readStructBegin()
15344 
    while True:
15345 
      (fname, ftype, fid) = iprot.readFieldBegin()
15346 
      if ftype == TType.STOP:
15347 
        break
15348 
      else:
15349 
        iprot.skip(ftype)
15350 
      iprot.readFieldEnd()
15351 
    iprot.readStructEnd()
15352 
 
15353 
  def write(self, oprot):
15354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15356 
      return
15357 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15358 
    oprot.writeFieldStop()
15359 
    oprot.writeStructEnd()
15360 
 
15361 
  def validate(self):
15362 
    return
15363 
 
15364 
 
15365 
  def __repr__(self):
15366 
    L = ['%s=%r' % (key, value)
15367 
      for key, value in self.__dict__.iteritems()]
15368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15369 
 
15370 
  def __eq__(self, other):
15371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15372 
 
15373 
  def __ne__(self, other):
15374 
    return not (self == other)
15375 
 
15376 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15377 
  """
15378 
  Attributes:
15379 
   - success
15380 
  """
15381 
 
15382 
  thrift_spec = (
15383 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15384 
  )
15385 
 
15386 
  def __init__(self, success=None,):
15387 
    self.success = success
15388 
 
15389 
  def read(self, iprot):
15390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15392 
      return
15393 
    iprot.readStructBegin()
15394 
    while True:
15395 
      (fname, ftype, fid) = iprot.readFieldBegin()
15396 
      if ftype == TType.STOP:
15397 
        break
15398 
      if fid == 0:
15399 
        if ftype == TType.LIST:
15400 
          self.success = []
6031 rajveer 15401 
          (_etype360, _size357) = iprot.readListBegin()
15402 
          for _i361 in xrange(_size357):
15403 
            _elem362 = Order()
15404 
            _elem362.read(iprot)
15405 
            self.success.append(_elem362)
4783 phani.kuma 15406 
          iprot.readListEnd()
15407 
        else:
15408 
          iprot.skip(ftype)
15409 
      else:
15410 
        iprot.skip(ftype)
15411 
      iprot.readFieldEnd()
15412 
    iprot.readStructEnd()
15413 
 
15414 
  def write(self, oprot):
15415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15417 
      return
15418 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15419 
    if self.success is not None:
15420 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15421 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15422 
      for iter363 in self.success:
15423 
        iter363.write(oprot)
4783 phani.kuma 15424 
      oprot.writeListEnd()
15425 
      oprot.writeFieldEnd()
15426 
    oprot.writeFieldStop()
15427 
    oprot.writeStructEnd()
15428 
 
15429 
  def validate(self):
15430 
    return
15431 
 
15432 
 
15433 
  def __repr__(self):
15434 
    L = ['%s=%r' % (key, value)
15435 
      for key, value in self.__dict__.iteritems()]
15436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15437 
 
15438 
  def __eq__(self, other):
15439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15440 
 
15441 
  def __ne__(self, other):
15442 
    return not (self == other)
15443 
 
2536 chandransh 15444 
class toggleDOAFlag_args:
15445 
  """
15446 
  Attributes:
15447 
   - orderId
15448 
  """
1886 ankur.sing 15449 
 
2536 chandransh 15450 
  thrift_spec = (
15451 
    None, # 0
15452 
    (1, TType.I64, 'orderId', None, None, ), # 1
15453 
  )
15454 
 
15455 
  def __init__(self, orderId=None,):
15456 
    self.orderId = orderId
15457 
 
15458 
  def read(self, iprot):
15459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15461 
      return
15462 
    iprot.readStructBegin()
15463 
    while True:
15464 
      (fname, ftype, fid) = iprot.readFieldBegin()
15465 
      if ftype == TType.STOP:
15466 
        break
15467 
      if fid == 1:
15468 
        if ftype == TType.I64:
15469 
          self.orderId = iprot.readI64();
15470 
        else:
15471 
          iprot.skip(ftype)
15472 
      else:
15473 
        iprot.skip(ftype)
15474 
      iprot.readFieldEnd()
15475 
    iprot.readStructEnd()
15476 
 
15477 
  def write(self, oprot):
15478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15480 
      return
15481 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15482 
    if self.orderId is not None:
2536 chandransh 15483 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15484 
      oprot.writeI64(self.orderId)
15485 
      oprot.writeFieldEnd()
15486 
    oprot.writeFieldStop()
15487 
    oprot.writeStructEnd()
15488 
 
3431 rajveer 15489 
  def validate(self):
15490 
    return
15491 
 
15492 
 
2536 chandransh 15493 
  def __repr__(self):
15494 
    L = ['%s=%r' % (key, value)
15495 
      for key, value in self.__dict__.iteritems()]
15496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15497 
 
15498 
  def __eq__(self, other):
15499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15500 
 
15501 
  def __ne__(self, other):
15502 
    return not (self == other)
15503 
 
15504 
class toggleDOAFlag_result:
15505 
  """
15506 
  Attributes:
15507 
   - success
15508 
   - ex
15509 
  """
15510 
 
15511 
  thrift_spec = (
15512 
    (0, TType.BOOL, 'success', None, None, ), # 0
15513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15514 
  )
15515 
 
15516 
  def __init__(self, success=None, ex=None,):
15517 
    self.success = success
15518 
    self.ex = ex
15519 
 
15520 
  def read(self, iprot):
15521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15523 
      return
15524 
    iprot.readStructBegin()
15525 
    while True:
15526 
      (fname, ftype, fid) = iprot.readFieldBegin()
15527 
      if ftype == TType.STOP:
15528 
        break
15529 
      if fid == 0:
15530 
        if ftype == TType.BOOL:
15531 
          self.success = iprot.readBool();
15532 
        else:
15533 
          iprot.skip(ftype)
15534 
      elif fid == 1:
15535 
        if ftype == TType.STRUCT:
15536 
          self.ex = TransactionServiceException()
15537 
          self.ex.read(iprot)
15538 
        else:
15539 
          iprot.skip(ftype)
15540 
      else:
15541 
        iprot.skip(ftype)
15542 
      iprot.readFieldEnd()
15543 
    iprot.readStructEnd()
15544 
 
15545 
  def write(self, oprot):
15546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15548 
      return
15549 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15550 
    if self.success is not None:
2536 chandransh 15551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15552 
      oprot.writeBool(self.success)
15553 
      oprot.writeFieldEnd()
3431 rajveer 15554 
    if self.ex is not None:
2536 chandransh 15555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15556 
      self.ex.write(oprot)
15557 
      oprot.writeFieldEnd()
15558 
    oprot.writeFieldStop()
15559 
    oprot.writeStructEnd()
15560 
 
3431 rajveer 15561 
  def validate(self):
15562 
    return
15563 
 
15564 
 
2536 chandransh 15565 
  def __repr__(self):
15566 
    L = ['%s=%r' % (key, value)
15567 
      for key, value in self.__dict__.iteritems()]
15568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15569 
 
15570 
  def __eq__(self, other):
15571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15572 
 
15573 
  def __ne__(self, other):
15574 
    return not (self == other)
15575 
 
4712 rajveer 15576 
class markOrderAsDelivered_args:
15577 
  """
15578 
  Attributes:
15579 
   - orderId
15580 
   - deliveryTimestamp
15581 
   - receiver
15582 
  """
15583 
 
15584 
  thrift_spec = None
15585 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15586 
    self.orderId = orderId
15587 
    self.deliveryTimestamp = deliveryTimestamp
15588 
    self.receiver = receiver
15589 
 
15590 
  def read(self, iprot):
15591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15593 
      return
15594 
    iprot.readStructBegin()
15595 
    while True:
15596 
      (fname, ftype, fid) = iprot.readFieldBegin()
15597 
      if ftype == TType.STOP:
15598 
        break
15599 
      if fid == 1:
15600 
        if ftype == TType.I64:
15601 
          self.orderId = iprot.readI64();
15602 
        else:
15603 
          iprot.skip(ftype)
15604 
      elif fid == 2:
15605 
        if ftype == TType.I64:
15606 
          self.deliveryTimestamp = iprot.readI64();
15607 
        else:
15608 
          iprot.skip(ftype)
15609 
      elif fid == -1:
15610 
        if ftype == TType.STRING:
15611 
          self.receiver = iprot.readString();
15612 
        else:
15613 
          iprot.skip(ftype)
15614 
      else:
15615 
        iprot.skip(ftype)
15616 
      iprot.readFieldEnd()
15617 
    iprot.readStructEnd()
15618 
 
15619 
  def write(self, oprot):
15620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15622 
      return
15623 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15624 
    if self.receiver is not None:
15625 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15626 
      oprot.writeString(self.receiver)
15627 
      oprot.writeFieldEnd()
15628 
    if self.orderId is not None:
15629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15630 
      oprot.writeI64(self.orderId)
15631 
      oprot.writeFieldEnd()
15632 
    if self.deliveryTimestamp is not None:
15633 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15634 
      oprot.writeI64(self.deliveryTimestamp)
15635 
      oprot.writeFieldEnd()
15636 
    oprot.writeFieldStop()
15637 
    oprot.writeStructEnd()
15638 
 
15639 
  def validate(self):
15640 
    return
15641 
 
15642 
 
15643 
  def __repr__(self):
15644 
    L = ['%s=%r' % (key, value)
15645 
      for key, value in self.__dict__.iteritems()]
15646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15647 
 
15648 
  def __eq__(self, other):
15649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15650 
 
15651 
  def __ne__(self, other):
15652 
    return not (self == other)
15653 
 
15654 
class markOrderAsDelivered_result:
15655 
  """
15656 
  Attributes:
15657 
   - ex
15658 
  """
15659 
 
15660 
  thrift_spec = (
15661 
    None, # 0
15662 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15663 
  )
15664 
 
15665 
  def __init__(self, ex=None,):
15666 
    self.ex = ex
15667 
 
15668 
  def read(self, iprot):
15669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15671 
      return
15672 
    iprot.readStructBegin()
15673 
    while True:
15674 
      (fname, ftype, fid) = iprot.readFieldBegin()
15675 
      if ftype == TType.STOP:
15676 
        break
15677 
      if fid == 1:
15678 
        if ftype == TType.STRUCT:
15679 
          self.ex = TransactionServiceException()
15680 
          self.ex.read(iprot)
15681 
        else:
15682 
          iprot.skip(ftype)
15683 
      else:
15684 
        iprot.skip(ftype)
15685 
      iprot.readFieldEnd()
15686 
    iprot.readStructEnd()
15687 
 
15688 
  def write(self, oprot):
15689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15691 
      return
15692 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15693 
    if self.ex is not None:
15694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15695 
      self.ex.write(oprot)
15696 
      oprot.writeFieldEnd()
15697 
    oprot.writeFieldStop()
15698 
    oprot.writeStructEnd()
15699 
 
15700 
  def validate(self):
15701 
    return
15702 
 
15703 
 
15704 
  def __repr__(self):
15705 
    L = ['%s=%r' % (key, value)
15706 
      for key, value in self.__dict__.iteritems()]
15707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15708 
 
15709 
  def __eq__(self, other):
15710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15711 
 
15712 
  def __ne__(self, other):
15713 
    return not (self == other)
15714 
 
5553 rajveer 15715 
class markOrderAsReceivedAtStore_args:
15716 
  """
15717 
  Attributes:
15718 
   - orderId
15719 
   - deliveryTimestamp
15720 
  """
15721 
 
15722 
  thrift_spec = (
15723 
    None, # 0
15724 
    (1, TType.I64, 'orderId', None, None, ), # 1
15725 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15726 
  )
15727 
 
15728 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15729 
    self.orderId = orderId
15730 
    self.deliveryTimestamp = deliveryTimestamp
15731 
 
15732 
  def read(self, iprot):
15733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15735 
      return
15736 
    iprot.readStructBegin()
15737 
    while True:
15738 
      (fname, ftype, fid) = iprot.readFieldBegin()
15739 
      if ftype == TType.STOP:
15740 
        break
15741 
      if fid == 1:
15742 
        if ftype == TType.I64:
15743 
          self.orderId = iprot.readI64();
15744 
        else:
15745 
          iprot.skip(ftype)
15746 
      elif fid == 2:
15747 
        if ftype == TType.I64:
15748 
          self.deliveryTimestamp = iprot.readI64();
15749 
        else:
15750 
          iprot.skip(ftype)
15751 
      else:
15752 
        iprot.skip(ftype)
15753 
      iprot.readFieldEnd()
15754 
    iprot.readStructEnd()
15755 
 
15756 
  def write(self, oprot):
15757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15759 
      return
15760 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15761 
    if self.orderId is not None:
15762 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15763 
      oprot.writeI64(self.orderId)
15764 
      oprot.writeFieldEnd()
15765 
    if self.deliveryTimestamp is not None:
15766 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15767 
      oprot.writeI64(self.deliveryTimestamp)
15768 
      oprot.writeFieldEnd()
15769 
    oprot.writeFieldStop()
15770 
    oprot.writeStructEnd()
15771 
 
15772 
  def validate(self):
15773 
    return
15774 
 
15775 
 
15776 
  def __repr__(self):
15777 
    L = ['%s=%r' % (key, value)
15778 
      for key, value in self.__dict__.iteritems()]
15779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15780 
 
15781 
  def __eq__(self, other):
15782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15783 
 
15784 
  def __ne__(self, other):
15785 
    return not (self == other)
15786 
 
15787 
class markOrderAsReceivedAtStore_result:
15788 
  """
15789 
  Attributes:
15790 
   - ex
15791 
  """
15792 
 
15793 
  thrift_spec = (
15794 
    None, # 0
15795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15796 
  )
15797 
 
15798 
  def __init__(self, ex=None,):
15799 
    self.ex = ex
15800 
 
15801 
  def read(self, iprot):
15802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15804 
      return
15805 
    iprot.readStructBegin()
15806 
    while True:
15807 
      (fname, ftype, fid) = iprot.readFieldBegin()
15808 
      if ftype == TType.STOP:
15809 
        break
15810 
      if fid == 1:
15811 
        if ftype == TType.STRUCT:
15812 
          self.ex = TransactionServiceException()
15813 
          self.ex.read(iprot)
15814 
        else:
15815 
          iprot.skip(ftype)
15816 
      else:
15817 
        iprot.skip(ftype)
15818 
      iprot.readFieldEnd()
15819 
    iprot.readStructEnd()
15820 
 
15821 
  def write(self, oprot):
15822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15824 
      return
15825 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15826 
    if self.ex is not None:
15827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15828 
      self.ex.write(oprot)
15829 
      oprot.writeFieldEnd()
15830 
    oprot.writeFieldStop()
15831 
    oprot.writeStructEnd()
15832 
 
15833 
  def validate(self):
15834 
    return
15835 
 
15836 
 
15837 
  def __repr__(self):
15838 
    L = ['%s=%r' % (key, value)
15839 
      for key, value in self.__dict__.iteritems()]
15840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15841 
 
15842 
  def __eq__(self, other):
15843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15844 
 
15845 
  def __ne__(self, other):
15846 
    return not (self == other)
15847 
 
4454 rajveer 15848 
class markOrderDoaRequestReceived_args:
15849 
  """
15850 
  Attributes:
15851 
   - orderId
15852 
  """
15853 
 
15854 
  thrift_spec = (
15855 
    None, # 0
15856 
    (1, TType.I64, 'orderId', None, None, ), # 1
15857 
  )
15858 
 
15859 
  def __init__(self, orderId=None,):
15860 
    self.orderId = orderId
15861 
 
15862 
  def read(self, iprot):
15863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15865 
      return
15866 
    iprot.readStructBegin()
15867 
    while True:
15868 
      (fname, ftype, fid) = iprot.readFieldBegin()
15869 
      if ftype == TType.STOP:
15870 
        break
15871 
      if fid == 1:
15872 
        if ftype == TType.I64:
15873 
          self.orderId = iprot.readI64();
15874 
        else:
15875 
          iprot.skip(ftype)
15876 
      else:
15877 
        iprot.skip(ftype)
15878 
      iprot.readFieldEnd()
15879 
    iprot.readStructEnd()
15880 
 
15881 
  def write(self, oprot):
15882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15884 
      return
15885 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15886 
    if self.orderId is not None:
15887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15888 
      oprot.writeI64(self.orderId)
15889 
      oprot.writeFieldEnd()
15890 
    oprot.writeFieldStop()
15891 
    oprot.writeStructEnd()
15892 
 
15893 
  def validate(self):
15894 
    return
15895 
 
15896 
 
15897 
  def __repr__(self):
15898 
    L = ['%s=%r' % (key, value)
15899 
      for key, value in self.__dict__.iteritems()]
15900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15901 
 
15902 
  def __eq__(self, other):
15903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15904 
 
15905 
  def __ne__(self, other):
15906 
    return not (self == other)
15907 
 
15908 
class markOrderDoaRequestReceived_result:
15909 
  """
15910 
  Attributes:
15911 
   - success
15912 
   - ex
15913 
  """
15914 
 
15915 
  thrift_spec = (
15916 
    (0, TType.BOOL, 'success', None, None, ), # 0
15917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15918 
  )
15919 
 
15920 
  def __init__(self, success=None, ex=None,):
15921 
    self.success = success
15922 
    self.ex = ex
15923 
 
15924 
  def read(self, iprot):
15925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15927 
      return
15928 
    iprot.readStructBegin()
15929 
    while True:
15930 
      (fname, ftype, fid) = iprot.readFieldBegin()
15931 
      if ftype == TType.STOP:
15932 
        break
15933 
      if fid == 0:
15934 
        if ftype == TType.BOOL:
15935 
          self.success = iprot.readBool();
15936 
        else:
15937 
          iprot.skip(ftype)
15938 
      elif fid == 1:
15939 
        if ftype == TType.STRUCT:
15940 
          self.ex = TransactionServiceException()
15941 
          self.ex.read(iprot)
15942 
        else:
15943 
          iprot.skip(ftype)
15944 
      else:
15945 
        iprot.skip(ftype)
15946 
      iprot.readFieldEnd()
15947 
    iprot.readStructEnd()
15948 
 
15949 
  def write(self, oprot):
15950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15952 
      return
15953 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15954 
    if self.success is not None:
15955 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15956 
      oprot.writeBool(self.success)
15957 
      oprot.writeFieldEnd()
15958 
    if self.ex is not None:
15959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15960 
      self.ex.write(oprot)
15961 
      oprot.writeFieldEnd()
15962 
    oprot.writeFieldStop()
15963 
    oprot.writeStructEnd()
15964 
 
15965 
  def validate(self):
15966 
    return
15967 
 
15968 
 
15969 
  def __repr__(self):
15970 
    L = ['%s=%r' % (key, value)
15971 
      for key, value in self.__dict__.iteritems()]
15972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15973 
 
15974 
  def __eq__(self, other):
15975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15976 
 
15977 
  def __ne__(self, other):
15978 
    return not (self == other)
15979 
 
15980 
class markOrderDoaRequestAuthorized_args:
15981 
  """
15982 
  Attributes:
15983 
   - orderId
15984 
   - isAuthorized
15985 
  """
15986 
 
15987 
  thrift_spec = (
15988 
    None, # 0
15989 
    (1, TType.I64, 'orderId', None, None, ), # 1
15990 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15991 
  )
15992 
 
15993 
  def __init__(self, orderId=None, isAuthorized=None,):
15994 
    self.orderId = orderId
15995 
    self.isAuthorized = isAuthorized
15996 
 
15997 
  def read(self, iprot):
15998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16000 
      return
16001 
    iprot.readStructBegin()
16002 
    while True:
16003 
      (fname, ftype, fid) = iprot.readFieldBegin()
16004 
      if ftype == TType.STOP:
16005 
        break
16006 
      if fid == 1:
16007 
        if ftype == TType.I64:
16008 
          self.orderId = iprot.readI64();
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      elif fid == 2:
16012 
        if ftype == TType.BOOL:
16013 
          self.isAuthorized = iprot.readBool();
16014 
        else:
16015 
          iprot.skip(ftype)
16016 
      else:
16017 
        iprot.skip(ftype)
16018 
      iprot.readFieldEnd()
16019 
    iprot.readStructEnd()
16020 
 
16021 
  def write(self, oprot):
16022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16024 
      return
16025 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16026 
    if self.orderId is not None:
16027 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16028 
      oprot.writeI64(self.orderId)
16029 
      oprot.writeFieldEnd()
16030 
    if self.isAuthorized is not None:
16031 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16032 
      oprot.writeBool(self.isAuthorized)
16033 
      oprot.writeFieldEnd()
16034 
    oprot.writeFieldStop()
16035 
    oprot.writeStructEnd()
16036 
 
16037 
  def validate(self):
16038 
    return
16039 
 
16040 
 
16041 
  def __repr__(self):
16042 
    L = ['%s=%r' % (key, value)
16043 
      for key, value in self.__dict__.iteritems()]
16044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16045 
 
16046 
  def __eq__(self, other):
16047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16048 
 
16049 
  def __ne__(self, other):
16050 
    return not (self == other)
16051 
 
16052 
class markOrderDoaRequestAuthorized_result:
16053 
  """
16054 
  Attributes:
16055 
   - success
16056 
   - ex
16057 
  """
16058 
 
16059 
  thrift_spec = (
16060 
    (0, TType.BOOL, 'success', None, None, ), # 0
16061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16062 
  )
16063 
 
16064 
  def __init__(self, success=None, ex=None,):
16065 
    self.success = success
16066 
    self.ex = ex
16067 
 
16068 
  def read(self, iprot):
16069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16071 
      return
16072 
    iprot.readStructBegin()
16073 
    while True:
16074 
      (fname, ftype, fid) = iprot.readFieldBegin()
16075 
      if ftype == TType.STOP:
16076 
        break
16077 
      if fid == 0:
16078 
        if ftype == TType.BOOL:
16079 
          self.success = iprot.readBool();
16080 
        else:
16081 
          iprot.skip(ftype)
16082 
      elif fid == 1:
16083 
        if ftype == TType.STRUCT:
16084 
          self.ex = TransactionServiceException()
16085 
          self.ex.read(iprot)
16086 
        else:
16087 
          iprot.skip(ftype)
16088 
      else:
16089 
        iprot.skip(ftype)
16090 
      iprot.readFieldEnd()
16091 
    iprot.readStructEnd()
16092 
 
16093 
  def write(self, oprot):
16094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16096 
      return
16097 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16098 
    if self.success is not None:
16099 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16100 
      oprot.writeBool(self.success)
16101 
      oprot.writeFieldEnd()
16102 
    if self.ex is not None:
16103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16104 
      self.ex.write(oprot)
16105 
      oprot.writeFieldEnd()
16106 
    oprot.writeFieldStop()
16107 
    oprot.writeStructEnd()
16108 
 
16109 
  def validate(self):
16110 
    return
16111 
 
16112 
 
16113 
  def __repr__(self):
16114 
    L = ['%s=%r' % (key, value)
16115 
      for key, value in self.__dict__.iteritems()]
16116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16117 
 
16118 
  def __eq__(self, other):
16119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16120 
 
16121 
  def __ne__(self, other):
16122 
    return not (self == other)
16123 
 
4488 rajveer 16124 
class markOrderReturnRequestReceived_args:
16125 
  """
16126 
  Attributes:
16127 
   - orderId
16128 
  """
16129 
 
16130 
  thrift_spec = (
16131 
    None, # 0
16132 
    (1, TType.I64, 'orderId', None, None, ), # 1
16133 
  )
16134 
 
16135 
  def __init__(self, orderId=None,):
16136 
    self.orderId = orderId
16137 
 
16138 
  def read(self, iprot):
16139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16141 
      return
16142 
    iprot.readStructBegin()
16143 
    while True:
16144 
      (fname, ftype, fid) = iprot.readFieldBegin()
16145 
      if ftype == TType.STOP:
16146 
        break
16147 
      if fid == 1:
16148 
        if ftype == TType.I64:
16149 
          self.orderId = iprot.readI64();
16150 
        else:
16151 
          iprot.skip(ftype)
16152 
      else:
16153 
        iprot.skip(ftype)
16154 
      iprot.readFieldEnd()
16155 
    iprot.readStructEnd()
16156 
 
16157 
  def write(self, oprot):
16158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16160 
      return
16161 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16162 
    if self.orderId is not None:
16163 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16164 
      oprot.writeI64(self.orderId)
16165 
      oprot.writeFieldEnd()
16166 
    oprot.writeFieldStop()
16167 
    oprot.writeStructEnd()
16168 
 
16169 
  def validate(self):
16170 
    return
16171 
 
16172 
 
16173 
  def __repr__(self):
16174 
    L = ['%s=%r' % (key, value)
16175 
      for key, value in self.__dict__.iteritems()]
16176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16177 
 
16178 
  def __eq__(self, other):
16179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16180 
 
16181 
  def __ne__(self, other):
16182 
    return not (self == other)
16183 
 
16184 
class markOrderReturnRequestReceived_result:
16185 
  """
16186 
  Attributes:
16187 
   - success
16188 
   - ex
16189 
  """
16190 
 
16191 
  thrift_spec = (
16192 
    (0, TType.BOOL, 'success', None, None, ), # 0
16193 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16194 
  )
16195 
 
16196 
  def __init__(self, success=None, ex=None,):
16197 
    self.success = success
16198 
    self.ex = ex
16199 
 
16200 
  def read(self, iprot):
16201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16203 
      return
16204 
    iprot.readStructBegin()
16205 
    while True:
16206 
      (fname, ftype, fid) = iprot.readFieldBegin()
16207 
      if ftype == TType.STOP:
16208 
        break
16209 
      if fid == 0:
16210 
        if ftype == TType.BOOL:
16211 
          self.success = iprot.readBool();
16212 
        else:
16213 
          iprot.skip(ftype)
16214 
      elif fid == 1:
16215 
        if ftype == TType.STRUCT:
16216 
          self.ex = TransactionServiceException()
16217 
          self.ex.read(iprot)
16218 
        else:
16219 
          iprot.skip(ftype)
16220 
      else:
16221 
        iprot.skip(ftype)
16222 
      iprot.readFieldEnd()
16223 
    iprot.readStructEnd()
16224 
 
16225 
  def write(self, oprot):
16226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16228 
      return
16229 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16230 
    if self.success is not None:
16231 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16232 
      oprot.writeBool(self.success)
16233 
      oprot.writeFieldEnd()
16234 
    if self.ex is not None:
16235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16236 
      self.ex.write(oprot)
16237 
      oprot.writeFieldEnd()
16238 
    oprot.writeFieldStop()
16239 
    oprot.writeStructEnd()
16240 
 
16241 
  def validate(self):
16242 
    return
16243 
 
16244 
 
16245 
  def __repr__(self):
16246 
    L = ['%s=%r' % (key, value)
16247 
      for key, value in self.__dict__.iteritems()]
16248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16249 
 
16250 
  def __eq__(self, other):
16251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16252 
 
16253 
  def __ne__(self, other):
16254 
    return not (self == other)
16255 
 
16256 
class markOrderReturnRequestAuthorized_args:
16257 
  """
16258 
  Attributes:
16259 
   - orderId
16260 
   - isAuthorized
16261 
  """
16262 
 
16263 
  thrift_spec = (
16264 
    None, # 0
16265 
    (1, TType.I64, 'orderId', None, None, ), # 1
16266 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16267 
  )
16268 
 
16269 
  def __init__(self, orderId=None, isAuthorized=None,):
16270 
    self.orderId = orderId
16271 
    self.isAuthorized = isAuthorized
16272 
 
16273 
  def read(self, iprot):
16274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16276 
      return
16277 
    iprot.readStructBegin()
16278 
    while True:
16279 
      (fname, ftype, fid) = iprot.readFieldBegin()
16280 
      if ftype == TType.STOP:
16281 
        break
16282 
      if fid == 1:
16283 
        if ftype == TType.I64:
16284 
          self.orderId = iprot.readI64();
16285 
        else:
16286 
          iprot.skip(ftype)
16287 
      elif fid == 2:
16288 
        if ftype == TType.BOOL:
16289 
          self.isAuthorized = iprot.readBool();
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
16301 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16302 
    if self.orderId is not None:
16303 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16304 
      oprot.writeI64(self.orderId)
16305 
      oprot.writeFieldEnd()
16306 
    if self.isAuthorized is not None:
16307 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16308 
      oprot.writeBool(self.isAuthorized)
16309 
      oprot.writeFieldEnd()
16310 
    oprot.writeFieldStop()
16311 
    oprot.writeStructEnd()
16312 
 
16313 
  def validate(self):
16314 
    return
16315 
 
16316 
 
16317 
  def __repr__(self):
16318 
    L = ['%s=%r' % (key, value)
16319 
      for key, value in self.__dict__.iteritems()]
16320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16321 
 
16322 
  def __eq__(self, other):
16323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16324 
 
16325 
  def __ne__(self, other):
16326 
    return not (self == other)
16327 
 
16328 
class markOrderReturnRequestAuthorized_result:
16329 
  """
16330 
  Attributes:
16331 
   - success
16332 
   - ex
16333 
  """
16334 
 
16335 
  thrift_spec = (
16336 
    (0, TType.BOOL, 'success', None, None, ), # 0
16337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16338 
  )
16339 
 
16340 
  def __init__(self, success=None, ex=None,):
16341 
    self.success = success
16342 
    self.ex = ex
16343 
 
16344 
  def read(self, iprot):
16345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16347 
      return
16348 
    iprot.readStructBegin()
16349 
    while True:
16350 
      (fname, ftype, fid) = iprot.readFieldBegin()
16351 
      if ftype == TType.STOP:
16352 
        break
16353 
      if fid == 0:
16354 
        if ftype == TType.BOOL:
16355 
          self.success = iprot.readBool();
16356 
        else:
16357 
          iprot.skip(ftype)
16358 
      elif fid == 1:
16359 
        if ftype == TType.STRUCT:
16360 
          self.ex = TransactionServiceException()
16361 
          self.ex.read(iprot)
16362 
        else:
16363 
          iprot.skip(ftype)
16364 
      else:
16365 
        iprot.skip(ftype)
16366 
      iprot.readFieldEnd()
16367 
    iprot.readStructEnd()
16368 
 
16369 
  def write(self, oprot):
16370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16372 
      return
16373 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16374 
    if self.success is not None:
16375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16376 
      oprot.writeBool(self.success)
16377 
      oprot.writeFieldEnd()
16378 
    if self.ex is not None:
16379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16380 
      self.ex.write(oprot)
16381 
      oprot.writeFieldEnd()
16382 
    oprot.writeFieldStop()
16383 
    oprot.writeStructEnd()
16384 
 
16385 
  def validate(self):
16386 
    return
16387 
 
16388 
 
16389 
  def __repr__(self):
16390 
    L = ['%s=%r' % (key, value)
16391 
      for key, value in self.__dict__.iteritems()]
16392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16393 
 
16394 
  def __eq__(self, other):
16395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16396 
 
16397 
  def __ne__(self, other):
16398 
    return not (self == other)
16399 
 
2536 chandransh 16400 
class requestPickupNumber_args:
16401 
  """
16402 
  Attributes:
16403 
   - orderId
4579 rajveer 16404 
   - providerId
2536 chandransh 16405 
  """
16406 
 
16407 
  thrift_spec = (
16408 
    None, # 0
16409 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16410 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16411 
  )
16412 
 
4579 rajveer 16413 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16414 
    self.orderId = orderId
4579 rajveer 16415 
    self.providerId = providerId
2536 chandransh 16416 
 
16417 
  def read(self, iprot):
16418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16420 
      return
16421 
    iprot.readStructBegin()
16422 
    while True:
16423 
      (fname, ftype, fid) = iprot.readFieldBegin()
16424 
      if ftype == TType.STOP:
16425 
        break
16426 
      if fid == 1:
16427 
        if ftype == TType.I64:
16428 
          self.orderId = iprot.readI64();
16429 
        else:
16430 
          iprot.skip(ftype)
4579 rajveer 16431 
      elif fid == 2:
16432 
        if ftype == TType.I64:
16433 
          self.providerId = iprot.readI64();
16434 
        else:
16435 
          iprot.skip(ftype)
2536 chandransh 16436 
      else:
16437 
        iprot.skip(ftype)
16438 
      iprot.readFieldEnd()
16439 
    iprot.readStructEnd()
16440 
 
16441 
  def write(self, oprot):
16442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16444 
      return
16445 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16446 
    if self.orderId is not None:
2536 chandransh 16447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16448 
      oprot.writeI64(self.orderId)
16449 
      oprot.writeFieldEnd()
4579 rajveer 16450 
    if self.providerId is not None:
16451 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16452 
      oprot.writeI64(self.providerId)
16453 
      oprot.writeFieldEnd()
2536 chandransh 16454 
    oprot.writeFieldStop()
16455 
    oprot.writeStructEnd()
16456 
 
3431 rajveer 16457 
  def validate(self):
16458 
    return
16459 
 
16460 
 
2536 chandransh 16461 
  def __repr__(self):
16462 
    L = ['%s=%r' % (key, value)
16463 
      for key, value in self.__dict__.iteritems()]
16464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16465 
 
16466 
  def __eq__(self, other):
16467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16468 
 
16469 
  def __ne__(self, other):
16470 
    return not (self == other)
16471 
 
16472 
class requestPickupNumber_result:
16473 
  """
16474 
  Attributes:
16475 
   - success
16476 
   - ex
16477 
  """
16478 
 
16479 
  thrift_spec = (
16480 
    (0, TType.BOOL, 'success', None, None, ), # 0
16481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16482 
  )
16483 
 
16484 
  def __init__(self, success=None, ex=None,):
16485 
    self.success = success
16486 
    self.ex = ex
16487 
 
16488 
  def read(self, iprot):
16489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16491 
      return
16492 
    iprot.readStructBegin()
16493 
    while True:
16494 
      (fname, ftype, fid) = iprot.readFieldBegin()
16495 
      if ftype == TType.STOP:
16496 
        break
16497 
      if fid == 0:
16498 
        if ftype == TType.BOOL:
16499 
          self.success = iprot.readBool();
16500 
        else:
16501 
          iprot.skip(ftype)
16502 
      elif fid == 1:
16503 
        if ftype == TType.STRUCT:
16504 
          self.ex = TransactionServiceException()
16505 
          self.ex.read(iprot)
16506 
        else:
16507 
          iprot.skip(ftype)
16508 
      else:
16509 
        iprot.skip(ftype)
16510 
      iprot.readFieldEnd()
16511 
    iprot.readStructEnd()
16512 
 
16513 
  def write(self, oprot):
16514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16516 
      return
16517 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16518 
    if self.success is not None:
2536 chandransh 16519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16520 
      oprot.writeBool(self.success)
16521 
      oprot.writeFieldEnd()
3431 rajveer 16522 
    if self.ex is not None:
2536 chandransh 16523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16524 
      self.ex.write(oprot)
16525 
      oprot.writeFieldEnd()
16526 
    oprot.writeFieldStop()
16527 
    oprot.writeStructEnd()
16528 
 
3431 rajveer 16529 
  def validate(self):
16530 
    return
16531 
 
16532 
 
2536 chandransh 16533 
  def __repr__(self):
16534 
    L = ['%s=%r' % (key, value)
16535 
      for key, value in self.__dict__.iteritems()]
16536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16537 
 
16538 
  def __eq__(self, other):
16539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16540 
 
16541 
  def __ne__(self, other):
16542 
    return not (self == other)
16543 
 
16544 
class authorizePickup_args:
16545 
  """
16546 
  Attributes:
16547 
   - orderId
16548 
   - pickupNumber
4602 rajveer 16549 
   - providerId
2536 chandransh 16550 
  """
16551 
 
16552 
  thrift_spec = (
16553 
    None, # 0
16554 
    (1, TType.I64, 'orderId', None, None, ), # 1
16555 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16556 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16557 
  )
16558 
 
4602 rajveer 16559 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16560 
    self.orderId = orderId
16561 
    self.pickupNumber = pickupNumber
4602 rajveer 16562 
    self.providerId = providerId
2536 chandransh 16563 
 
16564 
  def read(self, iprot):
16565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16567 
      return
16568 
    iprot.readStructBegin()
16569 
    while True:
16570 
      (fname, ftype, fid) = iprot.readFieldBegin()
16571 
      if ftype == TType.STOP:
16572 
        break
16573 
      if fid == 1:
16574 
        if ftype == TType.I64:
16575 
          self.orderId = iprot.readI64();
16576 
        else:
16577 
          iprot.skip(ftype)
16578 
      elif fid == 2:
16579 
        if ftype == TType.STRING:
16580 
          self.pickupNumber = iprot.readString();
16581 
        else:
16582 
          iprot.skip(ftype)
4602 rajveer 16583 
      elif fid == 3:
16584 
        if ftype == TType.I64:
16585 
          self.providerId = iprot.readI64();
16586 
        else:
16587 
          iprot.skip(ftype)
2536 chandransh 16588 
      else:
16589 
        iprot.skip(ftype)
16590 
      iprot.readFieldEnd()
16591 
    iprot.readStructEnd()
16592 
 
16593 
  def write(self, oprot):
16594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16596 
      return
16597 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16598 
    if self.orderId is not None:
2536 chandransh 16599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16600 
      oprot.writeI64(self.orderId)
16601 
      oprot.writeFieldEnd()
3431 rajveer 16602 
    if self.pickupNumber is not None:
2536 chandransh 16603 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16604 
      oprot.writeString(self.pickupNumber)
16605 
      oprot.writeFieldEnd()
4602 rajveer 16606 
    if self.providerId is not None:
16607 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16608 
      oprot.writeI64(self.providerId)
16609 
      oprot.writeFieldEnd()
2536 chandransh 16610 
    oprot.writeFieldStop()
16611 
    oprot.writeStructEnd()
16612 
 
3431 rajveer 16613 
  def validate(self):
16614 
    return
16615 
 
16616 
 
2536 chandransh 16617 
  def __repr__(self):
16618 
    L = ['%s=%r' % (key, value)
16619 
      for key, value in self.__dict__.iteritems()]
16620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16621 
 
16622 
  def __eq__(self, other):
16623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16624 
 
16625 
  def __ne__(self, other):
16626 
    return not (self == other)
16627 
 
16628 
class authorizePickup_result:
16629 
  """
16630 
  Attributes:
16631 
   - success
16632 
   - ex
16633 
  """
16634 
 
16635 
  thrift_spec = (
16636 
    (0, TType.BOOL, 'success', None, None, ), # 0
16637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16638 
  )
16639 
 
16640 
  def __init__(self, success=None, ex=None,):
16641 
    self.success = success
16642 
    self.ex = ex
16643 
 
16644 
  def read(self, iprot):
16645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16647 
      return
16648 
    iprot.readStructBegin()
16649 
    while True:
16650 
      (fname, ftype, fid) = iprot.readFieldBegin()
16651 
      if ftype == TType.STOP:
16652 
        break
16653 
      if fid == 0:
16654 
        if ftype == TType.BOOL:
16655 
          self.success = iprot.readBool();
16656 
        else:
16657 
          iprot.skip(ftype)
16658 
      elif fid == 1:
16659 
        if ftype == TType.STRUCT:
16660 
          self.ex = TransactionServiceException()
16661 
          self.ex.read(iprot)
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      else:
16665 
        iprot.skip(ftype)
16666 
      iprot.readFieldEnd()
16667 
    iprot.readStructEnd()
16668 
 
16669 
  def write(self, oprot):
16670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16672 
      return
16673 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16674 
    if self.success is not None:
2536 chandransh 16675 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16676 
      oprot.writeBool(self.success)
16677 
      oprot.writeFieldEnd()
3431 rajveer 16678 
    if self.ex is not None:
2536 chandransh 16679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16680 
      self.ex.write(oprot)
16681 
      oprot.writeFieldEnd()
16682 
    oprot.writeFieldStop()
16683 
    oprot.writeStructEnd()
16684 
 
3431 rajveer 16685 
  def validate(self):
16686 
    return
16687 
 
16688 
 
2536 chandransh 16689 
  def __repr__(self):
16690 
    L = ['%s=%r' % (key, value)
16691 
      for key, value in self.__dict__.iteritems()]
16692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16693 
 
16694 
  def __eq__(self, other):
16695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16696 
 
16697 
  def __ne__(self, other):
16698 
    return not (self == other)
16699 
 
2764 chandransh 16700 
class markDoasAsPickedUp_args:
16701 
  """
16702 
  Attributes:
16703 
   - providerId
16704 
   - pickupDetails
16705 
  """
16706 
 
16707 
  thrift_spec = (
16708 
    None, # 0
16709 
    (1, TType.I64, 'providerId', None, None, ), # 1
16710 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16711 
  )
16712 
 
16713 
  def __init__(self, providerId=None, pickupDetails=None,):
16714 
    self.providerId = providerId
16715 
    self.pickupDetails = pickupDetails
16716 
 
16717 
  def read(self, iprot):
16718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16720 
      return
16721 
    iprot.readStructBegin()
16722 
    while True:
16723 
      (fname, ftype, fid) = iprot.readFieldBegin()
16724 
      if ftype == TType.STOP:
16725 
        break
16726 
      if fid == 1:
16727 
        if ftype == TType.I64:
16728 
          self.providerId = iprot.readI64();
16729 
        else:
16730 
          iprot.skip(ftype)
16731 
      elif fid == 2:
16732 
        if ftype == TType.MAP:
16733 
          self.pickupDetails = {}
6031 rajveer 16734 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16735 
          for _i368 in xrange(_size364):
16736 
            _key369 = iprot.readString();
16737 
            _val370 = iprot.readString();
16738 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16739 
          iprot.readMapEnd()
16740 
        else:
16741 
          iprot.skip(ftype)
16742 
      else:
16743 
        iprot.skip(ftype)
16744 
      iprot.readFieldEnd()
16745 
    iprot.readStructEnd()
16746 
 
16747 
  def write(self, oprot):
16748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16750 
      return
16751 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16752 
    if self.providerId is not None:
2764 chandransh 16753 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16754 
      oprot.writeI64(self.providerId)
16755 
      oprot.writeFieldEnd()
3431 rajveer 16756 
    if self.pickupDetails is not None:
2764 chandransh 16757 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16758 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16759 
      for kiter371,viter372 in self.pickupDetails.items():
16760 
        oprot.writeString(kiter371)
16761 
        oprot.writeString(viter372)
2764 chandransh 16762 
      oprot.writeMapEnd()
16763 
      oprot.writeFieldEnd()
16764 
    oprot.writeFieldStop()
16765 
    oprot.writeStructEnd()
16766 
 
3431 rajveer 16767 
  def validate(self):
16768 
    return
16769 
 
16770 
 
2764 chandransh 16771 
  def __repr__(self):
16772 
    L = ['%s=%r' % (key, value)
16773 
      for key, value in self.__dict__.iteritems()]
16774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16775 
 
16776 
  def __eq__(self, other):
16777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16778 
 
16779 
  def __ne__(self, other):
16780 
    return not (self == other)
16781 
 
16782 
class markDoasAsPickedUp_result:
4910 phani.kuma 16783 
 
16784 
  thrift_spec = (
16785 
  )
16786 
 
16787 
  def read(self, iprot):
16788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16790 
      return
16791 
    iprot.readStructBegin()
16792 
    while True:
16793 
      (fname, ftype, fid) = iprot.readFieldBegin()
16794 
      if ftype == TType.STOP:
16795 
        break
16796 
      else:
16797 
        iprot.skip(ftype)
16798 
      iprot.readFieldEnd()
16799 
    iprot.readStructEnd()
16800 
 
16801 
  def write(self, oprot):
16802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16804 
      return
16805 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16806 
    oprot.writeFieldStop()
16807 
    oprot.writeStructEnd()
16808 
 
16809 
  def validate(self):
16810 
    return
16811 
 
16812 
 
16813 
  def __repr__(self):
16814 
    L = ['%s=%r' % (key, value)
16815 
      for key, value in self.__dict__.iteritems()]
16816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16817 
 
16818 
  def __eq__(self, other):
16819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16820 
 
16821 
  def __ne__(self, other):
16822 
    return not (self == other)
16823 
 
16824 
class getDoasNotPickedUp_args:
2764 chandransh 16825 
  """
16826 
  Attributes:
4910 phani.kuma 16827 
   - providerId
16828 
  """
16829 
 
16830 
  thrift_spec = (
16831 
    None, # 0
16832 
    (1, TType.I64, 'providerId', None, None, ), # 1
16833 
  )
16834 
 
16835 
  def __init__(self, providerId=None,):
16836 
    self.providerId = providerId
16837 
 
16838 
  def read(self, iprot):
16839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16841 
      return
16842 
    iprot.readStructBegin()
16843 
    while True:
16844 
      (fname, ftype, fid) = iprot.readFieldBegin()
16845 
      if ftype == TType.STOP:
16846 
        break
16847 
      if fid == 1:
16848 
        if ftype == TType.I64:
16849 
          self.providerId = iprot.readI64();
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      else:
16853 
        iprot.skip(ftype)
16854 
      iprot.readFieldEnd()
16855 
    iprot.readStructEnd()
16856 
 
16857 
  def write(self, oprot):
16858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16860 
      return
16861 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16862 
    if self.providerId is not None:
16863 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16864 
      oprot.writeI64(self.providerId)
16865 
      oprot.writeFieldEnd()
16866 
    oprot.writeFieldStop()
16867 
    oprot.writeStructEnd()
16868 
 
16869 
  def validate(self):
16870 
    return
16871 
 
16872 
 
16873 
  def __repr__(self):
16874 
    L = ['%s=%r' % (key, value)
16875 
      for key, value in self.__dict__.iteritems()]
16876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16877 
 
16878 
  def __eq__(self, other):
16879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16880 
 
16881 
  def __ne__(self, other):
16882 
    return not (self == other)
16883 
 
16884 
class getDoasNotPickedUp_result:
16885 
  """
16886 
  Attributes:
2764 chandransh 16887 
   - success
16888 
  """
16889 
 
16890 
  thrift_spec = (
16891 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16892 
  )
16893 
 
16894 
  def __init__(self, success=None,):
16895 
    self.success = success
16896 
 
16897 
  def read(self, iprot):
16898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16900 
      return
16901 
    iprot.readStructBegin()
16902 
    while True:
16903 
      (fname, ftype, fid) = iprot.readFieldBegin()
16904 
      if ftype == TType.STOP:
16905 
        break
16906 
      if fid == 0:
16907 
        if ftype == TType.LIST:
16908 
          self.success = []
6031 rajveer 16909 
          (_etype376, _size373) = iprot.readListBegin()
16910 
          for _i377 in xrange(_size373):
16911 
            _elem378 = Order()
16912 
            _elem378.read(iprot)
16913 
            self.success.append(_elem378)
2764 chandransh 16914 
          iprot.readListEnd()
16915 
        else:
16916 
          iprot.skip(ftype)
16917 
      else:
16918 
        iprot.skip(ftype)
16919 
      iprot.readFieldEnd()
16920 
    iprot.readStructEnd()
16921 
 
16922 
  def write(self, oprot):
16923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16925 
      return
4910 phani.kuma 16926 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16927 
    if self.success is not None:
2764 chandransh 16928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 16930 
      for iter379 in self.success:
16931 
        iter379.write(oprot)
2764 chandransh 16932 
      oprot.writeListEnd()
16933 
      oprot.writeFieldEnd()
16934 
    oprot.writeFieldStop()
16935 
    oprot.writeStructEnd()
16936 
 
3431 rajveer 16937 
  def validate(self):
16938 
    return
16939 
 
16940 
 
2764 chandransh 16941 
  def __repr__(self):
16942 
    L = ['%s=%r' % (key, value)
16943 
      for key, value in self.__dict__.iteritems()]
16944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16945 
 
16946 
  def __eq__(self, other):
16947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16948 
 
16949 
  def __ne__(self, other):
16950 
    return not (self == other)
16951 
 
4741 phani.kuma 16952 
class markReturnOrdersAsPickedUp_args:
16953 
  """
16954 
  Attributes:
16955 
   - providerId
16956 
   - pickupDetails
16957 
  """
16958 
 
16959 
  thrift_spec = (
16960 
    None, # 0
16961 
    (1, TType.I64, 'providerId', None, None, ), # 1
16962 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16963 
  )
16964 
 
16965 
  def __init__(self, providerId=None, pickupDetails=None,):
16966 
    self.providerId = providerId
16967 
    self.pickupDetails = pickupDetails
16968 
 
16969 
  def read(self, iprot):
16970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16972 
      return
16973 
    iprot.readStructBegin()
16974 
    while True:
16975 
      (fname, ftype, fid) = iprot.readFieldBegin()
16976 
      if ftype == TType.STOP:
16977 
        break
16978 
      if fid == 1:
16979 
        if ftype == TType.I64:
16980 
          self.providerId = iprot.readI64();
16981 
        else:
16982 
          iprot.skip(ftype)
16983 
      elif fid == 2:
16984 
        if ftype == TType.MAP:
16985 
          self.pickupDetails = {}
6031 rajveer 16986 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16987 
          for _i384 in xrange(_size380):
16988 
            _key385 = iprot.readString();
16989 
            _val386 = iprot.readString();
16990 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16991 
          iprot.readMapEnd()
16992 
        else:
16993 
          iprot.skip(ftype)
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17004 
    if self.providerId is not None:
17005 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17006 
      oprot.writeI64(self.providerId)
17007 
      oprot.writeFieldEnd()
17008 
    if self.pickupDetails is not None:
17009 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17010 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17011 
      for kiter387,viter388 in self.pickupDetails.items():
17012 
        oprot.writeString(kiter387)
17013 
        oprot.writeString(viter388)
4741 phani.kuma 17014 
      oprot.writeMapEnd()
17015 
      oprot.writeFieldEnd()
17016 
    oprot.writeFieldStop()
17017 
    oprot.writeStructEnd()
17018 
 
17019 
  def validate(self):
17020 
    return
17021 
 
17022 
 
17023 
  def __repr__(self):
17024 
    L = ['%s=%r' % (key, value)
17025 
      for key, value in self.__dict__.iteritems()]
17026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17027 
 
17028 
  def __eq__(self, other):
17029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17030 
 
17031 
  def __ne__(self, other):
17032 
    return not (self == other)
17033 
 
17034 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17035 
 
17036 
  thrift_spec = (
17037 
  )
17038 
 
17039 
  def read(self, iprot):
17040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17042 
      return
17043 
    iprot.readStructBegin()
17044 
    while True:
17045 
      (fname, ftype, fid) = iprot.readFieldBegin()
17046 
      if ftype == TType.STOP:
17047 
        break
17048 
      else:
17049 
        iprot.skip(ftype)
17050 
      iprot.readFieldEnd()
17051 
    iprot.readStructEnd()
17052 
 
17053 
  def write(self, oprot):
17054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17056 
      return
17057 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
17076 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17077 
  """
17078 
  Attributes:
4910 phani.kuma 17079 
   - providerId
17080 
  """
17081 
 
17082 
  thrift_spec = (
17083 
    None, # 0
17084 
    (1, TType.I64, 'providerId', None, None, ), # 1
17085 
  )
17086 
 
17087 
  def __init__(self, providerId=None,):
17088 
    self.providerId = providerId
17089 
 
17090 
  def read(self, iprot):
17091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17093 
      return
17094 
    iprot.readStructBegin()
17095 
    while True:
17096 
      (fname, ftype, fid) = iprot.readFieldBegin()
17097 
      if ftype == TType.STOP:
17098 
        break
17099 
      if fid == 1:
17100 
        if ftype == TType.I64:
17101 
          self.providerId = iprot.readI64();
17102 
        else:
17103 
          iprot.skip(ftype)
17104 
      else:
17105 
        iprot.skip(ftype)
17106 
      iprot.readFieldEnd()
17107 
    iprot.readStructEnd()
17108 
 
17109 
  def write(self, oprot):
17110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17112 
      return
17113 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17114 
    if self.providerId is not None:
17115 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17116 
      oprot.writeI64(self.providerId)
17117 
      oprot.writeFieldEnd()
17118 
    oprot.writeFieldStop()
17119 
    oprot.writeStructEnd()
17120 
 
17121 
  def validate(self):
17122 
    return
17123 
 
17124 
 
17125 
  def __repr__(self):
17126 
    L = ['%s=%r' % (key, value)
17127 
      for key, value in self.__dict__.iteritems()]
17128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17129 
 
17130 
  def __eq__(self, other):
17131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17132 
 
17133 
  def __ne__(self, other):
17134 
    return not (self == other)
17135 
 
17136 
class getReturnOrdersNotPickedUp_result:
17137 
  """
17138 
  Attributes:
4741 phani.kuma 17139 
   - success
17140 
  """
17141 
 
17142 
  thrift_spec = (
17143 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17144 
  )
17145 
 
17146 
  def __init__(self, success=None,):
17147 
    self.success = success
17148 
 
17149 
  def read(self, iprot):
17150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17152 
      return
17153 
    iprot.readStructBegin()
17154 
    while True:
17155 
      (fname, ftype, fid) = iprot.readFieldBegin()
17156 
      if ftype == TType.STOP:
17157 
        break
17158 
      if fid == 0:
17159 
        if ftype == TType.LIST:
17160 
          self.success = []
6031 rajveer 17161 
          (_etype392, _size389) = iprot.readListBegin()
17162 
          for _i393 in xrange(_size389):
17163 
            _elem394 = Order()
17164 
            _elem394.read(iprot)
17165 
            self.success.append(_elem394)
4741 phani.kuma 17166 
          iprot.readListEnd()
17167 
        else:
17168 
          iprot.skip(ftype)
17169 
      else:
17170 
        iprot.skip(ftype)
17171 
      iprot.readFieldEnd()
17172 
    iprot.readStructEnd()
17173 
 
17174 
  def write(self, oprot):
17175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17177 
      return
4910 phani.kuma 17178 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17179 
    if self.success is not None:
17180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17182 
      for iter395 in self.success:
17183 
        iter395.write(oprot)
4741 phani.kuma 17184 
      oprot.writeListEnd()
17185 
      oprot.writeFieldEnd()
17186 
    oprot.writeFieldStop()
17187 
    oprot.writeStructEnd()
17188 
 
17189 
  def validate(self):
17190 
    return
17191 
 
17192 
 
17193 
  def __repr__(self):
17194 
    L = ['%s=%r' % (key, value)
17195 
      for key, value in self.__dict__.iteritems()]
17196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17197 
 
17198 
  def __eq__(self, other):
17199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17200 
 
17201 
  def __ne__(self, other):
17202 
    return not (self == other)
17203 
 
2616 chandransh 17204 
class receiveReturn_args:
2591 chandransh 17205 
  """
17206 
  Attributes:
17207 
   - orderId
4479 rajveer 17208 
   - receiveCondition
2591 chandransh 17209 
  """
2536 chandransh 17210 
 
2591 chandransh 17211 
  thrift_spec = (
17212 
    None, # 0
17213 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17214 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17215 
  )
17216 
 
4479 rajveer 17217 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17218 
    self.orderId = orderId
4479 rajveer 17219 
    self.receiveCondition = receiveCondition
2591 chandransh 17220 
 
17221 
  def read(self, iprot):
17222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17224 
      return
17225 
    iprot.readStructBegin()
17226 
    while True:
17227 
      (fname, ftype, fid) = iprot.readFieldBegin()
17228 
      if ftype == TType.STOP:
17229 
        break
17230 
      if fid == 1:
17231 
        if ftype == TType.I64:
17232 
          self.orderId = iprot.readI64();
17233 
        else:
17234 
          iprot.skip(ftype)
4479 rajveer 17235 
      elif fid == 2:
17236 
        if ftype == TType.I64:
17237 
          self.receiveCondition = iprot.readI64();
17238 
        else:
17239 
          iprot.skip(ftype)
2591 chandransh 17240 
      else:
17241 
        iprot.skip(ftype)
17242 
      iprot.readFieldEnd()
17243 
    iprot.readStructEnd()
17244 
 
17245 
  def write(self, oprot):
17246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17248 
      return
2616 chandransh 17249 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17250 
    if self.orderId is not None:
2591 chandransh 17251 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17252 
      oprot.writeI64(self.orderId)
17253 
      oprot.writeFieldEnd()
4479 rajveer 17254 
    if self.receiveCondition is not None:
17255 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17256 
      oprot.writeI64(self.receiveCondition)
17257 
      oprot.writeFieldEnd()
2591 chandransh 17258 
    oprot.writeFieldStop()
17259 
    oprot.writeStructEnd()
17260 
 
3431 rajveer 17261 
  def validate(self):
17262 
    return
17263 
 
17264 
 
2591 chandransh 17265 
  def __repr__(self):
17266 
    L = ['%s=%r' % (key, value)
17267 
      for key, value in self.__dict__.iteritems()]
17268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17269 
 
17270 
  def __eq__(self, other):
17271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17272 
 
17273 
  def __ne__(self, other):
17274 
    return not (self == other)
17275 
 
2616 chandransh 17276 
class receiveReturn_result:
2591 chandransh 17277 
  """
17278 
  Attributes:
17279 
   - success
17280 
   - ex
17281 
  """
17282 
 
17283 
  thrift_spec = (
17284 
    (0, TType.BOOL, 'success', None, None, ), # 0
17285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17286 
  )
17287 
 
17288 
  def __init__(self, success=None, ex=None,):
17289 
    self.success = success
17290 
    self.ex = ex
17291 
 
17292 
  def read(self, iprot):
17293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17295 
      return
17296 
    iprot.readStructBegin()
17297 
    while True:
17298 
      (fname, ftype, fid) = iprot.readFieldBegin()
17299 
      if ftype == TType.STOP:
17300 
        break
17301 
      if fid == 0:
17302 
        if ftype == TType.BOOL:
17303 
          self.success = iprot.readBool();
17304 
        else:
17305 
          iprot.skip(ftype)
17306 
      elif fid == 1:
17307 
        if ftype == TType.STRUCT:
17308 
          self.ex = TransactionServiceException()
17309 
          self.ex.read(iprot)
17310 
        else:
17311 
          iprot.skip(ftype)
17312 
      else:
17313 
        iprot.skip(ftype)
17314 
      iprot.readFieldEnd()
17315 
    iprot.readStructEnd()
17316 
 
17317 
  def write(self, oprot):
17318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17320 
      return
2616 chandransh 17321 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17322 
    if self.success is not None:
2591 chandransh 17323 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17324 
      oprot.writeBool(self.success)
17325 
      oprot.writeFieldEnd()
3431 rajveer 17326 
    if self.ex is not None:
2591 chandransh 17327 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17328 
      self.ex.write(oprot)
17329 
      oprot.writeFieldEnd()
17330 
    oprot.writeFieldStop()
17331 
    oprot.writeStructEnd()
17332 
 
3431 rajveer 17333 
  def validate(self):
17334 
    return
17335 
 
17336 
 
2591 chandransh 17337 
  def __repr__(self):
17338 
    L = ['%s=%r' % (key, value)
17339 
      for key, value in self.__dict__.iteritems()]
17340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17341 
 
17342 
  def __eq__(self, other):
17343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17344 
 
17345 
  def __ne__(self, other):
17346 
    return not (self == other)
17347 
 
17348 
class validateDoa_args:
17349 
  """
17350 
  Attributes:
17351 
   - orderId
17352 
   - isValid
17353 
  """
17354 
 
17355 
  thrift_spec = (
17356 
    None, # 0
17357 
    (1, TType.I64, 'orderId', None, None, ), # 1
17358 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17359 
  )
17360 
 
17361 
  def __init__(self, orderId=None, isValid=None,):
17362 
    self.orderId = orderId
17363 
    self.isValid = isValid
17364 
 
17365 
  def read(self, iprot):
17366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17368 
      return
17369 
    iprot.readStructBegin()
17370 
    while True:
17371 
      (fname, ftype, fid) = iprot.readFieldBegin()
17372 
      if ftype == TType.STOP:
17373 
        break
17374 
      if fid == 1:
17375 
        if ftype == TType.I64:
17376 
          self.orderId = iprot.readI64();
17377 
        else:
17378 
          iprot.skip(ftype)
17379 
      elif fid == 2:
17380 
        if ftype == TType.BOOL:
17381 
          self.isValid = iprot.readBool();
17382 
        else:
17383 
          iprot.skip(ftype)
17384 
      else:
17385 
        iprot.skip(ftype)
17386 
      iprot.readFieldEnd()
17387 
    iprot.readStructEnd()
17388 
 
17389 
  def write(self, oprot):
17390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17392 
      return
17393 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17394 
    if self.orderId is not None:
2591 chandransh 17395 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17396 
      oprot.writeI64(self.orderId)
17397 
      oprot.writeFieldEnd()
3431 rajveer 17398 
    if self.isValid is not None:
2591 chandransh 17399 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17400 
      oprot.writeBool(self.isValid)
17401 
      oprot.writeFieldEnd()
17402 
    oprot.writeFieldStop()
17403 
    oprot.writeStructEnd()
17404 
 
3431 rajveer 17405 
  def validate(self):
17406 
    return
17407 
 
17408 
 
2591 chandransh 17409 
  def __repr__(self):
17410 
    L = ['%s=%r' % (key, value)
17411 
      for key, value in self.__dict__.iteritems()]
17412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17413 
 
17414 
  def __eq__(self, other):
17415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17416 
 
17417 
  def __ne__(self, other):
17418 
    return not (self == other)
17419 
 
17420 
class validateDoa_result:
17421 
  """
17422 
  Attributes:
17423 
   - success
17424 
   - ex
17425 
  """
17426 
 
17427 
  thrift_spec = (
17428 
    (0, TType.BOOL, 'success', None, None, ), # 0
17429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17430 
  )
17431 
 
17432 
  def __init__(self, success=None, ex=None,):
17433 
    self.success = success
17434 
    self.ex = ex
17435 
 
17436 
  def read(self, iprot):
17437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17439 
      return
17440 
    iprot.readStructBegin()
17441 
    while True:
17442 
      (fname, ftype, fid) = iprot.readFieldBegin()
17443 
      if ftype == TType.STOP:
17444 
        break
17445 
      if fid == 0:
17446 
        if ftype == TType.BOOL:
17447 
          self.success = iprot.readBool();
17448 
        else:
17449 
          iprot.skip(ftype)
17450 
      elif fid == 1:
17451 
        if ftype == TType.STRUCT:
17452 
          self.ex = TransactionServiceException()
17453 
          self.ex.read(iprot)
17454 
        else:
17455 
          iprot.skip(ftype)
17456 
      else:
17457 
        iprot.skip(ftype)
17458 
      iprot.readFieldEnd()
17459 
    iprot.readStructEnd()
17460 
 
17461 
  def write(self, oprot):
17462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17464 
      return
17465 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17466 
    if self.success is not None:
2591 chandransh 17467 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17468 
      oprot.writeBool(self.success)
17469 
      oprot.writeFieldEnd()
3431 rajveer 17470 
    if self.ex is not None:
2591 chandransh 17471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17472 
      self.ex.write(oprot)
17473 
      oprot.writeFieldEnd()
17474 
    oprot.writeFieldStop()
17475 
    oprot.writeStructEnd()
17476 
 
3431 rajveer 17477 
  def validate(self):
17478 
    return
17479 
 
17480 
 
2591 chandransh 17481 
  def __repr__(self):
17482 
    L = ['%s=%r' % (key, value)
17483 
      for key, value in self.__dict__.iteritems()]
17484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17485 
 
17486 
  def __eq__(self, other):
17487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17488 
 
17489 
  def __ne__(self, other):
17490 
    return not (self == other)
17491 
 
4495 rajveer 17492 
class validateReturnProduct_args:
17493 
  """
17494 
  Attributes:
17495 
   - orderId
17496 
   - isUsable
17497 
  """
17498 
 
17499 
  thrift_spec = (
17500 
    None, # 0
17501 
    (1, TType.I64, 'orderId', None, None, ), # 1
17502 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17503 
  )
17504 
 
17505 
  def __init__(self, orderId=None, isUsable=None,):
17506 
    self.orderId = orderId
17507 
    self.isUsable = isUsable
17508 
 
17509 
  def read(self, iprot):
17510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17512 
      return
17513 
    iprot.readStructBegin()
17514 
    while True:
17515 
      (fname, ftype, fid) = iprot.readFieldBegin()
17516 
      if ftype == TType.STOP:
17517 
        break
17518 
      if fid == 1:
17519 
        if ftype == TType.I64:
17520 
          self.orderId = iprot.readI64();
17521 
        else:
17522 
          iprot.skip(ftype)
17523 
      elif fid == 2:
17524 
        if ftype == TType.BOOL:
17525 
          self.isUsable = iprot.readBool();
17526 
        else:
17527 
          iprot.skip(ftype)
17528 
      else:
17529 
        iprot.skip(ftype)
17530 
      iprot.readFieldEnd()
17531 
    iprot.readStructEnd()
17532 
 
17533 
  def write(self, oprot):
17534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17536 
      return
17537 
    oprot.writeStructBegin('validateReturnProduct_args')
17538 
    if self.orderId is not None:
17539 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17540 
      oprot.writeI64(self.orderId)
17541 
      oprot.writeFieldEnd()
17542 
    if self.isUsable is not None:
17543 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17544 
      oprot.writeBool(self.isUsable)
17545 
      oprot.writeFieldEnd()
17546 
    oprot.writeFieldStop()
17547 
    oprot.writeStructEnd()
17548 
 
17549 
  def validate(self):
17550 
    return
17551 
 
17552 
 
17553 
  def __repr__(self):
17554 
    L = ['%s=%r' % (key, value)
17555 
      for key, value in self.__dict__.iteritems()]
17556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17557 
 
17558 
  def __eq__(self, other):
17559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17560 
 
17561 
  def __ne__(self, other):
17562 
    return not (self == other)
17563 
 
17564 
class validateReturnProduct_result:
17565 
  """
17566 
  Attributes:
17567 
   - success
17568 
   - ex
17569 
  """
17570 
 
17571 
  thrift_spec = (
17572 
    (0, TType.BOOL, 'success', None, None, ), # 0
17573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17574 
  )
17575 
 
17576 
  def __init__(self, success=None, ex=None,):
17577 
    self.success = success
17578 
    self.ex = ex
17579 
 
17580 
  def read(self, iprot):
17581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17583 
      return
17584 
    iprot.readStructBegin()
17585 
    while True:
17586 
      (fname, ftype, fid) = iprot.readFieldBegin()
17587 
      if ftype == TType.STOP:
17588 
        break
17589 
      if fid == 0:
17590 
        if ftype == TType.BOOL:
17591 
          self.success = iprot.readBool();
17592 
        else:
17593 
          iprot.skip(ftype)
17594 
      elif fid == 1:
17595 
        if ftype == TType.STRUCT:
17596 
          self.ex = TransactionServiceException()
17597 
          self.ex.read(iprot)
17598 
        else:
17599 
          iprot.skip(ftype)
17600 
      else:
17601 
        iprot.skip(ftype)
17602 
      iprot.readFieldEnd()
17603 
    iprot.readStructEnd()
17604 
 
17605 
  def write(self, oprot):
17606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17608 
      return
17609 
    oprot.writeStructBegin('validateReturnProduct_result')
17610 
    if self.success is not None:
17611 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17612 
      oprot.writeBool(self.success)
17613 
      oprot.writeFieldEnd()
17614 
    if self.ex is not None:
17615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17616 
      self.ex.write(oprot)
17617 
      oprot.writeFieldEnd()
17618 
    oprot.writeFieldStop()
17619 
    oprot.writeStructEnd()
17620 
 
17621 
  def validate(self):
17622 
    return
17623 
 
17624 
 
17625 
  def __repr__(self):
17626 
    L = ['%s=%r' % (key, value)
17627 
      for key, value in self.__dict__.iteritems()]
17628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17629 
 
17630 
  def __eq__(self, other):
17631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17632 
 
17633 
  def __ne__(self, other):
17634 
    return not (self == other)
17635 
 
2616 chandransh 17636 
class reshipOrder_args:
17637 
  """
17638 
  Attributes:
17639 
   - orderId
17640 
  """
2591 chandransh 17641 
 
2616 chandransh 17642 
  thrift_spec = (
17643 
    None, # 0
17644 
    (1, TType.I64, 'orderId', None, None, ), # 1
17645 
  )
17646 
 
17647 
  def __init__(self, orderId=None,):
17648 
    self.orderId = orderId
17649 
 
17650 
  def read(self, iprot):
17651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17653 
      return
17654 
    iprot.readStructBegin()
17655 
    while True:
17656 
      (fname, ftype, fid) = iprot.readFieldBegin()
17657 
      if ftype == TType.STOP:
17658 
        break
17659 
      if fid == 1:
17660 
        if ftype == TType.I64:
17661 
          self.orderId = iprot.readI64();
17662 
        else:
17663 
          iprot.skip(ftype)
17664 
      else:
17665 
        iprot.skip(ftype)
17666 
      iprot.readFieldEnd()
17667 
    iprot.readStructEnd()
17668 
 
17669 
  def write(self, oprot):
17670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17672 
      return
17673 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17674 
    if self.orderId is not None:
2616 chandransh 17675 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17676 
      oprot.writeI64(self.orderId)
17677 
      oprot.writeFieldEnd()
17678 
    oprot.writeFieldStop()
17679 
    oprot.writeStructEnd()
17680 
 
3431 rajveer 17681 
  def validate(self):
17682 
    return
17683 
 
17684 
 
2616 chandransh 17685 
  def __repr__(self):
17686 
    L = ['%s=%r' % (key, value)
17687 
      for key, value in self.__dict__.iteritems()]
17688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17689 
 
17690 
  def __eq__(self, other):
17691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17692 
 
17693 
  def __ne__(self, other):
17694 
    return not (self == other)
17695 
 
17696 
class reshipOrder_result:
17697 
  """
17698 
  Attributes:
17699 
   - success
17700 
   - ex
17701 
  """
17702 
 
17703 
  thrift_spec = (
17704 
    (0, TType.I64, 'success', None, None, ), # 0
17705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17706 
  )
17707 
 
17708 
  def __init__(self, success=None, ex=None,):
17709 
    self.success = success
17710 
    self.ex = ex
17711 
 
17712 
  def read(self, iprot):
17713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17715 
      return
17716 
    iprot.readStructBegin()
17717 
    while True:
17718 
      (fname, ftype, fid) = iprot.readFieldBegin()
17719 
      if ftype == TType.STOP:
17720 
        break
17721 
      if fid == 0:
17722 
        if ftype == TType.I64:
17723 
          self.success = iprot.readI64();
17724 
        else:
17725 
          iprot.skip(ftype)
17726 
      elif fid == 1:
17727 
        if ftype == TType.STRUCT:
17728 
          self.ex = TransactionServiceException()
17729 
          self.ex.read(iprot)
17730 
        else:
17731 
          iprot.skip(ftype)
17732 
      else:
17733 
        iprot.skip(ftype)
17734 
      iprot.readFieldEnd()
17735 
    iprot.readStructEnd()
17736 
 
17737 
  def write(self, oprot):
17738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17740 
      return
17741 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17742 
    if self.success is not None:
2616 chandransh 17743 
      oprot.writeFieldBegin('success', TType.I64, 0)
17744 
      oprot.writeI64(self.success)
17745 
      oprot.writeFieldEnd()
3431 rajveer 17746 
    if self.ex is not None:
2616 chandransh 17747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17748 
      self.ex.write(oprot)
17749 
      oprot.writeFieldEnd()
17750 
    oprot.writeFieldStop()
17751 
    oprot.writeStructEnd()
17752 
 
3431 rajveer 17753 
  def validate(self):
17754 
    return
17755 
 
17756 
 
2616 chandransh 17757 
  def __repr__(self):
17758 
    L = ['%s=%r' % (key, value)
17759 
      for key, value in self.__dict__.iteritems()]
17760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17761 
 
17762 
  def __eq__(self, other):
17763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17764 
 
17765 
  def __ne__(self, other):
17766 
    return not (self == other)
17767 
 
17768 
class refundOrder_args:
17769 
  """
17770 
  Attributes:
17771 
   - orderId
3226 chandransh 17772 
   - refundedBy
17773 
   - reason
2616 chandransh 17774 
  """
17775 
 
17776 
  thrift_spec = (
17777 
    None, # 0
17778 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17779 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17780 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17781 
  )
17782 
 
3226 chandransh 17783 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17784 
    self.orderId = orderId
3226 chandransh 17785 
    self.refundedBy = refundedBy
17786 
    self.reason = reason
2616 chandransh 17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 1:
17798 
        if ftype == TType.I64:
17799 
          self.orderId = iprot.readI64();
17800 
        else:
17801 
          iprot.skip(ftype)
3226 chandransh 17802 
      elif fid == 2:
17803 
        if ftype == TType.STRING:
17804 
          self.refundedBy = iprot.readString();
17805 
        else:
17806 
          iprot.skip(ftype)
17807 
      elif fid == 3:
17808 
        if ftype == TType.STRING:
17809 
          self.reason = iprot.readString();
17810 
        else:
17811 
          iprot.skip(ftype)
2616 chandransh 17812 
      else:
17813 
        iprot.skip(ftype)
17814 
      iprot.readFieldEnd()
17815 
    iprot.readStructEnd()
17816 
 
17817 
  def write(self, oprot):
17818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17820 
      return
17821 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17822 
    if self.orderId is not None:
2616 chandransh 17823 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17824 
      oprot.writeI64(self.orderId)
17825 
      oprot.writeFieldEnd()
3431 rajveer 17826 
    if self.refundedBy is not None:
3226 chandransh 17827 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17828 
      oprot.writeString(self.refundedBy)
17829 
      oprot.writeFieldEnd()
3431 rajveer 17830 
    if self.reason is not None:
3226 chandransh 17831 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17832 
      oprot.writeString(self.reason)
17833 
      oprot.writeFieldEnd()
2616 chandransh 17834 
    oprot.writeFieldStop()
17835 
    oprot.writeStructEnd()
17836 
 
3431 rajveer 17837 
  def validate(self):
17838 
    return
17839 
 
17840 
 
2616 chandransh 17841 
  def __repr__(self):
17842 
    L = ['%s=%r' % (key, value)
17843 
      for key, value in self.__dict__.iteritems()]
17844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17845 
 
17846 
  def __eq__(self, other):
17847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17848 
 
17849 
  def __ne__(self, other):
17850 
    return not (self == other)
17851 
 
17852 
class refundOrder_result:
17853 
  """
17854 
  Attributes:
17855 
   - success
17856 
   - ex
17857 
  """
17858 
 
17859 
  thrift_spec = (
17860 
    (0, TType.BOOL, 'success', None, None, ), # 0
17861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17862 
  )
17863 
 
17864 
  def __init__(self, success=None, ex=None,):
17865 
    self.success = success
17866 
    self.ex = ex
17867 
 
17868 
  def read(self, iprot):
17869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17871 
      return
17872 
    iprot.readStructBegin()
17873 
    while True:
17874 
      (fname, ftype, fid) = iprot.readFieldBegin()
17875 
      if ftype == TType.STOP:
17876 
        break
17877 
      if fid == 0:
17878 
        if ftype == TType.BOOL:
17879 
          self.success = iprot.readBool();
17880 
        else:
17881 
          iprot.skip(ftype)
17882 
      elif fid == 1:
17883 
        if ftype == TType.STRUCT:
17884 
          self.ex = TransactionServiceException()
17885 
          self.ex.read(iprot)
17886 
        else:
17887 
          iprot.skip(ftype)
17888 
      else:
17889 
        iprot.skip(ftype)
17890 
      iprot.readFieldEnd()
17891 
    iprot.readStructEnd()
17892 
 
17893 
  def write(self, oprot):
17894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17896 
      return
17897 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17898 
    if self.success is not None:
2616 chandransh 17899 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17900 
      oprot.writeBool(self.success)
17901 
      oprot.writeFieldEnd()
3431 rajveer 17902 
    if self.ex is not None:
2616 chandransh 17903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17904 
      self.ex.write(oprot)
17905 
      oprot.writeFieldEnd()
17906 
    oprot.writeFieldStop()
17907 
    oprot.writeStructEnd()
17908 
 
3431 rajveer 17909 
  def validate(self):
17910 
    return
17911 
 
17912 
 
2616 chandransh 17913 
  def __repr__(self):
17914 
    L = ['%s=%r' % (key, value)
17915 
      for key, value in self.__dict__.iteritems()]
17916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17917 
 
17918 
  def __eq__(self, other):
17919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17920 
 
17921 
  def __ne__(self, other):
17922 
    return not (self == other)
17923 
 
2690 chandransh 17924 
class getReturnOrders_args:
17925 
  """
17926 
  Attributes:
17927 
   - warehouseId
17928 
   - fromDate
17929 
   - toDate
17930 
  """
2616 chandransh 17931 
 
2690 chandransh 17932 
  thrift_spec = (
17933 
    None, # 0
17934 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17935 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17936 
    (3, TType.I64, 'toDate', None, None, ), # 3
17937 
  )
17938 
 
17939 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17940 
    self.warehouseId = warehouseId
17941 
    self.fromDate = fromDate
17942 
    self.toDate = toDate
17943 
 
17944 
  def read(self, iprot):
17945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17947 
      return
17948 
    iprot.readStructBegin()
17949 
    while True:
17950 
      (fname, ftype, fid) = iprot.readFieldBegin()
17951 
      if ftype == TType.STOP:
17952 
        break
17953 
      if fid == 1:
17954 
        if ftype == TType.I64:
17955 
          self.warehouseId = iprot.readI64();
17956 
        else:
17957 
          iprot.skip(ftype)
17958 
      elif fid == 2:
17959 
        if ftype == TType.I64:
17960 
          self.fromDate = iprot.readI64();
17961 
        else:
17962 
          iprot.skip(ftype)
17963 
      elif fid == 3:
17964 
        if ftype == TType.I64:
17965 
          self.toDate = iprot.readI64();
17966 
        else:
17967 
          iprot.skip(ftype)
17968 
      else:
17969 
        iprot.skip(ftype)
17970 
      iprot.readFieldEnd()
17971 
    iprot.readStructEnd()
17972 
 
17973 
  def write(self, oprot):
17974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17976 
      return
17977 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17978 
    if self.warehouseId is not None:
2690 chandransh 17979 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17980 
      oprot.writeI64(self.warehouseId)
17981 
      oprot.writeFieldEnd()
3431 rajveer 17982 
    if self.fromDate is not None:
2690 chandransh 17983 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17984 
      oprot.writeI64(self.fromDate)
17985 
      oprot.writeFieldEnd()
3431 rajveer 17986 
    if self.toDate is not None:
2690 chandransh 17987 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17988 
      oprot.writeI64(self.toDate)
17989 
      oprot.writeFieldEnd()
17990 
    oprot.writeFieldStop()
17991 
    oprot.writeStructEnd()
17992 
 
3431 rajveer 17993 
  def validate(self):
17994 
    return
17995 
 
17996 
 
2690 chandransh 17997 
  def __repr__(self):
17998 
    L = ['%s=%r' % (key, value)
17999 
      for key, value in self.__dict__.iteritems()]
18000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18001 
 
18002 
  def __eq__(self, other):
18003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18004 
 
18005 
  def __ne__(self, other):
18006 
    return not (self == other)
18007 
 
18008 
class getReturnOrders_result:
18009 
  """
18010 
  Attributes:
18011 
   - success
18012 
  """
18013 
 
18014 
  thrift_spec = (
18015 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18016 
  )
18017 
 
18018 
  def __init__(self, success=None,):
18019 
    self.success = success
18020 
 
18021 
  def read(self, iprot):
18022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18024 
      return
18025 
    iprot.readStructBegin()
18026 
    while True:
18027 
      (fname, ftype, fid) = iprot.readFieldBegin()
18028 
      if ftype == TType.STOP:
18029 
        break
18030 
      if fid == 0:
18031 
        if ftype == TType.LIST:
18032 
          self.success = []
6031 rajveer 18033 
          (_etype399, _size396) = iprot.readListBegin()
18034 
          for _i400 in xrange(_size396):
18035 
            _elem401 = ReturnOrder()
18036 
            _elem401.read(iprot)
18037 
            self.success.append(_elem401)
2690 chandransh 18038 
          iprot.readListEnd()
18039 
        else:
18040 
          iprot.skip(ftype)
18041 
      else:
18042 
        iprot.skip(ftype)
18043 
      iprot.readFieldEnd()
18044 
    iprot.readStructEnd()
18045 
 
18046 
  def write(self, oprot):
18047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18049 
      return
18050 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18051 
    if self.success is not None:
2690 chandransh 18052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18054 
      for iter402 in self.success:
18055 
        iter402.write(oprot)
2690 chandransh 18056 
      oprot.writeListEnd()
18057 
      oprot.writeFieldEnd()
18058 
    oprot.writeFieldStop()
18059 
    oprot.writeStructEnd()
18060 
 
3431 rajveer 18061 
  def validate(self):
18062 
    return
18063 
 
18064 
 
2690 chandransh 18065 
  def __repr__(self):
18066 
    L = ['%s=%r' % (key, value)
18067 
      for key, value in self.__dict__.iteritems()]
18068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18069 
 
18070 
  def __eq__(self, other):
18071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18072 
 
18073 
  def __ne__(self, other):
18074 
    return not (self == other)
18075 
 
5481 phani.kuma 18076 
class getAllReturnOrders_args:
18077 
  """
18078 
  Attributes:
18079 
   - onlyNotProcessed
18080 
   - fromDate
18081 
   - toDate
18082 
  """
18083 
 
18084 
  thrift_spec = (
18085 
    None, # 0
18086 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18087 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18088 
    (3, TType.I64, 'toDate', None, None, ), # 3
18089 
  )
18090 
 
18091 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18092 
    self.onlyNotProcessed = onlyNotProcessed
18093 
    self.fromDate = fromDate
18094 
    self.toDate = toDate
18095 
 
18096 
  def read(self, iprot):
18097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18099 
      return
18100 
    iprot.readStructBegin()
18101 
    while True:
18102 
      (fname, ftype, fid) = iprot.readFieldBegin()
18103 
      if ftype == TType.STOP:
18104 
        break
18105 
      if fid == 1:
18106 
        if ftype == TType.BOOL:
18107 
          self.onlyNotProcessed = iprot.readBool();
18108 
        else:
18109 
          iprot.skip(ftype)
18110 
      elif fid == 2:
18111 
        if ftype == TType.I64:
18112 
          self.fromDate = iprot.readI64();
18113 
        else:
18114 
          iprot.skip(ftype)
18115 
      elif fid == 3:
18116 
        if ftype == TType.I64:
18117 
          self.toDate = iprot.readI64();
18118 
        else:
18119 
          iprot.skip(ftype)
18120 
      else:
18121 
        iprot.skip(ftype)
18122 
      iprot.readFieldEnd()
18123 
    iprot.readStructEnd()
18124 
 
18125 
  def write(self, oprot):
18126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18128 
      return
18129 
    oprot.writeStructBegin('getAllReturnOrders_args')
18130 
    if self.onlyNotProcessed is not None:
18131 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18132 
      oprot.writeBool(self.onlyNotProcessed)
18133 
      oprot.writeFieldEnd()
18134 
    if self.fromDate is not None:
18135 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18136 
      oprot.writeI64(self.fromDate)
18137 
      oprot.writeFieldEnd()
18138 
    if self.toDate is not None:
18139 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18140 
      oprot.writeI64(self.toDate)
18141 
      oprot.writeFieldEnd()
18142 
    oprot.writeFieldStop()
18143 
    oprot.writeStructEnd()
18144 
 
18145 
  def validate(self):
18146 
    return
18147 
 
18148 
 
18149 
  def __repr__(self):
18150 
    L = ['%s=%r' % (key, value)
18151 
      for key, value in self.__dict__.iteritems()]
18152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18153 
 
18154 
  def __eq__(self, other):
18155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18156 
 
18157 
  def __ne__(self, other):
18158 
    return not (self == other)
18159 
 
18160 
class getAllReturnOrders_result:
18161 
  """
18162 
  Attributes:
18163 
   - success
18164 
  """
18165 
 
18166 
  thrift_spec = (
18167 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18168 
  )
18169 
 
18170 
  def __init__(self, success=None,):
18171 
    self.success = success
18172 
 
18173 
  def read(self, iprot):
18174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18176 
      return
18177 
    iprot.readStructBegin()
18178 
    while True:
18179 
      (fname, ftype, fid) = iprot.readFieldBegin()
18180 
      if ftype == TType.STOP:
18181 
        break
18182 
      if fid == 0:
18183 
        if ftype == TType.LIST:
18184 
          self.success = []
6031 rajveer 18185 
          (_etype406, _size403) = iprot.readListBegin()
18186 
          for _i407 in xrange(_size403):
18187 
            _elem408 = ReturnOrder()
18188 
            _elem408.read(iprot)
18189 
            self.success.append(_elem408)
5481 phani.kuma 18190 
          iprot.readListEnd()
18191 
        else:
18192 
          iprot.skip(ftype)
18193 
      else:
18194 
        iprot.skip(ftype)
18195 
      iprot.readFieldEnd()
18196 
    iprot.readStructEnd()
18197 
 
18198 
  def write(self, oprot):
18199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18201 
      return
18202 
    oprot.writeStructBegin('getAllReturnOrders_result')
18203 
    if self.success is not None:
18204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18206 
      for iter409 in self.success:
18207 
        iter409.write(oprot)
5481 phani.kuma 18208 
      oprot.writeListEnd()
18209 
      oprot.writeFieldEnd()
18210 
    oprot.writeFieldStop()
18211 
    oprot.writeStructEnd()
18212 
 
18213 
  def validate(self):
18214 
    return
18215 
 
18216 
 
18217 
  def __repr__(self):
18218 
    L = ['%s=%r' % (key, value)
18219 
      for key, value in self.__dict__.iteritems()]
18220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18221 
 
18222 
  def __eq__(self, other):
18223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18224 
 
18225 
  def __ne__(self, other):
18226 
    return not (self == other)
18227 
 
2700 chandransh 18228 
class getReturnOrder_args:
18229 
  """
18230 
  Attributes:
18231 
   - id
18232 
  """
18233 
 
18234 
  thrift_spec = (
18235 
    None, # 0
18236 
    (1, TType.I64, 'id', None, None, ), # 1
18237 
  )
18238 
 
18239 
  def __init__(self, id=None,):
18240 
    self.id = id
18241 
 
18242 
  def read(self, iprot):
18243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18245 
      return
18246 
    iprot.readStructBegin()
18247 
    while True:
18248 
      (fname, ftype, fid) = iprot.readFieldBegin()
18249 
      if ftype == TType.STOP:
18250 
        break
18251 
      if fid == 1:
18252 
        if ftype == TType.I64:
18253 
          self.id = iprot.readI64();
18254 
        else:
18255 
          iprot.skip(ftype)
18256 
      else:
18257 
        iprot.skip(ftype)
18258 
      iprot.readFieldEnd()
18259 
    iprot.readStructEnd()
18260 
 
18261 
  def write(self, oprot):
18262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18264 
      return
18265 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18266 
    if self.id is not None:
2700 chandransh 18267 
      oprot.writeFieldBegin('id', TType.I64, 1)
18268 
      oprot.writeI64(self.id)
18269 
      oprot.writeFieldEnd()
18270 
    oprot.writeFieldStop()
18271 
    oprot.writeStructEnd()
18272 
 
3431 rajveer 18273 
  def validate(self):
18274 
    return
18275 
 
18276 
 
2700 chandransh 18277 
  def __repr__(self):
18278 
    L = ['%s=%r' % (key, value)
18279 
      for key, value in self.__dict__.iteritems()]
18280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18281 
 
18282 
  def __eq__(self, other):
18283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18284 
 
18285 
  def __ne__(self, other):
18286 
    return not (self == other)
18287 
 
18288 
class getReturnOrder_result:
18289 
  """
18290 
  Attributes:
18291 
   - success
18292 
   - ex
18293 
  """
18294 
 
18295 
  thrift_spec = (
18296 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18297 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18298 
  )
18299 
 
18300 
  def __init__(self, success=None, ex=None,):
18301 
    self.success = success
18302 
    self.ex = ex
18303 
 
18304 
  def read(self, iprot):
18305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18307 
      return
18308 
    iprot.readStructBegin()
18309 
    while True:
18310 
      (fname, ftype, fid) = iprot.readFieldBegin()
18311 
      if ftype == TType.STOP:
18312 
        break
18313 
      if fid == 0:
18314 
        if ftype == TType.STRUCT:
18315 
          self.success = ReturnOrder()
18316 
          self.success.read(iprot)
18317 
        else:
18318 
          iprot.skip(ftype)
18319 
      elif fid == 1:
18320 
        if ftype == TType.STRUCT:
18321 
          self.ex = TransactionServiceException()
18322 
          self.ex.read(iprot)
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18335 
    if self.success is not None:
2700 chandransh 18336 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18337 
      self.success.write(oprot)
18338 
      oprot.writeFieldEnd()
3431 rajveer 18339 
    if self.ex is not None:
2700 chandransh 18340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18341 
      self.ex.write(oprot)
18342 
      oprot.writeFieldEnd()
18343 
    oprot.writeFieldStop()
18344 
    oprot.writeStructEnd()
18345 
 
3431 rajveer 18346 
  def validate(self):
18347 
    return
18348 
 
18349 
 
2700 chandransh 18350 
  def __repr__(self):
18351 
    L = ['%s=%r' % (key, value)
18352 
      for key, value in self.__dict__.iteritems()]
18353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18354 
 
18355 
  def __eq__(self, other):
18356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18357 
 
18358 
  def __ne__(self, other):
18359 
    return not (self == other)
18360 
 
2690 chandransh 18361 
class processReturn_args:
18362 
  """
18363 
  Attributes:
18364 
   - returnOrderId
18365 
  """
18366 
 
18367 
  thrift_spec = (
18368 
    None, # 0
18369 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18370 
  )
18371 
 
18372 
  def __init__(self, returnOrderId=None,):
18373 
    self.returnOrderId = returnOrderId
18374 
 
18375 
  def read(self, iprot):
18376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18378 
      return
18379 
    iprot.readStructBegin()
18380 
    while True:
18381 
      (fname, ftype, fid) = iprot.readFieldBegin()
18382 
      if ftype == TType.STOP:
18383 
        break
18384 
      if fid == 1:
18385 
        if ftype == TType.I64:
18386 
          self.returnOrderId = iprot.readI64();
18387 
        else:
18388 
          iprot.skip(ftype)
18389 
      else:
18390 
        iprot.skip(ftype)
18391 
      iprot.readFieldEnd()
18392 
    iprot.readStructEnd()
18393 
 
18394 
  def write(self, oprot):
18395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18397 
      return
18398 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18399 
    if self.returnOrderId is not None:
2690 chandransh 18400 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18401 
      oprot.writeI64(self.returnOrderId)
18402 
      oprot.writeFieldEnd()
18403 
    oprot.writeFieldStop()
18404 
    oprot.writeStructEnd()
18405 
 
3431 rajveer 18406 
  def validate(self):
18407 
    return
18408 
 
18409 
 
2690 chandransh 18410 
  def __repr__(self):
18411 
    L = ['%s=%r' % (key, value)
18412 
      for key, value in self.__dict__.iteritems()]
18413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18414 
 
18415 
  def __eq__(self, other):
18416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18417 
 
18418 
  def __ne__(self, other):
18419 
    return not (self == other)
18420 
 
18421 
class processReturn_result:
18422 
  """
18423 
  Attributes:
18424 
   - ex
18425 
  """
18426 
 
18427 
  thrift_spec = (
18428 
    None, # 0
18429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18430 
  )
18431 
 
18432 
  def __init__(self, ex=None,):
18433 
    self.ex = ex
18434 
 
18435 
  def read(self, iprot):
18436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18438 
      return
18439 
    iprot.readStructBegin()
18440 
    while True:
18441 
      (fname, ftype, fid) = iprot.readFieldBegin()
18442 
      if ftype == TType.STOP:
18443 
        break
18444 
      if fid == 1:
18445 
        if ftype == TType.STRUCT:
18446 
          self.ex = TransactionServiceException()
18447 
          self.ex.read(iprot)
18448 
        else:
18449 
          iprot.skip(ftype)
18450 
      else:
18451 
        iprot.skip(ftype)
18452 
      iprot.readFieldEnd()
18453 
    iprot.readStructEnd()
18454 
 
18455 
  def write(self, oprot):
18456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18458 
      return
18459 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18460 
    if self.ex is not None:
2690 chandransh 18461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18462 
      self.ex.write(oprot)
18463 
      oprot.writeFieldEnd()
18464 
    oprot.writeFieldStop()
18465 
    oprot.writeStructEnd()
18466 
 
3431 rajveer 18467 
  def validate(self):
18468 
    return
18469 
 
18470 
 
2690 chandransh 18471 
  def __repr__(self):
18472 
    L = ['%s=%r' % (key, value)
18473 
      for key, value in self.__dict__.iteritems()]
18474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18475 
 
18476 
  def __eq__(self, other):
18477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18478 
 
18479 
  def __ne__(self, other):
18480 
    return not (self == other)
18481 
 
3451 chandransh 18482 
class updateWeight_args:
18483 
  """
18484 
  Attributes:
18485 
   - orderId
18486 
   - weight
18487 
  """
18488 
 
18489 
  thrift_spec = (
18490 
    None, # 0
18491 
    (1, TType.I64, 'orderId', None, None, ), # 1
18492 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18493 
  )
18494 
 
18495 
  def __init__(self, orderId=None, weight=None,):
18496 
    self.orderId = orderId
18497 
    self.weight = weight
18498 
 
18499 
  def read(self, iprot):
18500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18502 
      return
18503 
    iprot.readStructBegin()
18504 
    while True:
18505 
      (fname, ftype, fid) = iprot.readFieldBegin()
18506 
      if ftype == TType.STOP:
18507 
        break
18508 
      if fid == 1:
18509 
        if ftype == TType.I64:
18510 
          self.orderId = iprot.readI64();
18511 
        else:
18512 
          iprot.skip(ftype)
18513 
      elif fid == 2:
18514 
        if ftype == TType.DOUBLE:
18515 
          self.weight = iprot.readDouble();
18516 
        else:
18517 
          iprot.skip(ftype)
18518 
      else:
18519 
        iprot.skip(ftype)
18520 
      iprot.readFieldEnd()
18521 
    iprot.readStructEnd()
18522 
 
18523 
  def write(self, oprot):
18524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18526 
      return
18527 
    oprot.writeStructBegin('updateWeight_args')
18528 
    if self.orderId is not None:
18529 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18530 
      oprot.writeI64(self.orderId)
18531 
      oprot.writeFieldEnd()
18532 
    if self.weight is not None:
18533 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18534 
      oprot.writeDouble(self.weight)
18535 
      oprot.writeFieldEnd()
18536 
    oprot.writeFieldStop()
18537 
    oprot.writeStructEnd()
18538 
 
18539 
  def validate(self):
18540 
    return
18541 
 
18542 
 
18543 
  def __repr__(self):
18544 
    L = ['%s=%r' % (key, value)
18545 
      for key, value in self.__dict__.iteritems()]
18546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18547 
 
18548 
  def __eq__(self, other):
18549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18550 
 
18551 
  def __ne__(self, other):
18552 
    return not (self == other)
18553 
 
18554 
class updateWeight_result:
18555 
  """
18556 
  Attributes:
18557 
   - success
18558 
   - ex
18559 
  """
18560 
 
18561 
  thrift_spec = (
18562 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18564 
  )
18565 
 
18566 
  def __init__(self, success=None, ex=None,):
18567 
    self.success = success
18568 
    self.ex = ex
18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 0:
18580 
        if ftype == TType.STRUCT:
18581 
          self.success = Order()
18582 
          self.success.read(iprot)
18583 
        else:
18584 
          iprot.skip(ftype)
18585 
      elif fid == 1:
18586 
        if ftype == TType.STRUCT:
18587 
          self.ex = TransactionServiceException()
18588 
          self.ex.read(iprot)
18589 
        else:
18590 
          iprot.skip(ftype)
18591 
      else:
18592 
        iprot.skip(ftype)
18593 
      iprot.readFieldEnd()
18594 
    iprot.readStructEnd()
18595 
 
18596 
  def write(self, oprot):
18597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18599 
      return
18600 
    oprot.writeStructBegin('updateWeight_result')
18601 
    if self.success is not None:
18602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18603 
      self.success.write(oprot)
18604 
      oprot.writeFieldEnd()
18605 
    if self.ex is not None:
18606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18607 
      self.ex.write(oprot)
18608 
      oprot.writeFieldEnd()
18609 
    oprot.writeFieldStop()
18610 
    oprot.writeStructEnd()
18611 
 
18612 
  def validate(self):
18613 
    return
18614 
 
18615 
 
18616 
  def __repr__(self):
18617 
    L = ['%s=%r' % (key, value)
18618 
      for key, value in self.__dict__.iteritems()]
18619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18620 
 
18621 
  def __eq__(self, other):
18622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18623 
 
18624 
  def __ne__(self, other):
18625 
    return not (self == other)
3469 chandransh 18626 
 
18627 
class changeItem_args:
18628 
  """
18629 
  Attributes:
18630 
   - orderId
18631 
   - itemId
18632 
  """
18633 
 
18634 
  thrift_spec = (
18635 
    None, # 0
18636 
    (1, TType.I64, 'orderId', None, None, ), # 1
18637 
    (2, TType.I64, 'itemId', None, None, ), # 2
18638 
  )
18639 
 
18640 
  def __init__(self, orderId=None, itemId=None,):
18641 
    self.orderId = orderId
18642 
    self.itemId = itemId
18643 
 
18644 
  def read(self, iprot):
18645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18647 
      return
18648 
    iprot.readStructBegin()
18649 
    while True:
18650 
      (fname, ftype, fid) = iprot.readFieldBegin()
18651 
      if ftype == TType.STOP:
18652 
        break
18653 
      if fid == 1:
18654 
        if ftype == TType.I64:
18655 
          self.orderId = iprot.readI64();
18656 
        else:
18657 
          iprot.skip(ftype)
18658 
      elif fid == 2:
18659 
        if ftype == TType.I64:
18660 
          self.itemId = iprot.readI64();
18661 
        else:
18662 
          iprot.skip(ftype)
18663 
      else:
18664 
        iprot.skip(ftype)
18665 
      iprot.readFieldEnd()
18666 
    iprot.readStructEnd()
18667 
 
18668 
  def write(self, oprot):
18669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18671 
      return
18672 
    oprot.writeStructBegin('changeItem_args')
18673 
    if self.orderId is not None:
18674 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18675 
      oprot.writeI64(self.orderId)
18676 
      oprot.writeFieldEnd()
18677 
    if self.itemId is not None:
18678 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18679 
      oprot.writeI64(self.itemId)
18680 
      oprot.writeFieldEnd()
18681 
    oprot.writeFieldStop()
18682 
    oprot.writeStructEnd()
18683 
 
18684 
  def validate(self):
18685 
    return
18686 
 
18687 
 
18688 
  def __repr__(self):
18689 
    L = ['%s=%r' % (key, value)
18690 
      for key, value in self.__dict__.iteritems()]
18691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18692 
 
18693 
  def __eq__(self, other):
18694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18695 
 
18696 
  def __ne__(self, other):
18697 
    return not (self == other)
18698 
 
18699 
class changeItem_result:
18700 
  """
18701 
  Attributes:
18702 
   - success
18703 
   - ex
18704 
  """
18705 
 
18706 
  thrift_spec = (
18707 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18709 
  )
18710 
 
18711 
  def __init__(self, success=None, ex=None,):
18712 
    self.success = success
18713 
    self.ex = ex
18714 
 
18715 
  def read(self, iprot):
18716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18718 
      return
18719 
    iprot.readStructBegin()
18720 
    while True:
18721 
      (fname, ftype, fid) = iprot.readFieldBegin()
18722 
      if ftype == TType.STOP:
18723 
        break
18724 
      if fid == 0:
18725 
        if ftype == TType.STRUCT:
18726 
          self.success = Order()
18727 
          self.success.read(iprot)
18728 
        else:
18729 
          iprot.skip(ftype)
18730 
      elif fid == 1:
18731 
        if ftype == TType.STRUCT:
18732 
          self.ex = TransactionServiceException()
18733 
          self.ex.read(iprot)
18734 
        else:
18735 
          iprot.skip(ftype)
18736 
      else:
18737 
        iprot.skip(ftype)
18738 
      iprot.readFieldEnd()
18739 
    iprot.readStructEnd()
18740 
 
18741 
  def write(self, oprot):
18742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18744 
      return
18745 
    oprot.writeStructBegin('changeItem_result')
18746 
    if self.success is not None:
18747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18748 
      self.success.write(oprot)
18749 
      oprot.writeFieldEnd()
18750 
    if self.ex is not None:
18751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18752 
      self.ex.write(oprot)
18753 
      oprot.writeFieldEnd()
18754 
    oprot.writeFieldStop()
18755 
    oprot.writeStructEnd()
18756 
 
18757 
  def validate(self):
18758 
    return
18759 
 
18760 
 
18761 
  def __repr__(self):
18762 
    L = ['%s=%r' % (key, value)
18763 
      for key, value in self.__dict__.iteritems()]
18764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18765 
 
18766 
  def __eq__(self, other):
18767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18768 
 
18769 
  def __ne__(self, other):
18770 
    return not (self == other)
18771 
 
18772 
class shiftToWarehouse_args:
18773 
  """
18774 
  Attributes:
18775 
   - orderId
18776 
   - warehouseId
18777 
  """
18778 
 
18779 
  thrift_spec = (
18780 
    None, # 0
18781 
    (1, TType.I64, 'orderId', None, None, ), # 1
18782 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18783 
  )
18784 
 
18785 
  def __init__(self, orderId=None, warehouseId=None,):
18786 
    self.orderId = orderId
18787 
    self.warehouseId = warehouseId
18788 
 
18789 
  def read(self, iprot):
18790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18792 
      return
18793 
    iprot.readStructBegin()
18794 
    while True:
18795 
      (fname, ftype, fid) = iprot.readFieldBegin()
18796 
      if ftype == TType.STOP:
18797 
        break
18798 
      if fid == 1:
18799 
        if ftype == TType.I64:
18800 
          self.orderId = iprot.readI64();
18801 
        else:
18802 
          iprot.skip(ftype)
18803 
      elif fid == 2:
18804 
        if ftype == TType.I64:
18805 
          self.warehouseId = iprot.readI64();
18806 
        else:
18807 
          iprot.skip(ftype)
18808 
      else:
18809 
        iprot.skip(ftype)
18810 
      iprot.readFieldEnd()
18811 
    iprot.readStructEnd()
18812 
 
18813 
  def write(self, oprot):
18814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18816 
      return
18817 
    oprot.writeStructBegin('shiftToWarehouse_args')
18818 
    if self.orderId is not None:
18819 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18820 
      oprot.writeI64(self.orderId)
18821 
      oprot.writeFieldEnd()
18822 
    if self.warehouseId is not None:
18823 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18824 
      oprot.writeI64(self.warehouseId)
18825 
      oprot.writeFieldEnd()
18826 
    oprot.writeFieldStop()
18827 
    oprot.writeStructEnd()
18828 
 
18829 
  def validate(self):
18830 
    return
18831 
 
18832 
 
18833 
  def __repr__(self):
18834 
    L = ['%s=%r' % (key, value)
18835 
      for key, value in self.__dict__.iteritems()]
18836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18837 
 
18838 
  def __eq__(self, other):
18839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18840 
 
18841 
  def __ne__(self, other):
18842 
    return not (self == other)
18843 
 
18844 
class shiftToWarehouse_result:
18845 
  """
18846 
  Attributes:
18847 
   - success
18848 
   - ex
18849 
  """
18850 
 
18851 
  thrift_spec = (
18852 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18854 
  )
18855 
 
18856 
  def __init__(self, success=None, ex=None,):
18857 
    self.success = success
18858 
    self.ex = ex
18859 
 
18860 
  def read(self, iprot):
18861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18863 
      return
18864 
    iprot.readStructBegin()
18865 
    while True:
18866 
      (fname, ftype, fid) = iprot.readFieldBegin()
18867 
      if ftype == TType.STOP:
18868 
        break
18869 
      if fid == 0:
18870 
        if ftype == TType.STRUCT:
18871 
          self.success = Order()
18872 
          self.success.read(iprot)
18873 
        else:
18874 
          iprot.skip(ftype)
18875 
      elif fid == 1:
18876 
        if ftype == TType.STRUCT:
18877 
          self.ex = TransactionServiceException()
18878 
          self.ex.read(iprot)
18879 
        else:
18880 
          iprot.skip(ftype)
18881 
      else:
18882 
        iprot.skip(ftype)
18883 
      iprot.readFieldEnd()
18884 
    iprot.readStructEnd()
18885 
 
18886 
  def write(self, oprot):
18887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18889 
      return
18890 
    oprot.writeStructBegin('shiftToWarehouse_result')
18891 
    if self.success is not None:
18892 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18893 
      self.success.write(oprot)
18894 
      oprot.writeFieldEnd()
18895 
    if self.ex is not None:
18896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18897 
      self.ex.write(oprot)
18898 
      oprot.writeFieldEnd()
18899 
    oprot.writeFieldStop()
18900 
    oprot.writeStructEnd()
18901 
 
18902 
  def validate(self):
18903 
    return
18904 
 
18905 
 
18906 
  def __repr__(self):
18907 
    L = ['%s=%r' % (key, value)
18908 
      for key, value in self.__dict__.iteritems()]
18909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18910 
 
18911 
  def __eq__(self, other):
18912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18913 
 
18914 
  def __ne__(self, other):
18915 
    return not (self == other)
3553 chandransh 18916 
 
18917 
class addDelayReason_args:
18918 
  """
18919 
  Attributes:
18920 
   - orderId
18921 
   - delayReason
3986 chandransh 18922 
   - furtherDelay
4647 rajveer 18923 
   - delayReasonText
3553 chandransh 18924 
  """
18925 
 
18926 
  thrift_spec = (
18927 
    None, # 0
18928 
    (1, TType.I64, 'orderId', None, None, ), # 1
18929 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18930 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18931 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18932 
  )
18933 
 
4647 rajveer 18934 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18935 
    self.orderId = orderId
18936 
    self.delayReason = delayReason
3986 chandransh 18937 
    self.furtherDelay = furtherDelay
4647 rajveer 18938 
    self.delayReasonText = delayReasonText
3553 chandransh 18939 
 
18940 
  def read(self, iprot):
18941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18943 
      return
18944 
    iprot.readStructBegin()
18945 
    while True:
18946 
      (fname, ftype, fid) = iprot.readFieldBegin()
18947 
      if ftype == TType.STOP:
18948 
        break
18949 
      if fid == 1:
18950 
        if ftype == TType.I64:
18951 
          self.orderId = iprot.readI64();
18952 
        else:
18953 
          iprot.skip(ftype)
18954 
      elif fid == 2:
18955 
        if ftype == TType.I32:
18956 
          self.delayReason = iprot.readI32();
18957 
        else:
18958 
          iprot.skip(ftype)
3986 chandransh 18959 
      elif fid == 3:
18960 
        if ftype == TType.I64:
18961 
          self.furtherDelay = iprot.readI64();
18962 
        else:
18963 
          iprot.skip(ftype)
4647 rajveer 18964 
      elif fid == 4:
18965 
        if ftype == TType.STRING:
18966 
          self.delayReasonText = iprot.readString();
18967 
        else:
18968 
          iprot.skip(ftype)
3553 chandransh 18969 
      else:
18970 
        iprot.skip(ftype)
18971 
      iprot.readFieldEnd()
18972 
    iprot.readStructEnd()
18973 
 
18974 
  def write(self, oprot):
18975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18977 
      return
18978 
    oprot.writeStructBegin('addDelayReason_args')
18979 
    if self.orderId is not None:
18980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18981 
      oprot.writeI64(self.orderId)
18982 
      oprot.writeFieldEnd()
18983 
    if self.delayReason is not None:
18984 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18985 
      oprot.writeI32(self.delayReason)
18986 
      oprot.writeFieldEnd()
3986 chandransh 18987 
    if self.furtherDelay is not None:
18988 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18989 
      oprot.writeI64(self.furtherDelay)
18990 
      oprot.writeFieldEnd()
4647 rajveer 18991 
    if self.delayReasonText is not None:
18992 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18993 
      oprot.writeString(self.delayReasonText)
18994 
      oprot.writeFieldEnd()
3553 chandransh 18995 
    oprot.writeFieldStop()
18996 
    oprot.writeStructEnd()
18997 
 
18998 
  def validate(self):
18999 
    return
19000 
 
19001 
 
19002 
  def __repr__(self):
19003 
    L = ['%s=%r' % (key, value)
19004 
      for key, value in self.__dict__.iteritems()]
19005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19006 
 
19007 
  def __eq__(self, other):
19008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19009 
 
19010 
  def __ne__(self, other):
19011 
    return not (self == other)
19012 
 
19013 
class addDelayReason_result:
19014 
  """
19015 
  Attributes:
19016 
   - success
19017 
   - ex
19018 
  """
19019 
 
19020 
  thrift_spec = (
19021 
    (0, TType.BOOL, 'success', None, None, ), # 0
19022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19023 
  )
19024 
 
19025 
  def __init__(self, success=None, ex=None,):
19026 
    self.success = success
19027 
    self.ex = ex
19028 
 
19029 
  def read(self, iprot):
19030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19032 
      return
19033 
    iprot.readStructBegin()
19034 
    while True:
19035 
      (fname, ftype, fid) = iprot.readFieldBegin()
19036 
      if ftype == TType.STOP:
19037 
        break
19038 
      if fid == 0:
19039 
        if ftype == TType.BOOL:
19040 
          self.success = iprot.readBool();
19041 
        else:
19042 
          iprot.skip(ftype)
19043 
      elif fid == 1:
19044 
        if ftype == TType.STRUCT:
19045 
          self.ex = TransactionServiceException()
19046 
          self.ex.read(iprot)
19047 
        else:
19048 
          iprot.skip(ftype)
19049 
      else:
19050 
        iprot.skip(ftype)
19051 
      iprot.readFieldEnd()
19052 
    iprot.readStructEnd()
19053 
 
19054 
  def write(self, oprot):
19055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19057 
      return
19058 
    oprot.writeStructBegin('addDelayReason_result')
19059 
    if self.success is not None:
19060 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19061 
      oprot.writeBool(self.success)
19062 
      oprot.writeFieldEnd()
19063 
    if self.ex is not None:
19064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19065 
      self.ex.write(oprot)
19066 
      oprot.writeFieldEnd()
19067 
    oprot.writeFieldStop()
19068 
    oprot.writeStructEnd()
19069 
 
19070 
  def validate(self):
19071 
    return
19072 
 
19073 
 
19074 
  def __repr__(self):
19075 
    L = ['%s=%r' % (key, value)
19076 
      for key, value in self.__dict__.iteritems()]
19077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19078 
 
19079 
  def __eq__(self, other):
19080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19081 
 
19082 
  def __ne__(self, other):
19083 
    return not (self == other)
3956 chandransh 19084 
 
19085 
class reconcileCodCollection_args:
19086 
  """
19087 
  Attributes:
19088 
   - collectedAmountMap
19089 
   - xferBy
19090 
   - xferTxnId
19091 
   - xferDate
19092 
  """
19093 
 
19094 
  thrift_spec = (
19095 
    None, # 0
19096 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19097 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19098 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19099 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19100 
  )
19101 
 
19102 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19103 
    self.collectedAmountMap = collectedAmountMap
19104 
    self.xferBy = xferBy
19105 
    self.xferTxnId = xferTxnId
19106 
    self.xferDate = xferDate
19107 
 
19108 
  def read(self, iprot):
19109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19111 
      return
19112 
    iprot.readStructBegin()
19113 
    while True:
19114 
      (fname, ftype, fid) = iprot.readFieldBegin()
19115 
      if ftype == TType.STOP:
19116 
        break
19117 
      if fid == 1:
19118 
        if ftype == TType.MAP:
19119 
          self.collectedAmountMap = {}
6031 rajveer 19120 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19121 
          for _i414 in xrange(_size410):
19122 
            _key415 = iprot.readString();
19123 
            _val416 = iprot.readDouble();
19124 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19125 
          iprot.readMapEnd()
19126 
        else:
19127 
          iprot.skip(ftype)
19128 
      elif fid == 2:
19129 
        if ftype == TType.STRING:
19130 
          self.xferBy = iprot.readString();
19131 
        else:
19132 
          iprot.skip(ftype)
19133 
      elif fid == 3:
19134 
        if ftype == TType.STRING:
19135 
          self.xferTxnId = iprot.readString();
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      elif fid == 4:
19139 
        if ftype == TType.I64:
19140 
          self.xferDate = iprot.readI64();
19141 
        else:
19142 
          iprot.skip(ftype)
19143 
      else:
19144 
        iprot.skip(ftype)
19145 
      iprot.readFieldEnd()
19146 
    iprot.readStructEnd()
19147 
 
19148 
  def write(self, oprot):
19149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19151 
      return
19152 
    oprot.writeStructBegin('reconcileCodCollection_args')
19153 
    if self.collectedAmountMap is not None:
19154 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19155 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19156 
      for kiter417,viter418 in self.collectedAmountMap.items():
19157 
        oprot.writeString(kiter417)
19158 
        oprot.writeDouble(viter418)
3956 chandransh 19159 
      oprot.writeMapEnd()
19160 
      oprot.writeFieldEnd()
19161 
    if self.xferBy is not None:
19162 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19163 
      oprot.writeString(self.xferBy)
19164 
      oprot.writeFieldEnd()
19165 
    if self.xferTxnId is not None:
19166 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19167 
      oprot.writeString(self.xferTxnId)
19168 
      oprot.writeFieldEnd()
19169 
    if self.xferDate is not None:
19170 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19171 
      oprot.writeI64(self.xferDate)
19172 
      oprot.writeFieldEnd()
19173 
    oprot.writeFieldStop()
19174 
    oprot.writeStructEnd()
19175 
 
19176 
  def validate(self):
19177 
    return
19178 
 
19179 
 
19180 
  def __repr__(self):
19181 
    L = ['%s=%r' % (key, value)
19182 
      for key, value in self.__dict__.iteritems()]
19183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19184 
 
19185 
  def __eq__(self, other):
19186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19187 
 
19188 
  def __ne__(self, other):
19189 
    return not (self == other)
19190 
 
19191 
class reconcileCodCollection_result:
19192 
  """
19193 
  Attributes:
19194 
   - success
19195 
   - ex
19196 
  """
19197 
 
19198 
  thrift_spec = (
19199 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19200 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19201 
  )
19202 
 
19203 
  def __init__(self, success=None, ex=None,):
19204 
    self.success = success
19205 
    self.ex = ex
19206 
 
19207 
  def read(self, iprot):
19208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19210 
      return
19211 
    iprot.readStructBegin()
19212 
    while True:
19213 
      (fname, ftype, fid) = iprot.readFieldBegin()
19214 
      if ftype == TType.STOP:
19215 
        break
19216 
      if fid == 0:
19217 
        if ftype == TType.MAP:
19218 
          self.success = {}
6031 rajveer 19219 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19220 
          for _i423 in xrange(_size419):
19221 
            _key424 = iprot.readString();
19222 
            _val425 = iprot.readString();
19223 
            self.success[_key424] = _val425
3956 chandransh 19224 
          iprot.readMapEnd()
19225 
        else:
19226 
          iprot.skip(ftype)
19227 
      elif fid == 1:
19228 
        if ftype == TType.STRUCT:
19229 
          self.ex = TransactionServiceException()
19230 
          self.ex.read(iprot)
19231 
        else:
19232 
          iprot.skip(ftype)
19233 
      else:
19234 
        iprot.skip(ftype)
19235 
      iprot.readFieldEnd()
19236 
    iprot.readStructEnd()
19237 
 
19238 
  def write(self, oprot):
19239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19241 
      return
19242 
    oprot.writeStructBegin('reconcileCodCollection_result')
19243 
    if self.success is not None:
19244 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19245 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19246 
      for kiter426,viter427 in self.success.items():
19247 
        oprot.writeString(kiter426)
19248 
        oprot.writeString(viter427)
3956 chandransh 19249 
      oprot.writeMapEnd()
19250 
      oprot.writeFieldEnd()
19251 
    if self.ex is not None:
19252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19253 
      self.ex.write(oprot)
19254 
      oprot.writeFieldEnd()
19255 
    oprot.writeFieldStop()
19256 
    oprot.writeStructEnd()
19257 
 
19258 
  def validate(self):
19259 
    return
19260 
 
19261 
 
19262 
  def __repr__(self):
19263 
    L = ['%s=%r' % (key, value)
19264 
      for key, value in self.__dict__.iteritems()]
19265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19266 
 
19267 
  def __eq__(self, other):
19268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19269 
 
19270 
  def __ne__(self, other):
19271 
    return not (self == other)
4008 mandeep.dh 19272 
 
19273 
class getTransactionsRequiringExtraProcessing_args:
19274 
  """
19275 
  Attributes:
19276 
   - category
19277 
  """
19278 
 
19279 
  thrift_spec = (
19280 
    None, # 0
19281 
    (1, TType.I32, 'category', None, None, ), # 1
19282 
  )
19283 
 
19284 
  def __init__(self, category=None,):
19285 
    self.category = category
19286 
 
19287 
  def read(self, iprot):
19288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19290 
      return
19291 
    iprot.readStructBegin()
19292 
    while True:
19293 
      (fname, ftype, fid) = iprot.readFieldBegin()
19294 
      if ftype == TType.STOP:
19295 
        break
19296 
      if fid == 1:
19297 
        if ftype == TType.I32:
19298 
          self.category = iprot.readI32();
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      else:
19302 
        iprot.skip(ftype)
19303 
      iprot.readFieldEnd()
19304 
    iprot.readStructEnd()
19305 
 
19306 
  def write(self, oprot):
19307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19309 
      return
19310 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19311 
    if self.category is not None:
19312 
      oprot.writeFieldBegin('category', TType.I32, 1)
19313 
      oprot.writeI32(self.category)
19314 
      oprot.writeFieldEnd()
19315 
    oprot.writeFieldStop()
19316 
    oprot.writeStructEnd()
19317 
 
19318 
  def validate(self):
19319 
    return
19320 
 
19321 
 
19322 
  def __repr__(self):
19323 
    L = ['%s=%r' % (key, value)
19324 
      for key, value in self.__dict__.iteritems()]
19325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19326 
 
19327 
  def __eq__(self, other):
19328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19329 
 
19330 
  def __ne__(self, other):
19331 
    return not (self == other)
19332 
 
19333 
class getTransactionsRequiringExtraProcessing_result:
19334 
  """
19335 
  Attributes:
19336 
   - success
19337 
  """
19338 
 
19339 
  thrift_spec = (
19340 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19341 
  )
19342 
 
19343 
  def __init__(self, success=None,):
19344 
    self.success = success
19345 
 
19346 
  def read(self, iprot):
19347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19349 
      return
19350 
    iprot.readStructBegin()
19351 
    while True:
19352 
      (fname, ftype, fid) = iprot.readFieldBegin()
19353 
      if ftype == TType.STOP:
19354 
        break
19355 
      if fid == 0:
19356 
        if ftype == TType.LIST:
19357 
          self.success = []
6031 rajveer 19358 
          (_etype431, _size428) = iprot.readListBegin()
19359 
          for _i432 in xrange(_size428):
19360 
            _elem433 = iprot.readI64();
19361 
            self.success.append(_elem433)
4008 mandeep.dh 19362 
          iprot.readListEnd()
19363 
        else:
19364 
          iprot.skip(ftype)
19365 
      else:
19366 
        iprot.skip(ftype)
19367 
      iprot.readFieldEnd()
19368 
    iprot.readStructEnd()
19369 
 
19370 
  def write(self, oprot):
19371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19373 
      return
19374 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19375 
    if self.success is not None:
19376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19377 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19378 
      for iter434 in self.success:
19379 
        oprot.writeI64(iter434)
4008 mandeep.dh 19380 
      oprot.writeListEnd()
19381 
      oprot.writeFieldEnd()
19382 
    oprot.writeFieldStop()
19383 
    oprot.writeStructEnd()
19384 
 
19385 
  def validate(self):
19386 
    return
19387 
 
19388 
 
19389 
  def __repr__(self):
19390 
    L = ['%s=%r' % (key, value)
19391 
      for key, value in self.__dict__.iteritems()]
19392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19393 
 
19394 
  def __eq__(self, other):
19395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19396 
 
19397 
  def __ne__(self, other):
19398 
    return not (self == other)
19399 
 
19400 
class markTransactionAsProcessed_args:
19401 
  """
19402 
  Attributes:
19403 
   - transactionId
19404 
   - category
19405 
  """
19406 
 
19407 
  thrift_spec = (
19408 
    None, # 0
19409 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19410 
    (2, TType.I32, 'category', None, None, ), # 2
19411 
  )
19412 
 
19413 
  def __init__(self, transactionId=None, category=None,):
19414 
    self.transactionId = transactionId
19415 
    self.category = category
19416 
 
19417 
  def read(self, iprot):
19418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19420 
      return
19421 
    iprot.readStructBegin()
19422 
    while True:
19423 
      (fname, ftype, fid) = iprot.readFieldBegin()
19424 
      if ftype == TType.STOP:
19425 
        break
19426 
      if fid == 1:
19427 
        if ftype == TType.I64:
19428 
          self.transactionId = iprot.readI64();
19429 
        else:
19430 
          iprot.skip(ftype)
19431 
      elif fid == 2:
19432 
        if ftype == TType.I32:
19433 
          self.category = iprot.readI32();
19434 
        else:
19435 
          iprot.skip(ftype)
19436 
      else:
19437 
        iprot.skip(ftype)
19438 
      iprot.readFieldEnd()
19439 
    iprot.readStructEnd()
19440 
 
19441 
  def write(self, oprot):
19442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19444 
      return
19445 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19446 
    if self.transactionId is not None:
19447 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19448 
      oprot.writeI64(self.transactionId)
19449 
      oprot.writeFieldEnd()
19450 
    if self.category is not None:
19451 
      oprot.writeFieldBegin('category', TType.I32, 2)
19452 
      oprot.writeI32(self.category)
19453 
      oprot.writeFieldEnd()
19454 
    oprot.writeFieldStop()
19455 
    oprot.writeStructEnd()
19456 
 
19457 
  def validate(self):
19458 
    return
19459 
 
19460 
 
19461 
  def __repr__(self):
19462 
    L = ['%s=%r' % (key, value)
19463 
      for key, value in self.__dict__.iteritems()]
19464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19465 
 
19466 
  def __eq__(self, other):
19467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19468 
 
19469 
  def __ne__(self, other):
19470 
    return not (self == other)
19471 
 
19472 
class markTransactionAsProcessed_result:
19473 
 
19474 
  thrift_spec = (
19475 
  )
19476 
 
19477 
  def read(self, iprot):
19478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19480 
      return
19481 
    iprot.readStructBegin()
19482 
    while True:
19483 
      (fname, ftype, fid) = iprot.readFieldBegin()
19484 
      if ftype == TType.STOP:
19485 
        break
19486 
      else:
19487 
        iprot.skip(ftype)
19488 
      iprot.readFieldEnd()
19489 
    iprot.readStructEnd()
19490 
 
19491 
  def write(self, oprot):
19492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19494 
      return
19495 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19496 
    oprot.writeFieldStop()
19497 
    oprot.writeStructEnd()
19498 
 
19499 
  def validate(self):
19500 
    return
19501 
 
19502 
 
19503 
  def __repr__(self):
19504 
    L = ['%s=%r' % (key, value)
19505 
      for key, value in self.__dict__.iteritems()]
19506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19507 
 
19508 
  def __eq__(self, other):
19509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19510 
 
19511 
  def __ne__(self, other):
19512 
    return not (self == other)
4018 chandransh 19513 
 
19514 
class getItemWiseRiskyOrdersCount_args:
19515 
 
19516 
  thrift_spec = (
19517 
  )
19518 
 
19519 
  def read(self, iprot):
19520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19522 
      return
19523 
    iprot.readStructBegin()
19524 
    while True:
19525 
      (fname, ftype, fid) = iprot.readFieldBegin()
19526 
      if ftype == TType.STOP:
19527 
        break
19528 
      else:
19529 
        iprot.skip(ftype)
19530 
      iprot.readFieldEnd()
19531 
    iprot.readStructEnd()
19532 
 
19533 
  def write(self, oprot):
19534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19536 
      return
19537 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19538 
    oprot.writeFieldStop()
19539 
    oprot.writeStructEnd()
19540 
 
19541 
  def validate(self):
19542 
    return
19543 
 
19544 
 
19545 
  def __repr__(self):
19546 
    L = ['%s=%r' % (key, value)
19547 
      for key, value in self.__dict__.iteritems()]
19548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19549 
 
19550 
  def __eq__(self, other):
19551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19552 
 
19553 
  def __ne__(self, other):
19554 
    return not (self == other)
19555 
 
19556 
class getItemWiseRiskyOrdersCount_result:
19557 
  """
19558 
  Attributes:
19559 
   - success
19560 
  """
19561 
 
19562 
  thrift_spec = (
19563 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19564 
  )
19565 
 
19566 
  def __init__(self, success=None,):
19567 
    self.success = success
19568 
 
19569 
  def read(self, iprot):
19570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19572 
      return
19573 
    iprot.readStructBegin()
19574 
    while True:
19575 
      (fname, ftype, fid) = iprot.readFieldBegin()
19576 
      if ftype == TType.STOP:
19577 
        break
19578 
      if fid == 0:
19579 
        if ftype == TType.MAP:
19580 
          self.success = {}
6031 rajveer 19581 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19582 
          for _i439 in xrange(_size435):
19583 
            _key440 = iprot.readI64();
19584 
            _val441 = iprot.readI64();
19585 
            self.success[_key440] = _val441
4018 chandransh 19586 
          iprot.readMapEnd()
19587 
        else:
19588 
          iprot.skip(ftype)
19589 
      else:
19590 
        iprot.skip(ftype)
19591 
      iprot.readFieldEnd()
19592 
    iprot.readStructEnd()
19593 
 
19594 
  def write(self, oprot):
19595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19597 
      return
19598 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19599 
    if self.success is not None:
19600 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19601 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19602 
      for kiter442,viter443 in self.success.items():
19603 
        oprot.writeI64(kiter442)
19604 
        oprot.writeI64(viter443)
4018 chandransh 19605 
      oprot.writeMapEnd()
19606 
      oprot.writeFieldEnd()
19607 
    oprot.writeFieldStop()
19608 
    oprot.writeStructEnd()
19609 
 
19610 
  def validate(self):
19611 
    return
19612 
 
19613 
 
19614 
  def __repr__(self):
19615 
    L = ['%s=%r' % (key, value)
19616 
      for key, value in self.__dict__.iteritems()]
19617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19618 
 
19619 
  def __eq__(self, other):
19620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19621 
 
19622 
  def __ne__(self, other):
19623 
    return not (self == other)
4247 rajveer 19624 
 
4295 varun.gupt 19625 
class getOrdersForItemIds_args:
19626 
  """
19627 
  Attributes:
19628 
   - itemIds
19629 
  """
19630 
 
19631 
  thrift_spec = (
19632 
    None, # 0
19633 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19634 
  )
19635 
 
19636 
  def __init__(self, itemIds=None,):
19637 
    self.itemIds = itemIds
19638 
 
19639 
  def read(self, iprot):
19640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19642 
      return
19643 
    iprot.readStructBegin()
19644 
    while True:
19645 
      (fname, ftype, fid) = iprot.readFieldBegin()
19646 
      if ftype == TType.STOP:
19647 
        break
19648 
      if fid == 1:
19649 
        if ftype == TType.LIST:
19650 
          self.itemIds = []
6031 rajveer 19651 
          (_etype447, _size444) = iprot.readListBegin()
19652 
          for _i448 in xrange(_size444):
19653 
            _elem449 = iprot.readI64();
19654 
            self.itemIds.append(_elem449)
4295 varun.gupt 19655 
          iprot.readListEnd()
19656 
        else:
19657 
          iprot.skip(ftype)
19658 
      else:
19659 
        iprot.skip(ftype)
19660 
      iprot.readFieldEnd()
19661 
    iprot.readStructEnd()
19662 
 
19663 
  def write(self, oprot):
19664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19666 
      return
19667 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19668 
    if self.itemIds is not None:
19669 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19670 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19671 
      for iter450 in self.itemIds:
19672 
        oprot.writeI64(iter450)
4295 varun.gupt 19673 
      oprot.writeListEnd()
19674 
      oprot.writeFieldEnd()
19675 
    oprot.writeFieldStop()
19676 
    oprot.writeStructEnd()
19677 
 
19678 
  def validate(self):
19679 
    return
19680 
 
19681 
 
19682 
  def __repr__(self):
19683 
    L = ['%s=%r' % (key, value)
19684 
      for key, value in self.__dict__.iteritems()]
19685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19686 
 
19687 
  def __eq__(self, other):
19688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19689 
 
19690 
  def __ne__(self, other):
19691 
    return not (self == other)
19692 
 
19693 
class getOrdersForItemIds_result:
19694 
  """
19695 
  Attributes:
19696 
   - success
19697 
  """
19698 
 
19699 
  thrift_spec = (
19700 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19701 
  )
19702 
 
19703 
  def __init__(self, success=None,):
19704 
    self.success = success
19705 
 
19706 
  def read(self, iprot):
19707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19709 
      return
19710 
    iprot.readStructBegin()
19711 
    while True:
19712 
      (fname, ftype, fid) = iprot.readFieldBegin()
19713 
      if ftype == TType.STOP:
19714 
        break
19715 
      if fid == 0:
19716 
        if ftype == TType.LIST:
19717 
          self.success = []
6031 rajveer 19718 
          (_etype454, _size451) = iprot.readListBegin()
19719 
          for _i455 in xrange(_size451):
19720 
            _elem456 = Order()
19721 
            _elem456.read(iprot)
19722 
            self.success.append(_elem456)
4295 varun.gupt 19723 
          iprot.readListEnd()
19724 
        else:
19725 
          iprot.skip(ftype)
19726 
      else:
19727 
        iprot.skip(ftype)
19728 
      iprot.readFieldEnd()
19729 
    iprot.readStructEnd()
19730 
 
19731 
  def write(self, oprot):
19732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19734 
      return
19735 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19736 
    if self.success is not None:
19737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19738 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 19739 
      for iter457 in self.success:
19740 
        iter457.write(oprot)
4295 varun.gupt 19741 
      oprot.writeListEnd()
19742 
      oprot.writeFieldEnd()
19743 
    oprot.writeFieldStop()
19744 
    oprot.writeStructEnd()
19745 
 
19746 
  def validate(self):
19747 
    return
19748 
 
19749 
 
19750 
  def __repr__(self):
19751 
    L = ['%s=%r' % (key, value)
19752 
      for key, value in self.__dict__.iteritems()]
19753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19754 
 
19755 
  def __eq__(self, other):
19756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19757 
 
19758 
  def __ne__(self, other):
19759 
    return not (self == other)
19760 
 
4247 rajveer 19761 
class markOrderCancellationRequestReceived_args:
19762 
  """
19763 
  Attributes:
19764 
   - orderId
19765 
  """
19766 
 
19767 
  thrift_spec = (
19768 
    None, # 0
19769 
    (1, TType.I64, 'orderId', None, None, ), # 1
19770 
  )
19771 
 
19772 
  def __init__(self, orderId=None,):
19773 
    self.orderId = orderId
19774 
 
19775 
  def read(self, iprot):
19776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19778 
      return
19779 
    iprot.readStructBegin()
19780 
    while True:
19781 
      (fname, ftype, fid) = iprot.readFieldBegin()
19782 
      if ftype == TType.STOP:
19783 
        break
19784 
      if fid == 1:
19785 
        if ftype == TType.I64:
19786 
          self.orderId = iprot.readI64();
19787 
        else:
19788 
          iprot.skip(ftype)
19789 
      else:
19790 
        iprot.skip(ftype)
19791 
      iprot.readFieldEnd()
19792 
    iprot.readStructEnd()
19793 
 
19794 
  def write(self, oprot):
19795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19797 
      return
19798 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19799 
    if self.orderId is not None:
19800 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19801 
      oprot.writeI64(self.orderId)
19802 
      oprot.writeFieldEnd()
19803 
    oprot.writeFieldStop()
19804 
    oprot.writeStructEnd()
19805 
 
19806 
  def validate(self):
19807 
    return
19808 
 
19809 
 
19810 
  def __repr__(self):
19811 
    L = ['%s=%r' % (key, value)
19812 
      for key, value in self.__dict__.iteritems()]
19813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19814 
 
19815 
  def __eq__(self, other):
19816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19817 
 
19818 
  def __ne__(self, other):
19819 
    return not (self == other)
19820 
 
19821 
class markOrderCancellationRequestReceived_result:
19822 
  """
19823 
  Attributes:
19824 
   - ex
19825 
  """
19826 
 
19827 
  thrift_spec = (
19828 
    None, # 0
19829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19830 
  )
19831 
 
19832 
  def __init__(self, ex=None,):
19833 
    self.ex = ex
19834 
 
19835 
  def read(self, iprot):
19836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19838 
      return
19839 
    iprot.readStructBegin()
19840 
    while True:
19841 
      (fname, ftype, fid) = iprot.readFieldBegin()
19842 
      if ftype == TType.STOP:
19843 
        break
19844 
      if fid == 1:
19845 
        if ftype == TType.STRUCT:
19846 
          self.ex = TransactionServiceException()
19847 
          self.ex.read(iprot)
19848 
        else:
19849 
          iprot.skip(ftype)
19850 
      else:
19851 
        iprot.skip(ftype)
19852 
      iprot.readFieldEnd()
19853 
    iprot.readStructEnd()
19854 
 
19855 
  def write(self, oprot):
19856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19858 
      return
19859 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19860 
    if self.ex is not None:
19861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19862 
      self.ex.write(oprot)
19863 
      oprot.writeFieldEnd()
19864 
    oprot.writeFieldStop()
19865 
    oprot.writeStructEnd()
19866 
 
19867 
  def validate(self):
19868 
    return
19869 
 
19870 
 
19871 
  def __repr__(self):
19872 
    L = ['%s=%r' % (key, value)
19873 
      for key, value in self.__dict__.iteritems()]
19874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19875 
 
19876 
  def __eq__(self, other):
19877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19878 
 
19879 
  def __ne__(self, other):
19880 
    return not (self == other)
19881 
 
19882 
class markOrderCancellationRequestConfirmed_args:
19883 
  """
19884 
  Attributes:
19885 
   - orderId
19886 
  """
19887 
 
19888 
  thrift_spec = (
19889 
    None, # 0
19890 
    (1, TType.I64, 'orderId', None, None, ), # 1
19891 
  )
19892 
 
19893 
  def __init__(self, orderId=None,):
19894 
    self.orderId = orderId
19895 
 
19896 
  def read(self, iprot):
19897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19899 
      return
19900 
    iprot.readStructBegin()
19901 
    while True:
19902 
      (fname, ftype, fid) = iprot.readFieldBegin()
19903 
      if ftype == TType.STOP:
19904 
        break
19905 
      if fid == 1:
19906 
        if ftype == TType.I64:
19907 
          self.orderId = iprot.readI64();
19908 
        else:
19909 
          iprot.skip(ftype)
19910 
      else:
19911 
        iprot.skip(ftype)
19912 
      iprot.readFieldEnd()
19913 
    iprot.readStructEnd()
19914 
 
19915 
  def write(self, oprot):
19916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19918 
      return
19919 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19920 
    if self.orderId is not None:
19921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19922 
      oprot.writeI64(self.orderId)
19923 
      oprot.writeFieldEnd()
19924 
    oprot.writeFieldStop()
19925 
    oprot.writeStructEnd()
19926 
 
19927 
  def validate(self):
19928 
    return
19929 
 
19930 
 
19931 
  def __repr__(self):
19932 
    L = ['%s=%r' % (key, value)
19933 
      for key, value in self.__dict__.iteritems()]
19934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19935 
 
19936 
  def __eq__(self, other):
19937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19938 
 
19939 
  def __ne__(self, other):
19940 
    return not (self == other)
19941 
 
19942 
class markOrderCancellationRequestConfirmed_result:
19943 
  """
19944 
  Attributes:
19945 
   - ex
19946 
  """
19947 
 
19948 
  thrift_spec = (
19949 
    None, # 0
19950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19951 
  )
19952 
 
19953 
  def __init__(self, ex=None,):
19954 
    self.ex = ex
19955 
 
19956 
  def read(self, iprot):
19957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19959 
      return
19960 
    iprot.readStructBegin()
19961 
    while True:
19962 
      (fname, ftype, fid) = iprot.readFieldBegin()
19963 
      if ftype == TType.STOP:
19964 
        break
19965 
      if fid == 1:
19966 
        if ftype == TType.STRUCT:
19967 
          self.ex = TransactionServiceException()
19968 
          self.ex.read(iprot)
19969 
        else:
19970 
          iprot.skip(ftype)
19971 
      else:
19972 
        iprot.skip(ftype)
19973 
      iprot.readFieldEnd()
19974 
    iprot.readStructEnd()
19975 
 
19976 
  def write(self, oprot):
19977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19979 
      return
19980 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19981 
    if self.ex is not None:
19982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19983 
      self.ex.write(oprot)
19984 
      oprot.writeFieldEnd()
19985 
    oprot.writeFieldStop()
19986 
    oprot.writeStructEnd()
19987 
 
19988 
  def validate(self):
19989 
    return
19990 
 
19991 
 
19992 
  def __repr__(self):
19993 
    L = ['%s=%r' % (key, value)
19994 
      for key, value in self.__dict__.iteritems()]
19995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19996 
 
19997 
  def __eq__(self, other):
19998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19999 
 
20000 
  def __ne__(self, other):
20001 
    return not (self == other)
20002 
 
20003 
class markOrderCancellationRequestDenied_args:
20004 
  """
20005 
  Attributes:
20006 
   - orderId
20007 
  """
20008 
 
20009 
  thrift_spec = (
20010 
    None, # 0
20011 
    (1, TType.I64, 'orderId', None, None, ), # 1
20012 
  )
20013 
 
20014 
  def __init__(self, orderId=None,):
20015 
    self.orderId = orderId
20016 
 
20017 
  def read(self, iprot):
20018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20020 
      return
20021 
    iprot.readStructBegin()
20022 
    while True:
20023 
      (fname, ftype, fid) = iprot.readFieldBegin()
20024 
      if ftype == TType.STOP:
20025 
        break
20026 
      if fid == 1:
20027 
        if ftype == TType.I64:
20028 
          self.orderId = iprot.readI64();
20029 
        else:
20030 
          iprot.skip(ftype)
20031 
      else:
20032 
        iprot.skip(ftype)
20033 
      iprot.readFieldEnd()
20034 
    iprot.readStructEnd()
20035 
 
20036 
  def write(self, oprot):
20037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20039 
      return
20040 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20041 
    if self.orderId is not None:
20042 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20043 
      oprot.writeI64(self.orderId)
20044 
      oprot.writeFieldEnd()
20045 
    oprot.writeFieldStop()
20046 
    oprot.writeStructEnd()
20047 
 
20048 
  def validate(self):
20049 
    return
20050 
 
20051 
 
20052 
  def __repr__(self):
20053 
    L = ['%s=%r' % (key, value)
20054 
      for key, value in self.__dict__.iteritems()]
20055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20056 
 
20057 
  def __eq__(self, other):
20058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20059 
 
20060 
  def __ne__(self, other):
20061 
    return not (self == other)
20062 
 
20063 
class markOrderCancellationRequestDenied_result:
20064 
  """
20065 
  Attributes:
20066 
   - ex
20067 
  """
20068 
 
20069 
  thrift_spec = (
20070 
    None, # 0
20071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20072 
  )
20073 
 
20074 
  def __init__(self, ex=None,):
20075 
    self.ex = ex
20076 
 
20077 
  def read(self, iprot):
20078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20080 
      return
20081 
    iprot.readStructBegin()
20082 
    while True:
20083 
      (fname, ftype, fid) = iprot.readFieldBegin()
20084 
      if ftype == TType.STOP:
20085 
        break
20086 
      if fid == 1:
20087 
        if ftype == TType.STRUCT:
20088 
          self.ex = TransactionServiceException()
20089 
          self.ex.read(iprot)
20090 
        else:
20091 
          iprot.skip(ftype)
20092 
      else:
20093 
        iprot.skip(ftype)
20094 
      iprot.readFieldEnd()
20095 
    iprot.readStructEnd()
20096 
 
20097 
  def write(self, oprot):
20098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20100 
      return
20101 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20102 
    if self.ex is not None:
20103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20104 
      self.ex.write(oprot)
20105 
      oprot.writeFieldEnd()
20106 
    oprot.writeFieldStop()
20107 
    oprot.writeStructEnd()
20108 
 
20109 
  def validate(self):
20110 
    return
20111 
 
20112 
 
20113 
  def __repr__(self):
20114 
    L = ['%s=%r' % (key, value)
20115 
      for key, value in self.__dict__.iteritems()]
20116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20117 
 
20118 
  def __eq__(self, other):
20119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20120 
 
20121 
  def __ne__(self, other):
20122 
    return not (self == other)
20123 
 
4258 rajveer 20124 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20125 
  """
20126 
  Attributes:
4258 rajveer 20127 
   - transactionId
4247 rajveer 20128 
  """
20129 
 
20130 
  thrift_spec = (
20131 
    None, # 0
4258 rajveer 20132 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20133 
  )
20134 
 
4258 rajveer 20135 
  def __init__(self, transactionId=None,):
20136 
    self.transactionId = transactionId
4247 rajveer 20137 
 
20138 
  def read(self, iprot):
20139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20141 
      return
20142 
    iprot.readStructBegin()
20143 
    while True:
20144 
      (fname, ftype, fid) = iprot.readFieldBegin()
20145 
      if ftype == TType.STOP:
20146 
        break
20147 
      if fid == 1:
20148 
        if ftype == TType.I64:
4258 rajveer 20149 
          self.transactionId = iprot.readI64();
4247 rajveer 20150 
        else:
20151 
          iprot.skip(ftype)
20152 
      else:
20153 
        iprot.skip(ftype)
20154 
      iprot.readFieldEnd()
20155 
    iprot.readStructEnd()
20156 
 
20157 
  def write(self, oprot):
20158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20160 
      return
4258 rajveer 20161 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20162 
    if self.transactionId is not None:
20163 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20164 
      oprot.writeI64(self.transactionId)
4247 rajveer 20165 
      oprot.writeFieldEnd()
20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
4258 rajveer 20184 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20185 
  """
20186 
  Attributes:
20187 
   - ex
20188 
  """
20189 
 
20190 
  thrift_spec = (
20191 
    None, # 0
20192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20193 
  )
20194 
 
20195 
  def __init__(self, ex=None,):
20196 
    self.ex = ex
20197 
 
20198 
  def read(self, iprot):
20199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20201 
      return
20202 
    iprot.readStructBegin()
20203 
    while True:
20204 
      (fname, ftype, fid) = iprot.readFieldBegin()
20205 
      if ftype == TType.STOP:
20206 
        break
20207 
      if fid == 1:
20208 
        if ftype == TType.STRUCT:
20209 
          self.ex = TransactionServiceException()
20210 
          self.ex.read(iprot)
20211 
        else:
20212 
          iprot.skip(ftype)
20213 
      else:
20214 
        iprot.skip(ftype)
20215 
      iprot.readFieldEnd()
20216 
    iprot.readStructEnd()
20217 
 
20218 
  def write(self, oprot):
20219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20221 
      return
4258 rajveer 20222 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20223 
    if self.ex is not None:
20224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20225 
      self.ex.write(oprot)
20226 
      oprot.writeFieldEnd()
20227 
    oprot.writeFieldStop()
20228 
    oprot.writeStructEnd()
20229 
 
20230 
  def validate(self):
20231 
    return
20232 
 
20233 
 
20234 
  def __repr__(self):
20235 
    L = ['%s=%r' % (key, value)
20236 
      for key, value in self.__dict__.iteritems()]
20237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20238 
 
20239 
  def __eq__(self, other):
20240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20241 
 
20242 
  def __ne__(self, other):
20243 
    return not (self == other)
4259 anupam.sin 20244 
 
20245 
class refundTransaction_args:
20246 
  """
20247 
  Attributes:
20248 
   - transactionId
20249 
   - refundedBy
20250 
   - reason
20251 
  """
20252 
 
20253 
  thrift_spec = (
20254 
    None, # 0
20255 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20256 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20257 
    (3, TType.STRING, 'reason', None, None, ), # 3
20258 
  )
20259 
 
20260 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20261 
    self.transactionId = transactionId
20262 
    self.refundedBy = refundedBy
20263 
    self.reason = reason
20264 
 
20265 
  def read(self, iprot):
20266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20268 
      return
20269 
    iprot.readStructBegin()
20270 
    while True:
20271 
      (fname, ftype, fid) = iprot.readFieldBegin()
20272 
      if ftype == TType.STOP:
20273 
        break
20274 
      if fid == 1:
20275 
        if ftype == TType.I64:
20276 
          self.transactionId = iprot.readI64();
20277 
        else:
20278 
          iprot.skip(ftype)
20279 
      elif fid == 2:
20280 
        if ftype == TType.STRING:
20281 
          self.refundedBy = iprot.readString();
20282 
        else:
20283 
          iprot.skip(ftype)
20284 
      elif fid == 3:
20285 
        if ftype == TType.STRING:
20286 
          self.reason = iprot.readString();
20287 
        else:
20288 
          iprot.skip(ftype)
20289 
      else:
20290 
        iprot.skip(ftype)
20291 
      iprot.readFieldEnd()
20292 
    iprot.readStructEnd()
20293 
 
20294 
  def write(self, oprot):
20295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20297 
      return
20298 
    oprot.writeStructBegin('refundTransaction_args')
20299 
    if self.transactionId is not None:
20300 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20301 
      oprot.writeI64(self.transactionId)
20302 
      oprot.writeFieldEnd()
20303 
    if self.refundedBy is not None:
20304 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20305 
      oprot.writeString(self.refundedBy)
20306 
      oprot.writeFieldEnd()
20307 
    if self.reason is not None:
20308 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20309 
      oprot.writeString(self.reason)
20310 
      oprot.writeFieldEnd()
20311 
    oprot.writeFieldStop()
20312 
    oprot.writeStructEnd()
20313 
 
20314 
  def validate(self):
20315 
    return
20316 
 
20317 
 
20318 
  def __repr__(self):
20319 
    L = ['%s=%r' % (key, value)
20320 
      for key, value in self.__dict__.iteritems()]
20321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20322 
 
20323 
  def __eq__(self, other):
20324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20325 
 
20326 
  def __ne__(self, other):
20327 
    return not (self == other)
20328 
 
20329 
class refundTransaction_result:
20330 
  """
20331 
  Attributes:
20332 
   - ex
20333 
  """
20334 
 
20335 
  thrift_spec = (
20336 
    None, # 0
20337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20338 
  )
20339 
 
20340 
  def __init__(self, ex=None,):
20341 
    self.ex = ex
20342 
 
20343 
  def read(self, iprot):
20344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20346 
      return
20347 
    iprot.readStructBegin()
20348 
    while True:
20349 
      (fname, ftype, fid) = iprot.readFieldBegin()
20350 
      if ftype == TType.STOP:
20351 
        break
20352 
      if fid == 1:
20353 
        if ftype == TType.STRUCT:
20354 
          self.ex = TransactionServiceException()
20355 
          self.ex.read(iprot)
20356 
        else:
20357 
          iprot.skip(ftype)
20358 
      else:
20359 
        iprot.skip(ftype)
20360 
      iprot.readFieldEnd()
20361 
    iprot.readStructEnd()
20362 
 
20363 
  def write(self, oprot):
20364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20366 
      return
20367 
    oprot.writeStructBegin('refundTransaction_result')
20368 
    if self.ex is not None:
20369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20370 
      self.ex.write(oprot)
20371 
      oprot.writeFieldEnd()
20372 
    oprot.writeFieldStop()
20373 
    oprot.writeStructEnd()
20374 
 
20375 
  def validate(self):
20376 
    return
20377 
 
20378 
 
20379 
  def __repr__(self):
20380 
    L = ['%s=%r' % (key, value)
20381 
      for key, value in self.__dict__.iteritems()]
20382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20383 
 
20384 
  def __eq__(self, other):
20385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20386 
 
20387 
  def __ne__(self, other):
20388 
    return not (self == other)
4285 rajveer 20389 
 
4324 mandeep.dh 20390 
class updateShipmentAddress_args:
20391 
  """
20392 
  Attributes:
20393 
   - orderId
20394 
   - addressId
20395 
  """
20396 
 
20397 
  thrift_spec = (
20398 
    None, # 0
20399 
    (1, TType.I64, 'orderId', None, None, ), # 1
20400 
    (2, TType.I64, 'addressId', None, None, ), # 2
20401 
  )
20402 
 
20403 
  def __init__(self, orderId=None, addressId=None,):
20404 
    self.orderId = orderId
20405 
    self.addressId = addressId
20406 
 
20407 
  def read(self, iprot):
20408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20410 
      return
20411 
    iprot.readStructBegin()
20412 
    while True:
20413 
      (fname, ftype, fid) = iprot.readFieldBegin()
20414 
      if ftype == TType.STOP:
20415 
        break
20416 
      if fid == 1:
20417 
        if ftype == TType.I64:
20418 
          self.orderId = iprot.readI64();
20419 
        else:
20420 
          iprot.skip(ftype)
20421 
      elif fid == 2:
20422 
        if ftype == TType.I64:
20423 
          self.addressId = iprot.readI64();
20424 
        else:
20425 
          iprot.skip(ftype)
20426 
      else:
20427 
        iprot.skip(ftype)
20428 
      iprot.readFieldEnd()
20429 
    iprot.readStructEnd()
20430 
 
20431 
  def write(self, oprot):
20432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20434 
      return
20435 
    oprot.writeStructBegin('updateShipmentAddress_args')
20436 
    if self.orderId is not None:
20437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20438 
      oprot.writeI64(self.orderId)
20439 
      oprot.writeFieldEnd()
20440 
    if self.addressId is not None:
20441 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20442 
      oprot.writeI64(self.addressId)
20443 
      oprot.writeFieldEnd()
20444 
    oprot.writeFieldStop()
20445 
    oprot.writeStructEnd()
20446 
 
20447 
  def validate(self):
20448 
    return
20449 
 
20450 
 
20451 
  def __repr__(self):
20452 
    L = ['%s=%r' % (key, value)
20453 
      for key, value in self.__dict__.iteritems()]
20454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20455 
 
20456 
  def __eq__(self, other):
20457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20458 
 
20459 
  def __ne__(self, other):
20460 
    return not (self == other)
20461 
 
20462 
class updateShipmentAddress_result:
20463 
  """
20464 
  Attributes:
20465 
   - ex
20466 
  """
20467 
 
20468 
  thrift_spec = (
20469 
    None, # 0
20470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20471 
  )
20472 
 
20473 
  def __init__(self, ex=None,):
20474 
    self.ex = ex
20475 
 
20476 
  def read(self, iprot):
20477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20479 
      return
20480 
    iprot.readStructBegin()
20481 
    while True:
20482 
      (fname, ftype, fid) = iprot.readFieldBegin()
20483 
      if ftype == TType.STOP:
20484 
        break
20485 
      if fid == 1:
20486 
        if ftype == TType.STRUCT:
20487 
          self.ex = TransactionServiceException()
20488 
          self.ex.read(iprot)
20489 
        else:
20490 
          iprot.skip(ftype)
20491 
      else:
20492 
        iprot.skip(ftype)
20493 
      iprot.readFieldEnd()
20494 
    iprot.readStructEnd()
20495 
 
20496 
  def write(self, oprot):
20497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20499 
      return
20500 
    oprot.writeStructBegin('updateShipmentAddress_result')
20501 
    if self.ex is not None:
20502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20503 
      self.ex.write(oprot)
20504 
      oprot.writeFieldEnd()
20505 
    oprot.writeFieldStop()
20506 
    oprot.writeStructEnd()
20507 
 
20508 
  def validate(self):
20509 
    return
20510 
 
20511 
 
20512 
  def __repr__(self):
20513 
    L = ['%s=%r' % (key, value)
20514 
      for key, value in self.__dict__.iteritems()]
20515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20516 
 
20517 
  def __eq__(self, other):
20518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20519 
 
20520 
  def __ne__(self, other):
20521 
    return not (self == other)
20522 
 
4285 rajveer 20523 
class acceptOrdersForItemId_args:
20524 
  """
20525 
  Attributes:
20526 
   - itemId
20527 
   - inventory
20528 
  """
20529 
 
20530 
  thrift_spec = (
20531 
    None, # 0
20532 
    (1, TType.I64, 'itemId', None, None, ), # 1
20533 
    (2, TType.I64, 'inventory', None, None, ), # 2
20534 
  )
20535 
 
20536 
  def __init__(self, itemId=None, inventory=None,):
20537 
    self.itemId = itemId
20538 
    self.inventory = inventory
20539 
 
20540 
  def read(self, iprot):
20541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20543 
      return
20544 
    iprot.readStructBegin()
20545 
    while True:
20546 
      (fname, ftype, fid) = iprot.readFieldBegin()
20547 
      if ftype == TType.STOP:
20548 
        break
20549 
      if fid == 1:
20550 
        if ftype == TType.I64:
20551 
          self.itemId = iprot.readI64();
20552 
        else:
20553 
          iprot.skip(ftype)
20554 
      elif fid == 2:
20555 
        if ftype == TType.I64:
20556 
          self.inventory = iprot.readI64();
20557 
        else:
20558 
          iprot.skip(ftype)
20559 
      else:
20560 
        iprot.skip(ftype)
20561 
      iprot.readFieldEnd()
20562 
    iprot.readStructEnd()
20563 
 
20564 
  def write(self, oprot):
20565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20567 
      return
20568 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20569 
    if self.itemId is not None:
20570 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20571 
      oprot.writeI64(self.itemId)
20572 
      oprot.writeFieldEnd()
20573 
    if self.inventory is not None:
20574 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20575 
      oprot.writeI64(self.inventory)
20576 
      oprot.writeFieldEnd()
20577 
    oprot.writeFieldStop()
20578 
    oprot.writeStructEnd()
20579 
 
20580 
  def validate(self):
20581 
    return
20582 
 
20583 
 
20584 
  def __repr__(self):
20585 
    L = ['%s=%r' % (key, value)
20586 
      for key, value in self.__dict__.iteritems()]
20587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20588 
 
20589 
  def __eq__(self, other):
20590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20591 
 
20592 
  def __ne__(self, other):
20593 
    return not (self == other)
20594 
 
20595 
class acceptOrdersForItemId_result:
20596 
  """
20597 
  Attributes:
20598 
   - success
20599 
   - ex
20600 
  """
20601 
 
20602 
  thrift_spec = (
20603 
    (0, TType.BOOL, 'success', None, None, ), # 0
20604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20605 
  )
20606 
 
20607 
  def __init__(self, success=None, ex=None,):
20608 
    self.success = success
20609 
    self.ex = ex
20610 
 
20611 
  def read(self, iprot):
20612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20614 
      return
20615 
    iprot.readStructBegin()
20616 
    while True:
20617 
      (fname, ftype, fid) = iprot.readFieldBegin()
20618 
      if ftype == TType.STOP:
20619 
        break
20620 
      if fid == 0:
20621 
        if ftype == TType.BOOL:
20622 
          self.success = iprot.readBool();
20623 
        else:
20624 
          iprot.skip(ftype)
20625 
      elif fid == 1:
20626 
        if ftype == TType.STRUCT:
20627 
          self.ex = TransactionServiceException()
20628 
          self.ex.read(iprot)
20629 
        else:
20630 
          iprot.skip(ftype)
20631 
      else:
20632 
        iprot.skip(ftype)
20633 
      iprot.readFieldEnd()
20634 
    iprot.readStructEnd()
20635 
 
20636 
  def write(self, oprot):
20637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20639 
      return
20640 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20641 
    if self.success is not None:
20642 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20643 
      oprot.writeBool(self.success)
20644 
      oprot.writeFieldEnd()
20645 
    if self.ex is not None:
20646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20647 
      self.ex.write(oprot)
20648 
      oprot.writeFieldEnd()
20649 
    oprot.writeFieldStop()
20650 
    oprot.writeStructEnd()
20651 
 
20652 
  def validate(self):
20653 
    return
20654 
 
20655 
 
20656 
  def __repr__(self):
20657 
    L = ['%s=%r' % (key, value)
20658 
      for key, value in self.__dict__.iteritems()]
20659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20660 
 
20661 
  def __eq__(self, other):
20662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20663 
 
20664 
  def __ne__(self, other):
20665 
    return not (self == other)
4303 rajveer 20666 
 
20667 
class markOrdersAsPORaised_args:
20668 
  """
20669 
  Attributes:
20670 
   - vendorId
20671 
   - itemId
20672 
   - quantity
20673 
   - estimate
4369 rajveer 20674 
   - isReminder
4303 rajveer 20675 
  """
20676 
 
20677 
  thrift_spec = (
20678 
    None, # 0
20679 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20680 
    (2, TType.I64, 'itemId', None, None, ), # 2
20681 
    (3, TType.I64, 'quantity', None, None, ), # 3
20682 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20683 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20684 
  )
20685 
 
4369 rajveer 20686 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20687 
    self.vendorId = vendorId
20688 
    self.itemId = itemId
20689 
    self.quantity = quantity
20690 
    self.estimate = estimate
4369 rajveer 20691 
    self.isReminder = isReminder
4303 rajveer 20692 
 
20693 
  def read(self, iprot):
20694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20696 
      return
20697 
    iprot.readStructBegin()
20698 
    while True:
20699 
      (fname, ftype, fid) = iprot.readFieldBegin()
20700 
      if ftype == TType.STOP:
20701 
        break
20702 
      if fid == 1:
20703 
        if ftype == TType.I64:
20704 
          self.vendorId = iprot.readI64();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      elif fid == 2:
20708 
        if ftype == TType.I64:
20709 
          self.itemId = iprot.readI64();
20710 
        else:
20711 
          iprot.skip(ftype)
20712 
      elif fid == 3:
20713 
        if ftype == TType.I64:
20714 
          self.quantity = iprot.readI64();
20715 
        else:
20716 
          iprot.skip(ftype)
20717 
      elif fid == 4:
20718 
        if ftype == TType.I64:
20719 
          self.estimate = iprot.readI64();
20720 
        else:
20721 
          iprot.skip(ftype)
4369 rajveer 20722 
      elif fid == 5:
20723 
        if ftype == TType.BOOL:
20724 
          self.isReminder = iprot.readBool();
20725 
        else:
20726 
          iprot.skip(ftype)
4303 rajveer 20727 
      else:
20728 
        iprot.skip(ftype)
20729 
      iprot.readFieldEnd()
20730 
    iprot.readStructEnd()
20731 
 
20732 
  def write(self, oprot):
20733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20735 
      return
20736 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20737 
    if self.vendorId is not None:
20738 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20739 
      oprot.writeI64(self.vendorId)
20740 
      oprot.writeFieldEnd()
20741 
    if self.itemId is not None:
20742 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20743 
      oprot.writeI64(self.itemId)
20744 
      oprot.writeFieldEnd()
20745 
    if self.quantity is not None:
20746 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20747 
      oprot.writeI64(self.quantity)
20748 
      oprot.writeFieldEnd()
20749 
    if self.estimate is not None:
20750 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20751 
      oprot.writeI64(self.estimate)
20752 
      oprot.writeFieldEnd()
4369 rajveer 20753 
    if self.isReminder is not None:
20754 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20755 
      oprot.writeBool(self.isReminder)
20756 
      oprot.writeFieldEnd()
4303 rajveer 20757 
    oprot.writeFieldStop()
20758 
    oprot.writeStructEnd()
20759 
 
20760 
  def validate(self):
20761 
    return
20762 
 
20763 
 
20764 
  def __repr__(self):
20765 
    L = ['%s=%r' % (key, value)
20766 
      for key, value in self.__dict__.iteritems()]
20767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20768 
 
20769 
  def __eq__(self, other):
20770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20771 
 
20772 
  def __ne__(self, other):
20773 
    return not (self == other)
20774 
 
20775 
class markOrdersAsPORaised_result:
20776 
  """
20777 
  Attributes:
20778 
   - ex
20779 
  """
20780 
 
20781 
  thrift_spec = (
20782 
    None, # 0
20783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20784 
  )
20785 
 
20786 
  def __init__(self, ex=None,):
20787 
    self.ex = ex
20788 
 
20789 
  def read(self, iprot):
20790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20792 
      return
20793 
    iprot.readStructBegin()
20794 
    while True:
20795 
      (fname, ftype, fid) = iprot.readFieldBegin()
20796 
      if ftype == TType.STOP:
20797 
        break
20798 
      if fid == 1:
20799 
        if ftype == TType.STRUCT:
20800 
          self.ex = TransactionServiceException()
20801 
          self.ex.read(iprot)
20802 
        else:
20803 
          iprot.skip(ftype)
20804 
      else:
20805 
        iprot.skip(ftype)
20806 
      iprot.readFieldEnd()
20807 
    iprot.readStructEnd()
20808 
 
20809 
  def write(self, oprot):
20810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20812 
      return
20813 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20814 
    if self.ex is not None:
20815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20816 
      self.ex.write(oprot)
20817 
      oprot.writeFieldEnd()
20818 
    oprot.writeFieldStop()
20819 
    oprot.writeStructEnd()
20820 
 
20821 
  def validate(self):
20822 
    return
20823 
 
20824 
 
20825 
  def __repr__(self):
20826 
    L = ['%s=%r' % (key, value)
20827 
      for key, value in self.__dict__.iteritems()]
20828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20829 
 
20830 
  def __eq__(self, other):
20831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20832 
 
20833 
  def __ne__(self, other):
20834 
    return not (self == other)
20835 
 
20836 
class markOrdersAsReversalInitiated_args:
20837 
  """
20838 
  Attributes:
20839 
   - vendorId
20840 
   - itemId
20841 
   - quantity
20842 
   - estimate
4369 rajveer 20843 
   - isReminder
4303 rajveer 20844 
  """
20845 
 
20846 
  thrift_spec = (
20847 
    None, # 0
20848 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20849 
    (2, TType.I64, 'itemId', None, None, ), # 2
20850 
    (3, TType.I64, 'quantity', None, None, ), # 3
20851 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20852 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20853 
  )
20854 
 
4369 rajveer 20855 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20856 
    self.vendorId = vendorId
20857 
    self.itemId = itemId
20858 
    self.quantity = quantity
20859 
    self.estimate = estimate
4369 rajveer 20860 
    self.isReminder = isReminder
4303 rajveer 20861 
 
20862 
  def read(self, iprot):
20863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20865 
      return
20866 
    iprot.readStructBegin()
20867 
    while True:
20868 
      (fname, ftype, fid) = iprot.readFieldBegin()
20869 
      if ftype == TType.STOP:
20870 
        break
20871 
      if fid == 1:
20872 
        if ftype == TType.I64:
20873 
          self.vendorId = iprot.readI64();
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      elif fid == 2:
20877 
        if ftype == TType.I64:
20878 
          self.itemId = iprot.readI64();
20879 
        else:
20880 
          iprot.skip(ftype)
20881 
      elif fid == 3:
20882 
        if ftype == TType.I64:
20883 
          self.quantity = iprot.readI64();
20884 
        else:
20885 
          iprot.skip(ftype)
20886 
      elif fid == 4:
20887 
        if ftype == TType.I64:
20888 
          self.estimate = iprot.readI64();
20889 
        else:
20890 
          iprot.skip(ftype)
4369 rajveer 20891 
      elif fid == 5:
20892 
        if ftype == TType.BOOL:
20893 
          self.isReminder = iprot.readBool();
20894 
        else:
20895 
          iprot.skip(ftype)
4303 rajveer 20896 
      else:
20897 
        iprot.skip(ftype)
20898 
      iprot.readFieldEnd()
20899 
    iprot.readStructEnd()
20900 
 
20901 
  def write(self, oprot):
20902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20904 
      return
20905 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20906 
    if self.vendorId is not None:
20907 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20908 
      oprot.writeI64(self.vendorId)
20909 
      oprot.writeFieldEnd()
20910 
    if self.itemId is not None:
20911 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20912 
      oprot.writeI64(self.itemId)
20913 
      oprot.writeFieldEnd()
20914 
    if self.quantity is not None:
20915 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20916 
      oprot.writeI64(self.quantity)
20917 
      oprot.writeFieldEnd()
20918 
    if self.estimate is not None:
20919 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20920 
      oprot.writeI64(self.estimate)
20921 
      oprot.writeFieldEnd()
4369 rajveer 20922 
    if self.isReminder is not None:
20923 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20924 
      oprot.writeBool(self.isReminder)
20925 
      oprot.writeFieldEnd()
4303 rajveer 20926 
    oprot.writeFieldStop()
20927 
    oprot.writeStructEnd()
20928 
 
20929 
  def validate(self):
20930 
    return
20931 
 
20932 
 
20933 
  def __repr__(self):
20934 
    L = ['%s=%r' % (key, value)
20935 
      for key, value in self.__dict__.iteritems()]
20936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20937 
 
20938 
  def __eq__(self, other):
20939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20940 
 
20941 
  def __ne__(self, other):
20942 
    return not (self == other)
20943 
 
20944 
class markOrdersAsReversalInitiated_result:
20945 
  """
20946 
  Attributes:
20947 
   - ex
20948 
  """
20949 
 
20950 
  thrift_spec = (
20951 
    None, # 0
20952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20953 
  )
20954 
 
20955 
  def __init__(self, ex=None,):
20956 
    self.ex = ex
20957 
 
20958 
  def read(self, iprot):
20959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20961 
      return
20962 
    iprot.readStructBegin()
20963 
    while True:
20964 
      (fname, ftype, fid) = iprot.readFieldBegin()
20965 
      if ftype == TType.STOP:
20966 
        break
20967 
      if fid == 1:
20968 
        if ftype == TType.STRUCT:
20969 
          self.ex = TransactionServiceException()
20970 
          self.ex.read(iprot)
20971 
        else:
20972 
          iprot.skip(ftype)
20973 
      else:
20974 
        iprot.skip(ftype)
20975 
      iprot.readFieldEnd()
20976 
    iprot.readStructEnd()
20977 
 
20978 
  def write(self, oprot):
20979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20981 
      return
20982 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20983 
    if self.ex is not None:
20984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20985 
      self.ex.write(oprot)
20986 
      oprot.writeFieldEnd()
20987 
    oprot.writeFieldStop()
20988 
    oprot.writeStructEnd()
20989 
 
20990 
  def validate(self):
20991 
    return
20992 
 
20993 
 
20994 
  def __repr__(self):
20995 
    L = ['%s=%r' % (key, value)
20996 
      for key, value in self.__dict__.iteritems()]
20997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20998 
 
20999 
  def __eq__(self, other):
21000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21001 
 
21002 
  def __ne__(self, other):
21003 
    return not (self == other)
21004 
 
21005 
class markOrdersAsNotAvailabke_args:
21006 
  """
21007 
  Attributes:
21008 
   - vendorId
21009 
   - itemId
21010 
   - quantity
21011 
   - estimate
4369 rajveer 21012 
   - isReminder
4303 rajveer 21013 
  """
21014 
 
21015 
  thrift_spec = (
21016 
    None, # 0
21017 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21018 
    (2, TType.I64, 'itemId', None, None, ), # 2
21019 
    (3, TType.I64, 'quantity', None, None, ), # 3
21020 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21021 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21022 
  )
21023 
 
4369 rajveer 21024 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21025 
    self.vendorId = vendorId
21026 
    self.itemId = itemId
21027 
    self.quantity = quantity
21028 
    self.estimate = estimate
4369 rajveer 21029 
    self.isReminder = isReminder
4303 rajveer 21030 
 
21031 
  def read(self, iprot):
21032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21034 
      return
21035 
    iprot.readStructBegin()
21036 
    while True:
21037 
      (fname, ftype, fid) = iprot.readFieldBegin()
21038 
      if ftype == TType.STOP:
21039 
        break
21040 
      if fid == 1:
21041 
        if ftype == TType.I64:
21042 
          self.vendorId = iprot.readI64();
21043 
        else:
21044 
          iprot.skip(ftype)
21045 
      elif fid == 2:
21046 
        if ftype == TType.I64:
21047 
          self.itemId = iprot.readI64();
21048 
        else:
21049 
          iprot.skip(ftype)
21050 
      elif fid == 3:
21051 
        if ftype == TType.I64:
21052 
          self.quantity = iprot.readI64();
21053 
        else:
21054 
          iprot.skip(ftype)
21055 
      elif fid == 4:
21056 
        if ftype == TType.I64:
21057 
          self.estimate = iprot.readI64();
21058 
        else:
21059 
          iprot.skip(ftype)
4369 rajveer 21060 
      elif fid == 5:
21061 
        if ftype == TType.BOOL:
21062 
          self.isReminder = iprot.readBool();
21063 
        else:
21064 
          iprot.skip(ftype)
4303 rajveer 21065 
      else:
21066 
        iprot.skip(ftype)
21067 
      iprot.readFieldEnd()
21068 
    iprot.readStructEnd()
21069 
 
21070 
  def write(self, oprot):
21071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21073 
      return
21074 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21075 
    if self.vendorId is not None:
21076 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21077 
      oprot.writeI64(self.vendorId)
21078 
      oprot.writeFieldEnd()
21079 
    if self.itemId is not None:
21080 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21081 
      oprot.writeI64(self.itemId)
21082 
      oprot.writeFieldEnd()
21083 
    if self.quantity is not None:
21084 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21085 
      oprot.writeI64(self.quantity)
21086 
      oprot.writeFieldEnd()
21087 
    if self.estimate is not None:
21088 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21089 
      oprot.writeI64(self.estimate)
21090 
      oprot.writeFieldEnd()
4369 rajveer 21091 
    if self.isReminder is not None:
21092 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21093 
      oprot.writeBool(self.isReminder)
21094 
      oprot.writeFieldEnd()
4303 rajveer 21095 
    oprot.writeFieldStop()
21096 
    oprot.writeStructEnd()
21097 
 
21098 
  def validate(self):
21099 
    return
21100 
 
21101 
 
21102 
  def __repr__(self):
21103 
    L = ['%s=%r' % (key, value)
21104 
      for key, value in self.__dict__.iteritems()]
21105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21106 
 
21107 
  def __eq__(self, other):
21108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21109 
 
21110 
  def __ne__(self, other):
21111 
    return not (self == other)
21112 
 
21113 
class markOrdersAsNotAvailabke_result:
21114 
  """
21115 
  Attributes:
21116 
   - ex
21117 
  """
21118 
 
21119 
  thrift_spec = (
21120 
    None, # 0
21121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21122 
  )
21123 
 
21124 
  def __init__(self, ex=None,):
21125 
    self.ex = ex
21126 
 
21127 
  def read(self, iprot):
21128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21130 
      return
21131 
    iprot.readStructBegin()
21132 
    while True:
21133 
      (fname, ftype, fid) = iprot.readFieldBegin()
21134 
      if ftype == TType.STOP:
21135 
        break
21136 
      if fid == 1:
21137 
        if ftype == TType.STRUCT:
21138 
          self.ex = TransactionServiceException()
21139 
          self.ex.read(iprot)
21140 
        else:
21141 
          iprot.skip(ftype)
21142 
      else:
21143 
        iprot.skip(ftype)
21144 
      iprot.readFieldEnd()
21145 
    iprot.readStructEnd()
21146 
 
21147 
  def write(self, oprot):
21148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21150 
      return
21151 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21152 
    if self.ex is not None:
21153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21154 
      self.ex.write(oprot)
21155 
      oprot.writeFieldEnd()
21156 
    oprot.writeFieldStop()
21157 
    oprot.writeStructEnd()
21158 
 
21159 
  def validate(self):
21160 
    return
21161 
 
21162 
 
21163 
  def __repr__(self):
21164 
    L = ['%s=%r' % (key, value)
21165 
      for key, value in self.__dict__.iteritems()]
21166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21167 
 
21168 
  def __eq__(self, other):
21169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21170 
 
21171 
  def __ne__(self, other):
21172 
    return not (self == other)
4369 rajveer 21173 
 
21174 
class markOrdersAsTimeout_args:
21175 
  """
21176 
  Attributes:
21177 
   - vendorId
21178 
  """
21179 
 
21180 
  thrift_spec = (
21181 
    None, # 0
21182 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21183 
  )
21184 
 
21185 
  def __init__(self, vendorId=None,):
21186 
    self.vendorId = vendorId
21187 
 
21188 
  def read(self, iprot):
21189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21191 
      return
21192 
    iprot.readStructBegin()
21193 
    while True:
21194 
      (fname, ftype, fid) = iprot.readFieldBegin()
21195 
      if ftype == TType.STOP:
21196 
        break
21197 
      if fid == 1:
21198 
        if ftype == TType.I64:
21199 
          self.vendorId = iprot.readI64();
21200 
        else:
21201 
          iprot.skip(ftype)
21202 
      else:
21203 
        iprot.skip(ftype)
21204 
      iprot.readFieldEnd()
21205 
    iprot.readStructEnd()
21206 
 
21207 
  def write(self, oprot):
21208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21210 
      return
21211 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21212 
    if self.vendorId is not None:
21213 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21214 
      oprot.writeI64(self.vendorId)
21215 
      oprot.writeFieldEnd()
21216 
    oprot.writeFieldStop()
21217 
    oprot.writeStructEnd()
21218 
 
21219 
  def validate(self):
21220 
    return
21221 
 
21222 
 
21223 
  def __repr__(self):
21224 
    L = ['%s=%r' % (key, value)
21225 
      for key, value in self.__dict__.iteritems()]
21226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21227 
 
21228 
  def __eq__(self, other):
21229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21230 
 
21231 
  def __ne__(self, other):
21232 
    return not (self == other)
21233 
 
21234 
class markOrdersAsTimeout_result:
21235 
  """
21236 
  Attributes:
21237 
   - success
21238 
   - ex
21239 
  """
21240 
 
21241 
  thrift_spec = (
21242 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21244 
  )
21245 
 
21246 
  def __init__(self, success=None, ex=None,):
21247 
    self.success = success
21248 
    self.ex = ex
21249 
 
21250 
  def read(self, iprot):
21251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21253 
      return
21254 
    iprot.readStructBegin()
21255 
    while True:
21256 
      (fname, ftype, fid) = iprot.readFieldBegin()
21257 
      if ftype == TType.STOP:
21258 
        break
21259 
      if fid == 0:
21260 
        if ftype == TType.MAP:
21261 
          self.success = {}
6031 rajveer 21262 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21263 
          for _i462 in xrange(_size458):
21264 
            _key463 = iprot.readI32();
21265 
            _val464 = TimeoutSummary()
21266 
            _val464.read(iprot)
21267 
            self.success[_key463] = _val464
4369 rajveer 21268 
          iprot.readMapEnd()
21269 
        else:
21270 
          iprot.skip(ftype)
21271 
      elif fid == 1:
21272 
        if ftype == TType.STRUCT:
21273 
          self.ex = TransactionServiceException()
21274 
          self.ex.read(iprot)
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      else:
21278 
        iprot.skip(ftype)
21279 
      iprot.readFieldEnd()
21280 
    iprot.readStructEnd()
21281 
 
21282 
  def write(self, oprot):
21283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21285 
      return
21286 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21287 
    if self.success is not None:
21288 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21289 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21290 
      for kiter465,viter466 in self.success.items():
21291 
        oprot.writeI32(kiter465)
21292 
        viter466.write(oprot)
4369 rajveer 21293 
      oprot.writeMapEnd()
21294 
      oprot.writeFieldEnd()
21295 
    if self.ex is not None:
21296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21297 
      self.ex.write(oprot)
21298 
      oprot.writeFieldEnd()
21299 
    oprot.writeFieldStop()
21300 
    oprot.writeStructEnd()
21301 
 
21302 
  def validate(self):
21303 
    return
21304 
 
21305 
 
21306 
  def __repr__(self):
21307 
    L = ['%s=%r' % (key, value)
21308 
      for key, value in self.__dict__.iteritems()]
21309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21310 
 
21311 
  def __eq__(self, other):
21312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21313 
 
21314 
  def __ne__(self, other):
21315 
    return not (self == other)
4386 anupam.sin 21316 
 
4662 rajveer 21317 
class markOrderAsLostInTransit_args:
21318 
  """
21319 
  Attributes:
21320 
   - orderId
21321 
  """
21322 
 
21323 
  thrift_spec = (
21324 
    None, # 0
21325 
    (1, TType.I64, 'orderId', None, None, ), # 1
21326 
  )
21327 
 
21328 
  def __init__(self, orderId=None,):
21329 
    self.orderId = orderId
21330 
 
21331 
  def read(self, iprot):
21332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21334 
      return
21335 
    iprot.readStructBegin()
21336 
    while True:
21337 
      (fname, ftype, fid) = iprot.readFieldBegin()
21338 
      if ftype == TType.STOP:
21339 
        break
21340 
      if fid == 1:
21341 
        if ftype == TType.I64:
21342 
          self.orderId = iprot.readI64();
21343 
        else:
21344 
          iprot.skip(ftype)
21345 
      else:
21346 
        iprot.skip(ftype)
21347 
      iprot.readFieldEnd()
21348 
    iprot.readStructEnd()
21349 
 
21350 
  def write(self, oprot):
21351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21353 
      return
21354 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21355 
    if self.orderId is not None:
21356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21357 
      oprot.writeI64(self.orderId)
21358 
      oprot.writeFieldEnd()
21359 
    oprot.writeFieldStop()
21360 
    oprot.writeStructEnd()
21361 
 
21362 
  def validate(self):
21363 
    return
21364 
 
21365 
 
21366 
  def __repr__(self):
21367 
    L = ['%s=%r' % (key, value)
21368 
      for key, value in self.__dict__.iteritems()]
21369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21370 
 
21371 
  def __eq__(self, other):
21372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21373 
 
21374 
  def __ne__(self, other):
21375 
    return not (self == other)
21376 
 
21377 
class markOrderAsLostInTransit_result:
21378 
  """
21379 
  Attributes:
21380 
   - success
21381 
   - ex
21382 
  """
21383 
 
21384 
  thrift_spec = (
21385 
    (0, TType.BOOL, 'success', None, None, ), # 0
21386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21387 
  )
21388 
 
21389 
  def __init__(self, success=None, ex=None,):
21390 
    self.success = success
21391 
    self.ex = ex
21392 
 
21393 
  def read(self, iprot):
21394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21396 
      return
21397 
    iprot.readStructBegin()
21398 
    while True:
21399 
      (fname, ftype, fid) = iprot.readFieldBegin()
21400 
      if ftype == TType.STOP:
21401 
        break
21402 
      if fid == 0:
21403 
        if ftype == TType.BOOL:
21404 
          self.success = iprot.readBool();
21405 
        else:
21406 
          iprot.skip(ftype)
21407 
      elif fid == 1:
21408 
        if ftype == TType.STRUCT:
21409 
          self.ex = TransactionServiceException()
21410 
          self.ex.read(iprot)
21411 
        else:
21412 
          iprot.skip(ftype)
21413 
      else:
21414 
        iprot.skip(ftype)
21415 
      iprot.readFieldEnd()
21416 
    iprot.readStructEnd()
21417 
 
21418 
  def write(self, oprot):
21419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21421 
      return
21422 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21423 
    if self.success is not None:
21424 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21425 
      oprot.writeBool(self.success)
21426 
      oprot.writeFieldEnd()
21427 
    if self.ex is not None:
21428 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21429 
      self.ex.write(oprot)
21430 
      oprot.writeFieldEnd()
21431 
    oprot.writeFieldStop()
21432 
    oprot.writeStructEnd()
21433 
 
21434 
  def validate(self):
21435 
    return
21436 
 
21437 
 
21438 
  def __repr__(self):
21439 
    L = ['%s=%r' % (key, value)
21440 
      for key, value in self.__dict__.iteritems()]
21441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21442 
 
21443 
  def __eq__(self, other):
21444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21445 
 
21446 
  def __ne__(self, other):
21447 
    return not (self == other)
21448 
 
4386 anupam.sin 21449 
class getOrderForAwb_args:
21450 
  """
21451 
  Attributes:
21452 
   - awb
21453 
  """
21454 
 
21455 
  thrift_spec = (
21456 
    None, # 0
21457 
    (1, TType.STRING, 'awb', None, None, ), # 1
21458 
  )
21459 
 
21460 
  def __init__(self, awb=None,):
21461 
    self.awb = awb
21462 
 
21463 
  def read(self, iprot):
21464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21466 
      return
21467 
    iprot.readStructBegin()
21468 
    while True:
21469 
      (fname, ftype, fid) = iprot.readFieldBegin()
21470 
      if ftype == TType.STOP:
21471 
        break
21472 
      if fid == 1:
21473 
        if ftype == TType.STRING:
21474 
          self.awb = iprot.readString();
21475 
        else:
21476 
          iprot.skip(ftype)
21477 
      else:
21478 
        iprot.skip(ftype)
21479 
      iprot.readFieldEnd()
21480 
    iprot.readStructEnd()
21481 
 
21482 
  def write(self, oprot):
21483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21485 
      return
21486 
    oprot.writeStructBegin('getOrderForAwb_args')
21487 
    if self.awb is not None:
21488 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21489 
      oprot.writeString(self.awb)
21490 
      oprot.writeFieldEnd()
21491 
    oprot.writeFieldStop()
21492 
    oprot.writeStructEnd()
21493 
 
21494 
  def validate(self):
21495 
    return
21496 
 
21497 
 
21498 
  def __repr__(self):
21499 
    L = ['%s=%r' % (key, value)
21500 
      for key, value in self.__dict__.iteritems()]
21501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21502 
 
21503 
  def __eq__(self, other):
21504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21505 
 
21506 
  def __ne__(self, other):
21507 
    return not (self == other)
21508 
 
21509 
class getOrderForAwb_result:
21510 
  """
21511 
  Attributes:
21512 
   - success
21513 
   - ex
21514 
  """
21515 
 
21516 
  thrift_spec = (
21517 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21519 
  )
21520 
 
21521 
  def __init__(self, success=None, ex=None,):
21522 
    self.success = success
21523 
    self.ex = ex
21524 
 
21525 
  def read(self, iprot):
21526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21528 
      return
21529 
    iprot.readStructBegin()
21530 
    while True:
21531 
      (fname, ftype, fid) = iprot.readFieldBegin()
21532 
      if ftype == TType.STOP:
21533 
        break
21534 
      if fid == 0:
21535 
        if ftype == TType.STRUCT:
21536 
          self.success = Order()
21537 
          self.success.read(iprot)
21538 
        else:
21539 
          iprot.skip(ftype)
21540 
      elif fid == 1:
21541 
        if ftype == TType.STRUCT:
21542 
          self.ex = TransactionServiceException()
21543 
          self.ex.read(iprot)
21544 
        else:
21545 
          iprot.skip(ftype)
21546 
      else:
21547 
        iprot.skip(ftype)
21548 
      iprot.readFieldEnd()
21549 
    iprot.readStructEnd()
21550 
 
21551 
  def write(self, oprot):
21552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21554 
      return
21555 
    oprot.writeStructBegin('getOrderForAwb_result')
21556 
    if self.success is not None:
21557 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21558 
      self.success.write(oprot)
21559 
      oprot.writeFieldEnd()
21560 
    if self.ex is not None:
21561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21562 
      self.ex.write(oprot)
21563 
      oprot.writeFieldEnd()
21564 
    oprot.writeFieldStop()
21565 
    oprot.writeStructEnd()
21566 
 
21567 
  def validate(self):
21568 
    return
21569 
 
21570 
 
21571 
  def __repr__(self):
21572 
    L = ['%s=%r' % (key, value)
21573 
      for key, value in self.__dict__.iteritems()]
21574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21575 
 
21576 
  def __eq__(self, other):
21577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21578 
 
21579 
  def __ne__(self, other):
21580 
    return not (self == other)
4506 phani.kuma 21581 
 
21582 
class getOrdersForProviderForStatus_args:
21583 
  """
21584 
  Attributes:
21585 
   - logistics_provider_id
4910 phani.kuma 21586 
   - order_status_list
4506 phani.kuma 21587 
  """
21588 
 
21589 
  thrift_spec = (
21590 
    None, # 0
21591 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21592 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21593 
  )
21594 
 
4910 phani.kuma 21595 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21596 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21597 
    self.order_status_list = order_status_list
4506 phani.kuma 21598 
 
21599 
  def read(self, iprot):
21600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21602 
      return
21603 
    iprot.readStructBegin()
21604 
    while True:
21605 
      (fname, ftype, fid) = iprot.readFieldBegin()
21606 
      if ftype == TType.STOP:
21607 
        break
21608 
      if fid == 1:
21609 
        if ftype == TType.I64:
21610 
          self.logistics_provider_id = iprot.readI64();
21611 
        else:
21612 
          iprot.skip(ftype)
21613 
      elif fid == 2:
4910 phani.kuma 21614 
        if ftype == TType.LIST:
21615 
          self.order_status_list = []
6031 rajveer 21616 
          (_etype470, _size467) = iprot.readListBegin()
21617 
          for _i471 in xrange(_size467):
21618 
            _elem472 = iprot.readI32();
21619 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21620 
          iprot.readListEnd()
4506 phani.kuma 21621 
        else:
21622 
          iprot.skip(ftype)
21623 
      else:
21624 
        iprot.skip(ftype)
21625 
      iprot.readFieldEnd()
21626 
    iprot.readStructEnd()
21627 
 
21628 
  def write(self, oprot):
21629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21631 
      return
21632 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21633 
    if self.logistics_provider_id is not None:
21634 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21635 
      oprot.writeI64(self.logistics_provider_id)
21636 
      oprot.writeFieldEnd()
4910 phani.kuma 21637 
    if self.order_status_list is not None:
21638 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21639 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21640 
      for iter473 in self.order_status_list:
21641 
        oprot.writeI32(iter473)
4910 phani.kuma 21642 
      oprot.writeListEnd()
4506 phani.kuma 21643 
      oprot.writeFieldEnd()
21644 
    oprot.writeFieldStop()
21645 
    oprot.writeStructEnd()
21646 
 
21647 
  def validate(self):
21648 
    return
21649 
 
21650 
 
21651 
  def __repr__(self):
21652 
    L = ['%s=%r' % (key, value)
21653 
      for key, value in self.__dict__.iteritems()]
21654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21655 
 
21656 
  def __eq__(self, other):
21657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21658 
 
21659 
  def __ne__(self, other):
21660 
    return not (self == other)
21661 
 
21662 
class getOrdersForProviderForStatus_result:
21663 
  """
21664 
  Attributes:
21665 
   - success
21666 
   - ex
21667 
  """
21668 
 
21669 
  thrift_spec = (
21670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21672 
  )
21673 
 
21674 
  def __init__(self, success=None, ex=None,):
21675 
    self.success = success
21676 
    self.ex = ex
21677 
 
21678 
  def read(self, iprot):
21679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21681 
      return
21682 
    iprot.readStructBegin()
21683 
    while True:
21684 
      (fname, ftype, fid) = iprot.readFieldBegin()
21685 
      if ftype == TType.STOP:
21686 
        break
21687 
      if fid == 0:
21688 
        if ftype == TType.LIST:
21689 
          self.success = []
6031 rajveer 21690 
          (_etype477, _size474) = iprot.readListBegin()
21691 
          for _i478 in xrange(_size474):
21692 
            _elem479 = Order()
21693 
            _elem479.read(iprot)
21694 
            self.success.append(_elem479)
4506 phani.kuma 21695 
          iprot.readListEnd()
21696 
        else:
21697 
          iprot.skip(ftype)
21698 
      elif fid == 1:
21699 
        if ftype == TType.STRUCT:
21700 
          self.ex = TransactionServiceException()
21701 
          self.ex.read(iprot)
21702 
        else:
21703 
          iprot.skip(ftype)
21704 
      else:
21705 
        iprot.skip(ftype)
21706 
      iprot.readFieldEnd()
21707 
    iprot.readStructEnd()
21708 
 
21709 
  def write(self, oprot):
21710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21712 
      return
21713 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21714 
    if self.success is not None:
21715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21716 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21717 
      for iter480 in self.success:
21718 
        iter480.write(oprot)
4506 phani.kuma 21719 
      oprot.writeListEnd()
21720 
      oprot.writeFieldEnd()
21721 
    if self.ex is not None:
21722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21723 
      self.ex.write(oprot)
21724 
      oprot.writeFieldEnd()
21725 
    oprot.writeFieldStop()
21726 
    oprot.writeStructEnd()
21727 
 
21728 
  def validate(self):
21729 
    return
21730 
 
21731 
 
21732 
  def __repr__(self):
21733 
    L = ['%s=%r' % (key, value)
21734 
      for key, value in self.__dict__.iteritems()]
21735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21736 
 
21737 
  def __eq__(self, other):
21738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21739 
 
21740 
  def __ne__(self, other):
21741 
    return not (self == other)
4600 varun.gupt 21742 
 
21743 
class getBilledOrdersForVendor_args:
21744 
  """
21745 
  Attributes:
21746 
   - vendorId
21747 
   - billingDateFrom
21748 
   - billingDateTo
21749 
  """
21750 
 
21751 
  thrift_spec = (
21752 
    None, # 0
21753 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21754 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21755 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21756 
  )
21757 
 
21758 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21759 
    self.vendorId = vendorId
21760 
    self.billingDateFrom = billingDateFrom
21761 
    self.billingDateTo = billingDateTo
21762 
 
21763 
  def read(self, iprot):
21764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21766 
      return
21767 
    iprot.readStructBegin()
21768 
    while True:
21769 
      (fname, ftype, fid) = iprot.readFieldBegin()
21770 
      if ftype == TType.STOP:
21771 
        break
21772 
      if fid == 1:
21773 
        if ftype == TType.I64:
21774 
          self.vendorId = iprot.readI64();
21775 
        else:
21776 
          iprot.skip(ftype)
21777 
      elif fid == 2:
21778 
        if ftype == TType.I64:
21779 
          self.billingDateFrom = iprot.readI64();
21780 
        else:
21781 
          iprot.skip(ftype)
21782 
      elif fid == 3:
21783 
        if ftype == TType.I64:
21784 
          self.billingDateTo = iprot.readI64();
21785 
        else:
21786 
          iprot.skip(ftype)
21787 
      else:
21788 
        iprot.skip(ftype)
21789 
      iprot.readFieldEnd()
21790 
    iprot.readStructEnd()
21791 
 
21792 
  def write(self, oprot):
21793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21795 
      return
21796 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21797 
    if self.vendorId is not None:
21798 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21799 
      oprot.writeI64(self.vendorId)
21800 
      oprot.writeFieldEnd()
21801 
    if self.billingDateFrom is not None:
21802 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21803 
      oprot.writeI64(self.billingDateFrom)
21804 
      oprot.writeFieldEnd()
21805 
    if self.billingDateTo is not None:
21806 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21807 
      oprot.writeI64(self.billingDateTo)
21808 
      oprot.writeFieldEnd()
21809 
    oprot.writeFieldStop()
21810 
    oprot.writeStructEnd()
21811 
 
21812 
  def validate(self):
21813 
    return
21814 
 
21815 
 
21816 
  def __repr__(self):
21817 
    L = ['%s=%r' % (key, value)
21818 
      for key, value in self.__dict__.iteritems()]
21819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21820 
 
21821 
  def __eq__(self, other):
21822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21823 
 
21824 
  def __ne__(self, other):
21825 
    return not (self == other)
21826 
 
21827 
class getBilledOrdersForVendor_result:
21828 
  """
21829 
  Attributes:
21830 
   - success
21831 
   - ex
21832 
  """
21833 
 
21834 
  thrift_spec = (
21835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21837 
  )
21838 
 
21839 
  def __init__(self, success=None, ex=None,):
21840 
    self.success = success
21841 
    self.ex = ex
21842 
 
21843 
  def read(self, iprot):
21844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21846 
      return
21847 
    iprot.readStructBegin()
21848 
    while True:
21849 
      (fname, ftype, fid) = iprot.readFieldBegin()
21850 
      if ftype == TType.STOP:
21851 
        break
21852 
      if fid == 0:
21853 
        if ftype == TType.LIST:
21854 
          self.success = []
6031 rajveer 21855 
          (_etype484, _size481) = iprot.readListBegin()
21856 
          for _i485 in xrange(_size481):
21857 
            _elem486 = Order()
21858 
            _elem486.read(iprot)
21859 
            self.success.append(_elem486)
4600 varun.gupt 21860 
          iprot.readListEnd()
21861 
        else:
21862 
          iprot.skip(ftype)
21863 
      elif fid == 1:
21864 
        if ftype == TType.STRUCT:
21865 
          self.ex = TransactionServiceException()
21866 
          self.ex.read(iprot)
21867 
        else:
21868 
          iprot.skip(ftype)
21869 
      else:
21870 
        iprot.skip(ftype)
21871 
      iprot.readFieldEnd()
21872 
    iprot.readStructEnd()
21873 
 
21874 
  def write(self, oprot):
21875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21877 
      return
21878 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21879 
    if self.success is not None:
21880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21882 
      for iter487 in self.success:
21883 
        iter487.write(oprot)
4600 varun.gupt 21884 
      oprot.writeListEnd()
21885 
      oprot.writeFieldEnd()
21886 
    if self.ex is not None:
21887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21888 
      self.ex.write(oprot)
21889 
      oprot.writeFieldEnd()
21890 
    oprot.writeFieldStop()
21891 
    oprot.writeStructEnd()
21892 
 
21893 
  def validate(self):
21894 
    return
21895 
 
21896 
 
21897 
  def __repr__(self):
21898 
    L = ['%s=%r' % (key, value)
21899 
      for key, value in self.__dict__.iteritems()]
21900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21901 
 
21902 
  def __eq__(self, other):
21903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21904 
 
21905 
  def __ne__(self, other):
21906 
    return not (self == other)
21907 
 
4607 rajveer 21908 
class getSlippedSippingDateOrders_args:
21909 
 
21910 
  thrift_spec = (
21911 
  )
21912 
 
21913 
  def read(self, iprot):
21914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21916 
      return
21917 
    iprot.readStructBegin()
21918 
    while True:
21919 
      (fname, ftype, fid) = iprot.readFieldBegin()
21920 
      if ftype == TType.STOP:
21921 
        break
21922 
      else:
21923 
        iprot.skip(ftype)
21924 
      iprot.readFieldEnd()
21925 
    iprot.readStructEnd()
21926 
 
21927 
  def write(self, oprot):
21928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21930 
      return
21931 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21932 
    oprot.writeFieldStop()
21933 
    oprot.writeStructEnd()
21934 
 
21935 
  def validate(self):
21936 
    return
21937 
 
21938 
 
21939 
  def __repr__(self):
21940 
    L = ['%s=%r' % (key, value)
21941 
      for key, value in self.__dict__.iteritems()]
21942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21943 
 
21944 
  def __eq__(self, other):
21945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21946 
 
21947 
  def __ne__(self, other):
21948 
    return not (self == other)
21949 
 
21950 
class getSlippedSippingDateOrders_result:
21951 
  """
21952 
  Attributes:
21953 
   - success
21954 
   - ex
21955 
  """
21956 
 
21957 
  thrift_spec = (
21958 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21960 
  )
21961 
 
21962 
  def __init__(self, success=None, ex=None,):
21963 
    self.success = success
21964 
    self.ex = ex
21965 
 
21966 
  def read(self, iprot):
21967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21969 
      return
21970 
    iprot.readStructBegin()
21971 
    while True:
21972 
      (fname, ftype, fid) = iprot.readFieldBegin()
21973 
      if ftype == TType.STOP:
21974 
        break
21975 
      if fid == 0:
21976 
        if ftype == TType.LIST:
21977 
          self.success = []
6031 rajveer 21978 
          (_etype491, _size488) = iprot.readListBegin()
21979 
          for _i492 in xrange(_size488):
21980 
            _elem493 = Order()
21981 
            _elem493.read(iprot)
21982 
            self.success.append(_elem493)
4607 rajveer 21983 
          iprot.readListEnd()
21984 
        else:
21985 
          iprot.skip(ftype)
21986 
      elif fid == 1:
21987 
        if ftype == TType.STRUCT:
21988 
          self.ex = TransactionServiceException()
21989 
          self.ex.read(iprot)
21990 
        else:
21991 
          iprot.skip(ftype)
21992 
      else:
21993 
        iprot.skip(ftype)
21994 
      iprot.readFieldEnd()
21995 
    iprot.readStructEnd()
21996 
 
21997 
  def write(self, oprot):
21998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22000 
      return
22001 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22002 
    if self.success is not None:
22003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22005 
      for iter494 in self.success:
22006 
        iter494.write(oprot)
4607 rajveer 22007 
      oprot.writeListEnd()
22008 
      oprot.writeFieldEnd()
22009 
    if self.ex is not None:
22010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22011 
      self.ex.write(oprot)
22012 
      oprot.writeFieldEnd()
22013 
    oprot.writeFieldStop()
22014 
    oprot.writeStructEnd()
22015 
 
22016 
  def validate(self):
22017 
    return
22018 
 
22019 
 
22020 
  def __repr__(self):
22021 
    L = ['%s=%r' % (key, value)
22022 
      for key, value in self.__dict__.iteritems()]
22023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22024 
 
22025 
  def __eq__(self, other):
22026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22027 
 
22028 
  def __ne__(self, other):
22029 
    return not (self == other)
22030 
 
4709 rajveer 22031 
class getCancelledOrders_args:
22032 
  """
22033 
  Attributes:
22034 
   - cancelDateFrom
22035 
   - cancelDateTo
22036 
  """
22037 
 
22038 
  thrift_spec = (
22039 
    None, # 0
22040 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22041 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22042 
  )
22043 
 
22044 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22045 
    self.cancelDateFrom = cancelDateFrom
22046 
    self.cancelDateTo = cancelDateTo
22047 
 
22048 
  def read(self, iprot):
22049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22051 
      return
22052 
    iprot.readStructBegin()
22053 
    while True:
22054 
      (fname, ftype, fid) = iprot.readFieldBegin()
22055 
      if ftype == TType.STOP:
22056 
        break
22057 
      if fid == 1:
22058 
        if ftype == TType.I64:
22059 
          self.cancelDateFrom = iprot.readI64();
22060 
        else:
22061 
          iprot.skip(ftype)
22062 
      elif fid == 2:
22063 
        if ftype == TType.I64:
22064 
          self.cancelDateTo = iprot.readI64();
22065 
        else:
22066 
          iprot.skip(ftype)
22067 
      else:
22068 
        iprot.skip(ftype)
22069 
      iprot.readFieldEnd()
22070 
    iprot.readStructEnd()
22071 
 
22072 
  def write(self, oprot):
22073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22075 
      return
22076 
    oprot.writeStructBegin('getCancelledOrders_args')
22077 
    if self.cancelDateFrom is not None:
22078 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22079 
      oprot.writeI64(self.cancelDateFrom)
22080 
      oprot.writeFieldEnd()
22081 
    if self.cancelDateTo is not None:
22082 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22083 
      oprot.writeI64(self.cancelDateTo)
22084 
      oprot.writeFieldEnd()
22085 
    oprot.writeFieldStop()
22086 
    oprot.writeStructEnd()
22087 
 
22088 
  def validate(self):
22089 
    return
22090 
 
22091 
 
22092 
  def __repr__(self):
22093 
    L = ['%s=%r' % (key, value)
22094 
      for key, value in self.__dict__.iteritems()]
22095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22096 
 
22097 
  def __eq__(self, other):
22098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22099 
 
22100 
  def __ne__(self, other):
22101 
    return not (self == other)
22102 
 
22103 
class getCancelledOrders_result:
22104 
  """
22105 
  Attributes:
22106 
   - success
22107 
   - ex
22108 
  """
22109 
 
22110 
  thrift_spec = (
22111 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22113 
  )
22114 
 
22115 
  def __init__(self, success=None, ex=None,):
22116 
    self.success = success
22117 
    self.ex = ex
22118 
 
22119 
  def read(self, iprot):
22120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22122 
      return
22123 
    iprot.readStructBegin()
22124 
    while True:
22125 
      (fname, ftype, fid) = iprot.readFieldBegin()
22126 
      if ftype == TType.STOP:
22127 
        break
22128 
      if fid == 0:
22129 
        if ftype == TType.LIST:
22130 
          self.success = []
6031 rajveer 22131 
          (_etype498, _size495) = iprot.readListBegin()
22132 
          for _i499 in xrange(_size495):
22133 
            _elem500 = Order()
22134 
            _elem500.read(iprot)
22135 
            self.success.append(_elem500)
4709 rajveer 22136 
          iprot.readListEnd()
22137 
        else:
22138 
          iprot.skip(ftype)
22139 
      elif fid == 1:
22140 
        if ftype == TType.STRUCT:
22141 
          self.ex = TransactionServiceException()
22142 
          self.ex.read(iprot)
22143 
        else:
22144 
          iprot.skip(ftype)
22145 
      else:
22146 
        iprot.skip(ftype)
22147 
      iprot.readFieldEnd()
22148 
    iprot.readStructEnd()
22149 
 
22150 
  def write(self, oprot):
22151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22153 
      return
22154 
    oprot.writeStructBegin('getCancelledOrders_result')
22155 
    if self.success is not None:
22156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22158 
      for iter501 in self.success:
22159 
        iter501.write(oprot)
4709 rajveer 22160 
      oprot.writeListEnd()
22161 
      oprot.writeFieldEnd()
22162 
    if self.ex is not None:
22163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22164 
      self.ex.write(oprot)
22165 
      oprot.writeFieldEnd()
22166 
    oprot.writeFieldStop()
22167 
    oprot.writeStructEnd()
22168 
 
22169 
  def validate(self):
22170 
    return
22171 
 
22172 
 
22173 
  def __repr__(self):
22174 
    L = ['%s=%r' % (key, value)
22175 
      for key, value in self.__dict__.iteritems()]
22176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22177 
 
22178 
  def __eq__(self, other):
22179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22180 
 
22181 
  def __ne__(self, other):
22182 
    return not (self == other)
22183 
 
4600 varun.gupt 22184 
class saveBluedartSettlements_args:
22185 
  """
22186 
  Attributes:
22187 
   - mapAWBAndAmount
22188 
  """
22189 
 
22190 
  thrift_spec = (
22191 
    None, # 0
22192 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22193 
  )
22194 
 
22195 
  def __init__(self, mapAWBAndAmount=None,):
22196 
    self.mapAWBAndAmount = mapAWBAndAmount
22197 
 
22198 
  def read(self, iprot):
22199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22201 
      return
22202 
    iprot.readStructBegin()
22203 
    while True:
22204 
      (fname, ftype, fid) = iprot.readFieldBegin()
22205 
      if ftype == TType.STOP:
22206 
        break
22207 
      if fid == 1:
22208 
        if ftype == TType.MAP:
22209 
          self.mapAWBAndAmount = {}
6031 rajveer 22210 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22211 
          for _i506 in xrange(_size502):
22212 
            _key507 = iprot.readI64();
22213 
            _val508 = iprot.readDouble();
22214 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22215 
          iprot.readMapEnd()
22216 
        else:
22217 
          iprot.skip(ftype)
22218 
      else:
22219 
        iprot.skip(ftype)
22220 
      iprot.readFieldEnd()
22221 
    iprot.readStructEnd()
22222 
 
22223 
  def write(self, oprot):
22224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22226 
      return
22227 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22228 
    if self.mapAWBAndAmount is not None:
22229 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22230 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22231 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22232 
        oprot.writeI64(kiter509)
22233 
        oprot.writeDouble(viter510)
4600 varun.gupt 22234 
      oprot.writeMapEnd()
22235 
      oprot.writeFieldEnd()
22236 
    oprot.writeFieldStop()
22237 
    oprot.writeStructEnd()
22238 
 
22239 
  def validate(self):
22240 
    return
22241 
 
22242 
 
22243 
  def __repr__(self):
22244 
    L = ['%s=%r' % (key, value)
22245 
      for key, value in self.__dict__.iteritems()]
22246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22247 
 
22248 
  def __eq__(self, other):
22249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22250 
 
22251 
  def __ne__(self, other):
22252 
    return not (self == other)
22253 
 
22254 
class saveBluedartSettlements_result:
22255 
  """
22256 
  Attributes:
22257 
   - ex
22258 
  """
22259 
 
22260 
  thrift_spec = (
22261 
    None, # 0
22262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22263 
  )
22264 
 
22265 
  def __init__(self, ex=None,):
22266 
    self.ex = ex
22267 
 
22268 
  def read(self, iprot):
22269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22271 
      return
22272 
    iprot.readStructBegin()
22273 
    while True:
22274 
      (fname, ftype, fid) = iprot.readFieldBegin()
22275 
      if ftype == TType.STOP:
22276 
        break
22277 
      if fid == 1:
22278 
        if ftype == TType.STRUCT:
22279 
          self.ex = TransactionServiceException()
22280 
          self.ex.read(iprot)
22281 
        else:
22282 
          iprot.skip(ftype)
22283 
      else:
22284 
        iprot.skip(ftype)
22285 
      iprot.readFieldEnd()
22286 
    iprot.readStructEnd()
22287 
 
22288 
  def write(self, oprot):
22289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22291 
      return
22292 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22293 
    if self.ex is not None:
22294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22295 
      self.ex.write(oprot)
22296 
      oprot.writeFieldEnd()
22297 
    oprot.writeFieldStop()
22298 
    oprot.writeStructEnd()
22299 
 
22300 
  def validate(self):
22301 
    return
22302 
 
22303 
 
22304 
  def __repr__(self):
22305 
    L = ['%s=%r' % (key, value)
22306 
      for key, value in self.__dict__.iteritems()]
22307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22308 
 
22309 
  def __eq__(self, other):
22310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22311 
 
22312 
  def __ne__(self, other):
22313 
    return not (self == other)
22314 
 
22315 
class savePaymentSettlements_args:
22316 
  """
22317 
  Attributes:
22318 
   - settlementDate
22319 
   - paymentGatewayId
4905 varun.gupt 22320 
   - referenceId
4600 varun.gupt 22321 
   - serviceTax
22322 
   - otherCharges
22323 
   - netCollection
22324 
  """
22325 
 
22326 
  thrift_spec = (
22327 
    None, # 0
22328 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22329 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22330 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22331 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22332 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22333 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22334 
  )
22335 
 
4905 varun.gupt 22336 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22337 
    self.settlementDate = settlementDate
22338 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22339 
    self.referenceId = referenceId
4600 varun.gupt 22340 
    self.serviceTax = serviceTax
22341 
    self.otherCharges = otherCharges
22342 
    self.netCollection = netCollection
22343 
 
22344 
  def read(self, iprot):
22345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22347 
      return
22348 
    iprot.readStructBegin()
22349 
    while True:
22350 
      (fname, ftype, fid) = iprot.readFieldBegin()
22351 
      if ftype == TType.STOP:
22352 
        break
22353 
      if fid == 1:
22354 
        if ftype == TType.I64:
22355 
          self.settlementDate = iprot.readI64();
22356 
        else:
22357 
          iprot.skip(ftype)
22358 
      elif fid == 2:
22359 
        if ftype == TType.I64:
22360 
          self.paymentGatewayId = iprot.readI64();
22361 
        else:
22362 
          iprot.skip(ftype)
22363 
      elif fid == 3:
22364 
        if ftype == TType.I64:
4905 varun.gupt 22365 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22366 
        else:
22367 
          iprot.skip(ftype)
22368 
      elif fid == 4:
22369 
        if ftype == TType.DOUBLE:
22370 
          self.serviceTax = iprot.readDouble();
22371 
        else:
22372 
          iprot.skip(ftype)
22373 
      elif fid == 5:
22374 
        if ftype == TType.DOUBLE:
22375 
          self.otherCharges = iprot.readDouble();
22376 
        else:
22377 
          iprot.skip(ftype)
22378 
      elif fid == 6:
22379 
        if ftype == TType.DOUBLE:
22380 
          self.netCollection = iprot.readDouble();
22381 
        else:
22382 
          iprot.skip(ftype)
22383 
      else:
22384 
        iprot.skip(ftype)
22385 
      iprot.readFieldEnd()
22386 
    iprot.readStructEnd()
22387 
 
22388 
  def write(self, oprot):
22389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22391 
      return
22392 
    oprot.writeStructBegin('savePaymentSettlements_args')
22393 
    if self.settlementDate is not None:
22394 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22395 
      oprot.writeI64(self.settlementDate)
22396 
      oprot.writeFieldEnd()
22397 
    if self.paymentGatewayId is not None:
22398 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22399 
      oprot.writeI64(self.paymentGatewayId)
22400 
      oprot.writeFieldEnd()
4905 varun.gupt 22401 
    if self.referenceId is not None:
22402 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22403 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22404 
      oprot.writeFieldEnd()
22405 
    if self.serviceTax is not None:
22406 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22407 
      oprot.writeDouble(self.serviceTax)
22408 
      oprot.writeFieldEnd()
22409 
    if self.otherCharges is not None:
22410 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22411 
      oprot.writeDouble(self.otherCharges)
22412 
      oprot.writeFieldEnd()
22413 
    if self.netCollection is not None:
22414 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22415 
      oprot.writeDouble(self.netCollection)
22416 
      oprot.writeFieldEnd()
22417 
    oprot.writeFieldStop()
22418 
    oprot.writeStructEnd()
22419 
 
22420 
  def validate(self):
22421 
    return
22422 
 
22423 
 
22424 
  def __repr__(self):
22425 
    L = ['%s=%r' % (key, value)
22426 
      for key, value in self.__dict__.iteritems()]
22427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22428 
 
22429 
  def __eq__(self, other):
22430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22431 
 
22432 
  def __ne__(self, other):
22433 
    return not (self == other)
22434 
 
22435 
class savePaymentSettlements_result:
22436 
  """
22437 
  Attributes:
22438 
   - ex
22439 
  """
22440 
 
22441 
  thrift_spec = (
22442 
    None, # 0
22443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22444 
  )
22445 
 
22446 
  def __init__(self, ex=None,):
22447 
    self.ex = ex
22448 
 
22449 
  def read(self, iprot):
22450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22452 
      return
22453 
    iprot.readStructBegin()
22454 
    while True:
22455 
      (fname, ftype, fid) = iprot.readFieldBegin()
22456 
      if ftype == TType.STOP:
22457 
        break
22458 
      if fid == 1:
22459 
        if ftype == TType.STRUCT:
22460 
          self.ex = TransactionServiceException()
22461 
          self.ex.read(iprot)
22462 
        else:
22463 
          iprot.skip(ftype)
22464 
      else:
22465 
        iprot.skip(ftype)
22466 
      iprot.readFieldEnd()
22467 
    iprot.readStructEnd()
22468 
 
22469 
  def write(self, oprot):
22470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22472 
      return
22473 
    oprot.writeStructBegin('savePaymentSettlements_result')
22474 
    if self.ex is not None:
22475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22476 
      self.ex.write(oprot)
22477 
      oprot.writeFieldEnd()
22478 
    oprot.writeFieldStop()
22479 
    oprot.writeStructEnd()
22480 
 
22481 
  def validate(self):
22482 
    return
22483 
 
22484 
 
22485 
  def __repr__(self):
22486 
    L = ['%s=%r' % (key, value)
22487 
      for key, value in self.__dict__.iteritems()]
22488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22489 
 
22490 
  def __eq__(self, other):
22491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22492 
 
22493 
  def __ne__(self, other):
22494 
    return not (self == other)
22495 
 
22496 
class saveEBSSettlementSummary_args:
22497 
  """
22498 
  Attributes:
22499 
   - settlementId
22500 
   - settlementDate
22501 
   - transactionDateFrom
22502 
   - transactionDateTo
22503 
   - amount
22504 
  """
22505 
 
22506 
  thrift_spec = (
22507 
    None, # 0
22508 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22509 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22510 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22511 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22512 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22513 
  )
22514 
 
22515 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22516 
    self.settlementId = settlementId
22517 
    self.settlementDate = settlementDate
22518 
    self.transactionDateFrom = transactionDateFrom
22519 
    self.transactionDateTo = transactionDateTo
22520 
    self.amount = amount
22521 
 
22522 
  def read(self, iprot):
22523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22525 
      return
22526 
    iprot.readStructBegin()
22527 
    while True:
22528 
      (fname, ftype, fid) = iprot.readFieldBegin()
22529 
      if ftype == TType.STOP:
22530 
        break
22531 
      if fid == 1:
22532 
        if ftype == TType.I64:
22533 
          self.settlementId = iprot.readI64();
22534 
        else:
22535 
          iprot.skip(ftype)
22536 
      elif fid == 2:
22537 
        if ftype == TType.I64:
22538 
          self.settlementDate = iprot.readI64();
22539 
        else:
22540 
          iprot.skip(ftype)
22541 
      elif fid == 3:
22542 
        if ftype == TType.I64:
22543 
          self.transactionDateFrom = iprot.readI64();
22544 
        else:
22545 
          iprot.skip(ftype)
22546 
      elif fid == 4:
22547 
        if ftype == TType.I64:
22548 
          self.transactionDateTo = iprot.readI64();
22549 
        else:
22550 
          iprot.skip(ftype)
22551 
      elif fid == 5:
22552 
        if ftype == TType.DOUBLE:
22553 
          self.amount = iprot.readDouble();
22554 
        else:
22555 
          iprot.skip(ftype)
22556 
      else:
22557 
        iprot.skip(ftype)
22558 
      iprot.readFieldEnd()
22559 
    iprot.readStructEnd()
22560 
 
22561 
  def write(self, oprot):
22562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22564 
      return
22565 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22566 
    if self.settlementId is not None:
22567 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22568 
      oprot.writeI64(self.settlementId)
22569 
      oprot.writeFieldEnd()
22570 
    if self.settlementDate is not None:
22571 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22572 
      oprot.writeI64(self.settlementDate)
22573 
      oprot.writeFieldEnd()
22574 
    if self.transactionDateFrom is not None:
22575 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22576 
      oprot.writeI64(self.transactionDateFrom)
22577 
      oprot.writeFieldEnd()
22578 
    if self.transactionDateTo is not None:
22579 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22580 
      oprot.writeI64(self.transactionDateTo)
22581 
      oprot.writeFieldEnd()
22582 
    if self.amount is not None:
22583 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22584 
      oprot.writeDouble(self.amount)
22585 
      oprot.writeFieldEnd()
22586 
    oprot.writeFieldStop()
22587 
    oprot.writeStructEnd()
22588 
 
22589 
  def validate(self):
22590 
    return
22591 
 
22592 
 
22593 
  def __repr__(self):
22594 
    L = ['%s=%r' % (key, value)
22595 
      for key, value in self.__dict__.iteritems()]
22596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22597 
 
22598 
  def __eq__(self, other):
22599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22600 
 
22601 
  def __ne__(self, other):
22602 
    return not (self == other)
22603 
 
22604 
class saveEBSSettlementSummary_result:
22605 
  """
22606 
  Attributes:
22607 
   - ex
22608 
  """
22609 
 
22610 
  thrift_spec = (
22611 
    None, # 0
22612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22613 
  )
22614 
 
22615 
  def __init__(self, ex=None,):
22616 
    self.ex = ex
22617 
 
22618 
  def read(self, iprot):
22619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22621 
      return
22622 
    iprot.readStructBegin()
22623 
    while True:
22624 
      (fname, ftype, fid) = iprot.readFieldBegin()
22625 
      if ftype == TType.STOP:
22626 
        break
22627 
      if fid == 1:
22628 
        if ftype == TType.STRUCT:
22629 
          self.ex = TransactionServiceException()
22630 
          self.ex.read(iprot)
22631 
        else:
22632 
          iprot.skip(ftype)
22633 
      else:
22634 
        iprot.skip(ftype)
22635 
      iprot.readFieldEnd()
22636 
    iprot.readStructEnd()
22637 
 
22638 
  def write(self, oprot):
22639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22641 
      return
22642 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22643 
    if self.ex is not None:
22644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22645 
      self.ex.write(oprot)
22646 
      oprot.writeFieldEnd()
22647 
    oprot.writeFieldStop()
22648 
    oprot.writeStructEnd()
22649 
 
22650 
  def validate(self):
22651 
    return
22652 
 
22653 
 
22654 
  def __repr__(self):
22655 
    L = ['%s=%r' % (key, value)
22656 
      for key, value in self.__dict__.iteritems()]
22657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22658 
 
22659 
  def __eq__(self, other):
22660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22661 
 
22662 
  def __ne__(self, other):
22663 
    return not (self == other)
22664 
 
5386 phani.kuma 22665 
class getSettlementForPrepaid_args:
4600 varun.gupt 22666 
  """
22667 
  Attributes:
5189 varun.gupt 22668 
   - referenceId
22669 
   - isRefund
4600 varun.gupt 22670 
  """
22671 
 
22672 
  thrift_spec = (
22673 
    None, # 0
5189 varun.gupt 22674 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22675 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22676 
  )
22677 
 
5386 phani.kuma 22678 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22679 
    self.referenceId = referenceId
22680 
    self.isRefund = isRefund
4600 varun.gupt 22681 
 
22682 
  def read(self, iprot):
22683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22685 
      return
22686 
    iprot.readStructBegin()
22687 
    while True:
22688 
      (fname, ftype, fid) = iprot.readFieldBegin()
22689 
      if ftype == TType.STOP:
22690 
        break
22691 
      if fid == 1:
22692 
        if ftype == TType.I64:
5189 varun.gupt 22693 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22694 
        else:
22695 
          iprot.skip(ftype)
5189 varun.gupt 22696 
      elif fid == 2:
22697 
        if ftype == TType.BOOL:
22698 
          self.isRefund = iprot.readBool();
22699 
        else:
22700 
          iprot.skip(ftype)
4600 varun.gupt 22701 
      else:
22702 
        iprot.skip(ftype)
22703 
      iprot.readFieldEnd()
22704 
    iprot.readStructEnd()
22705 
 
22706 
  def write(self, oprot):
22707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22709 
      return
5386 phani.kuma 22710 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22711 
    if self.referenceId is not None:
22712 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22713 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22714 
      oprot.writeFieldEnd()
5386 phani.kuma 22715 
    if self.isRefund is not None:
22716 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22717 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22718 
      oprot.writeFieldEnd()
5386 phani.kuma 22719 
    oprot.writeFieldStop()
22720 
    oprot.writeStructEnd()
22721 
 
22722 
  def validate(self):
22723 
    return
22724 
 
22725 
 
22726 
  def __repr__(self):
22727 
    L = ['%s=%r' % (key, value)
22728 
      for key, value in self.__dict__.iteritems()]
22729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22730 
 
22731 
  def __eq__(self, other):
22732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22733 
 
22734 
  def __ne__(self, other):
22735 
    return not (self == other)
22736 
 
22737 
class getSettlementForPrepaid_result:
22738 
  """
22739 
  Attributes:
22740 
   - success
22741 
   - ex
22742 
  """
22743 
 
22744 
  thrift_spec = (
22745 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22747 
  )
22748 
 
22749 
  def __init__(self, success=None, ex=None,):
22750 
    self.success = success
22751 
    self.ex = ex
22752 
 
22753 
  def read(self, iprot):
22754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22756 
      return
22757 
    iprot.readStructBegin()
22758 
    while True:
22759 
      (fname, ftype, fid) = iprot.readFieldBegin()
22760 
      if ftype == TType.STOP:
22761 
        break
22762 
      if fid == 0:
22763 
        if ftype == TType.STRUCT:
22764 
          self.success = PaymentSettlement()
22765 
          self.success.read(iprot)
22766 
        else:
22767 
          iprot.skip(ftype)
22768 
      elif fid == 1:
22769 
        if ftype == TType.STRUCT:
22770 
          self.ex = TransactionServiceException()
22771 
          self.ex.read(iprot)
22772 
        else:
22773 
          iprot.skip(ftype)
22774 
      else:
22775 
        iprot.skip(ftype)
22776 
      iprot.readFieldEnd()
22777 
    iprot.readStructEnd()
22778 
 
22779 
  def write(self, oprot):
22780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22782 
      return
22783 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22784 
    if self.success is not None:
22785 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22786 
      self.success.write(oprot)
22787 
      oprot.writeFieldEnd()
22788 
    if self.ex is not None:
22789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22790 
      self.ex.write(oprot)
22791 
      oprot.writeFieldEnd()
22792 
    oprot.writeFieldStop()
22793 
    oprot.writeStructEnd()
22794 
 
22795 
  def validate(self):
22796 
    return
22797 
 
22798 
 
22799 
  def __repr__(self):
22800 
    L = ['%s=%r' % (key, value)
22801 
      for key, value in self.__dict__.iteritems()]
22802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22803 
 
22804 
  def __eq__(self, other):
22805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22806 
 
22807 
  def __ne__(self, other):
22808 
    return not (self == other)
22809 
 
22810 
class getSettlementForCod_args:
22811 
  """
22812 
  Attributes:
22813 
   - orderId
22814 
   - isRefund
22815 
  """
22816 
 
22817 
  thrift_spec = (
22818 
    None, # 0
22819 
    (1, TType.I64, 'orderId', None, None, ), # 1
22820 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22821 
  )
22822 
 
22823 
  def __init__(self, orderId=None, isRefund=None,):
22824 
    self.orderId = orderId
22825 
    self.isRefund = isRefund
22826 
 
22827 
  def read(self, iprot):
22828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22830 
      return
22831 
    iprot.readStructBegin()
22832 
    while True:
22833 
      (fname, ftype, fid) = iprot.readFieldBegin()
22834 
      if ftype == TType.STOP:
22835 
        break
22836 
      if fid == 1:
22837 
        if ftype == TType.I64:
22838 
          self.orderId = iprot.readI64();
22839 
        else:
22840 
          iprot.skip(ftype)
22841 
      elif fid == 2:
22842 
        if ftype == TType.BOOL:
22843 
          self.isRefund = iprot.readBool();
22844 
        else:
22845 
          iprot.skip(ftype)
22846 
      else:
22847 
        iprot.skip(ftype)
22848 
      iprot.readFieldEnd()
22849 
    iprot.readStructEnd()
22850 
 
22851 
  def write(self, oprot):
22852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22854 
      return
22855 
    oprot.writeStructBegin('getSettlementForCod_args')
22856 
    if self.orderId is not None:
22857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22858 
      oprot.writeI64(self.orderId)
22859 
      oprot.writeFieldEnd()
5189 varun.gupt 22860 
    if self.isRefund is not None:
5386 phani.kuma 22861 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22862 
      oprot.writeBool(self.isRefund)
22863 
      oprot.writeFieldEnd()
4600 varun.gupt 22864 
    oprot.writeFieldStop()
22865 
    oprot.writeStructEnd()
22866 
 
22867 
  def validate(self):
22868 
    return
22869 
 
22870 
 
22871 
  def __repr__(self):
22872 
    L = ['%s=%r' % (key, value)
22873 
      for key, value in self.__dict__.iteritems()]
22874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22875 
 
22876 
  def __eq__(self, other):
22877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22878 
 
22879 
  def __ne__(self, other):
22880 
    return not (self == other)
22881 
 
5386 phani.kuma 22882 
class getSettlementForCod_result:
4600 varun.gupt 22883 
  """
22884 
  Attributes:
22885 
   - success
22886 
   - ex
22887 
  """
22888 
 
22889 
  thrift_spec = (
22890 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22892 
  )
22893 
 
22894 
  def __init__(self, success=None, ex=None,):
22895 
    self.success = success
22896 
    self.ex = ex
22897 
 
22898 
  def read(self, iprot):
22899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22901 
      return
22902 
    iprot.readStructBegin()
22903 
    while True:
22904 
      (fname, ftype, fid) = iprot.readFieldBegin()
22905 
      if ftype == TType.STOP:
22906 
        break
22907 
      if fid == 0:
22908 
        if ftype == TType.STRUCT:
22909 
          self.success = PaymentSettlement()
22910 
          self.success.read(iprot)
22911 
        else:
22912 
          iprot.skip(ftype)
22913 
      elif fid == 1:
22914 
        if ftype == TType.STRUCT:
22915 
          self.ex = TransactionServiceException()
22916 
          self.ex.read(iprot)
22917 
        else:
22918 
          iprot.skip(ftype)
22919 
      else:
22920 
        iprot.skip(ftype)
22921 
      iprot.readFieldEnd()
22922 
    iprot.readStructEnd()
22923 
 
22924 
  def write(self, oprot):
22925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22927 
      return
5386 phani.kuma 22928 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22929 
    if self.success is not None:
22930 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22931 
      self.success.write(oprot)
22932 
      oprot.writeFieldEnd()
22933 
    if self.ex is not None:
22934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22935 
      self.ex.write(oprot)
22936 
      oprot.writeFieldEnd()
22937 
    oprot.writeFieldStop()
22938 
    oprot.writeStructEnd()
22939 
 
22940 
  def validate(self):
22941 
    return
22942 
 
22943 
 
22944 
  def __repr__(self):
22945 
    L = ['%s=%r' % (key, value)
22946 
      for key, value in self.__dict__.iteritems()]
22947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22948 
 
22949 
  def __eq__(self, other):
22950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22951 
 
22952 
  def __ne__(self, other):
22953 
    return not (self == other)
22954 
 
22955 
class getEBSSettlementSummaries_args:
22956 
 
22957 
  thrift_spec = (
22958 
  )
22959 
 
22960 
  def read(self, iprot):
22961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22963 
      return
22964 
    iprot.readStructBegin()
22965 
    while True:
22966 
      (fname, ftype, fid) = iprot.readFieldBegin()
22967 
      if ftype == TType.STOP:
22968 
        break
22969 
      else:
22970 
        iprot.skip(ftype)
22971 
      iprot.readFieldEnd()
22972 
    iprot.readStructEnd()
22973 
 
22974 
  def write(self, oprot):
22975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22977 
      return
22978 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22979 
    oprot.writeFieldStop()
22980 
    oprot.writeStructEnd()
22981 
 
22982 
  def validate(self):
22983 
    return
22984 
 
22985 
 
22986 
  def __repr__(self):
22987 
    L = ['%s=%r' % (key, value)
22988 
      for key, value in self.__dict__.iteritems()]
22989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22990 
 
22991 
  def __eq__(self, other):
22992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22993 
 
22994 
  def __ne__(self, other):
22995 
    return not (self == other)
22996 
 
22997 
class getEBSSettlementSummaries_result:
22998 
  """
22999 
  Attributes:
23000 
   - success
23001 
   - ex
23002 
  """
23003 
 
23004 
  thrift_spec = (
23005 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23007 
  )
23008 
 
23009 
  def __init__(self, success=None, ex=None,):
23010 
    self.success = success
23011 
    self.ex = ex
23012 
 
23013 
  def read(self, iprot):
23014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23016 
      return
23017 
    iprot.readStructBegin()
23018 
    while True:
23019 
      (fname, ftype, fid) = iprot.readFieldBegin()
23020 
      if ftype == TType.STOP:
23021 
        break
23022 
      if fid == 0:
23023 
        if ftype == TType.MAP:
23024 
          self.success = {}
6031 rajveer 23025 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
23026 
          for _i515 in xrange(_size511):
23027 
            _key516 = iprot.readI64();
23028 
            _val517 = iprot.readString();
23029 
            self.success[_key516] = _val517
4600 varun.gupt 23030 
          iprot.readMapEnd()
23031 
        else:
23032 
          iprot.skip(ftype)
23033 
      elif fid == 1:
23034 
        if ftype == TType.STRUCT:
23035 
          self.ex = TransactionServiceException()
23036 
          self.ex.read(iprot)
23037 
        else:
23038 
          iprot.skip(ftype)
23039 
      else:
23040 
        iprot.skip(ftype)
23041 
      iprot.readFieldEnd()
23042 
    iprot.readStructEnd()
23043 
 
23044 
  def write(self, oprot):
23045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23047 
      return
23048 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23049 
    if self.success is not None:
23050 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23051 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 23052 
      for kiter518,viter519 in self.success.items():
23053 
        oprot.writeI64(kiter518)
23054 
        oprot.writeString(viter519)
4600 varun.gupt 23055 
      oprot.writeMapEnd()
23056 
      oprot.writeFieldEnd()
23057 
    if self.ex is not None:
23058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23059 
      self.ex.write(oprot)
23060 
      oprot.writeFieldEnd()
23061 
    oprot.writeFieldStop()
23062 
    oprot.writeStructEnd()
23063 
 
23064 
  def validate(self):
23065 
    return
23066 
 
23067 
 
23068 
  def __repr__(self):
23069 
    L = ['%s=%r' % (key, value)
23070 
      for key, value in self.__dict__.iteritems()]
23071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23072 
 
23073 
  def __eq__(self, other):
23074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23075 
 
23076 
  def __ne__(self, other):
23077 
    return not (self == other)
23078 
 
23079 
class markEBSSettlementUploaded_args:
23080 
  """
23081 
  Attributes:
23082 
   - settlementId
23083 
  """
23084 
 
23085 
  thrift_spec = (
23086 
    None, # 0
23087 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23088 
  )
23089 
 
23090 
  def __init__(self, settlementId=None,):
23091 
    self.settlementId = settlementId
23092 
 
23093 
  def read(self, iprot):
23094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23096 
      return
23097 
    iprot.readStructBegin()
23098 
    while True:
23099 
      (fname, ftype, fid) = iprot.readFieldBegin()
23100 
      if ftype == TType.STOP:
23101 
        break
23102 
      if fid == 1:
23103 
        if ftype == TType.I64:
23104 
          self.settlementId = iprot.readI64();
23105 
        else:
23106 
          iprot.skip(ftype)
23107 
      else:
23108 
        iprot.skip(ftype)
23109 
      iprot.readFieldEnd()
23110 
    iprot.readStructEnd()
23111 
 
23112 
  def write(self, oprot):
23113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23115 
      return
23116 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23117 
    if self.settlementId is not None:
23118 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23119 
      oprot.writeI64(self.settlementId)
23120 
      oprot.writeFieldEnd()
23121 
    oprot.writeFieldStop()
23122 
    oprot.writeStructEnd()
23123 
 
23124 
  def validate(self):
23125 
    return
23126 
 
23127 
 
23128 
  def __repr__(self):
23129 
    L = ['%s=%r' % (key, value)
23130 
      for key, value in self.__dict__.iteritems()]
23131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23132 
 
23133 
  def __eq__(self, other):
23134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23135 
 
23136 
  def __ne__(self, other):
23137 
    return not (self == other)
23138 
 
23139 
class markEBSSettlementUploaded_result:
23140 
  """
23141 
  Attributes:
23142 
   - ex
23143 
  """
23144 
 
23145 
  thrift_spec = (
23146 
    None, # 0
23147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23148 
  )
23149 
 
23150 
  def __init__(self, ex=None,):
23151 
    self.ex = ex
23152 
 
23153 
  def read(self, iprot):
23154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23156 
      return
23157 
    iprot.readStructBegin()
23158 
    while True:
23159 
      (fname, ftype, fid) = iprot.readFieldBegin()
23160 
      if ftype == TType.STOP:
23161 
        break
23162 
      if fid == 1:
23163 
        if ftype == TType.STRUCT:
23164 
          self.ex = TransactionServiceException()
23165 
          self.ex.read(iprot)
23166 
        else:
23167 
          iprot.skip(ftype)
23168 
      else:
23169 
        iprot.skip(ftype)
23170 
      iprot.readFieldEnd()
23171 
    iprot.readStructEnd()
23172 
 
23173 
  def write(self, oprot):
23174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23176 
      return
23177 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23178 
    if self.ex is not None:
23179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23180 
      self.ex.write(oprot)
23181 
      oprot.writeFieldEnd()
23182 
    oprot.writeFieldStop()
23183 
    oprot.writeStructEnd()
23184 
 
23185 
  def validate(self):
23186 
    return
23187 
 
23188 
 
23189 
  def __repr__(self):
23190 
    L = ['%s=%r' % (key, value)
23191 
      for key, value in self.__dict__.iteritems()]
23192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23193 
 
23194 
  def __eq__(self, other):
23195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23196 
 
23197 
  def __ne__(self, other):
23198 
    return not (self == other)
23199 
 
23200 
class getEBSSettlementDate_args:
23201 
  """
23202 
  Attributes:
23203 
   - settlementId
23204 
  """
23205 
 
23206 
  thrift_spec = (
23207 
    None, # 0
23208 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23209 
  )
23210 
 
23211 
  def __init__(self, settlementId=None,):
23212 
    self.settlementId = settlementId
23213 
 
23214 
  def read(self, iprot):
23215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23217 
      return
23218 
    iprot.readStructBegin()
23219 
    while True:
23220 
      (fname, ftype, fid) = iprot.readFieldBegin()
23221 
      if ftype == TType.STOP:
23222 
        break
23223 
      if fid == 1:
23224 
        if ftype == TType.I64:
23225 
          self.settlementId = iprot.readI64();
23226 
        else:
23227 
          iprot.skip(ftype)
23228 
      else:
23229 
        iprot.skip(ftype)
23230 
      iprot.readFieldEnd()
23231 
    iprot.readStructEnd()
23232 
 
23233 
  def write(self, oprot):
23234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23236 
      return
23237 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23238 
    if self.settlementId is not None:
23239 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23240 
      oprot.writeI64(self.settlementId)
23241 
      oprot.writeFieldEnd()
23242 
    oprot.writeFieldStop()
23243 
    oprot.writeStructEnd()
23244 
 
23245 
  def validate(self):
23246 
    return
23247 
 
23248 
 
23249 
  def __repr__(self):
23250 
    L = ['%s=%r' % (key, value)
23251 
      for key, value in self.__dict__.iteritems()]
23252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23253 
 
23254 
  def __eq__(self, other):
23255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23256 
 
23257 
  def __ne__(self, other):
23258 
    return not (self == other)
23259 
 
23260 
class getEBSSettlementDate_result:
23261 
  """
23262 
  Attributes:
23263 
   - success
23264 
   - ex
23265 
  """
23266 
 
23267 
  thrift_spec = (
23268 
    (0, TType.I64, 'success', None, None, ), # 0
23269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23270 
  )
23271 
 
23272 
  def __init__(self, success=None, ex=None,):
23273 
    self.success = success
23274 
    self.ex = ex
23275 
 
23276 
  def read(self, iprot):
23277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23279 
      return
23280 
    iprot.readStructBegin()
23281 
    while True:
23282 
      (fname, ftype, fid) = iprot.readFieldBegin()
23283 
      if ftype == TType.STOP:
23284 
        break
23285 
      if fid == 0:
23286 
        if ftype == TType.I64:
23287 
          self.success = iprot.readI64();
23288 
        else:
23289 
          iprot.skip(ftype)
23290 
      elif fid == 1:
23291 
        if ftype == TType.STRUCT:
23292 
          self.ex = TransactionServiceException()
23293 
          self.ex.read(iprot)
23294 
        else:
23295 
          iprot.skip(ftype)
23296 
      else:
23297 
        iprot.skip(ftype)
23298 
      iprot.readFieldEnd()
23299 
    iprot.readStructEnd()
23300 
 
23301 
  def write(self, oprot):
23302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23304 
      return
23305 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23306 
    if self.success is not None:
23307 
      oprot.writeFieldBegin('success', TType.I64, 0)
23308 
      oprot.writeI64(self.success)
23309 
      oprot.writeFieldEnd()
23310 
    if self.ex is not None:
23311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23312 
      self.ex.write(oprot)
23313 
      oprot.writeFieldEnd()
23314 
    oprot.writeFieldStop()
23315 
    oprot.writeStructEnd()
23316 
 
23317 
  def validate(self):
23318 
    return
23319 
 
23320 
 
23321 
  def __repr__(self):
23322 
    L = ['%s=%r' % (key, value)
23323 
      for key, value in self.__dict__.iteritems()]
23324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23325 
 
23326 
  def __eq__(self, other):
23327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23328 
 
23329 
  def __ne__(self, other):
23330 
    return not (self == other)
4715 varun.gupt 23331 
 
23332 
class getSettlementsByDate_args:
23333 
  """
23334 
  Attributes:
23335 
   - settlementDateFrom
23336 
   - settlementDateTo
23337 
   - isRefund
23338 
  """
23339 
 
23340 
  thrift_spec = (
23341 
    None, # 0
23342 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23343 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23344 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23345 
  )
23346 
 
23347 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23348 
    self.settlementDateFrom = settlementDateFrom
23349 
    self.settlementDateTo = settlementDateTo
23350 
    self.isRefund = isRefund
23351 
 
23352 
  def read(self, iprot):
23353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23355 
      return
23356 
    iprot.readStructBegin()
23357 
    while True:
23358 
      (fname, ftype, fid) = iprot.readFieldBegin()
23359 
      if ftype == TType.STOP:
23360 
        break
23361 
      if fid == 1:
23362 
        if ftype == TType.I64:
23363 
          self.settlementDateFrom = iprot.readI64();
23364 
        else:
23365 
          iprot.skip(ftype)
23366 
      elif fid == 2:
23367 
        if ftype == TType.I64:
23368 
          self.settlementDateTo = iprot.readI64();
23369 
        else:
23370 
          iprot.skip(ftype)
23371 
      elif fid == 3:
23372 
        if ftype == TType.BOOL:
23373 
          self.isRefund = iprot.readBool();
23374 
        else:
23375 
          iprot.skip(ftype)
23376 
      else:
23377 
        iprot.skip(ftype)
23378 
      iprot.readFieldEnd()
23379 
    iprot.readStructEnd()
23380 
 
23381 
  def write(self, oprot):
23382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23384 
      return
23385 
    oprot.writeStructBegin('getSettlementsByDate_args')
23386 
    if self.settlementDateFrom is not None:
23387 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23388 
      oprot.writeI64(self.settlementDateFrom)
23389 
      oprot.writeFieldEnd()
23390 
    if self.settlementDateTo is not None:
23391 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23392 
      oprot.writeI64(self.settlementDateTo)
23393 
      oprot.writeFieldEnd()
23394 
    if self.isRefund is not None:
23395 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23396 
      oprot.writeBool(self.isRefund)
23397 
      oprot.writeFieldEnd()
23398 
    oprot.writeFieldStop()
23399 
    oprot.writeStructEnd()
23400 
 
23401 
  def validate(self):
23402 
    return
23403 
 
23404 
 
23405 
  def __repr__(self):
23406 
    L = ['%s=%r' % (key, value)
23407 
      for key, value in self.__dict__.iteritems()]
23408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23409 
 
23410 
  def __eq__(self, other):
23411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23412 
 
23413 
  def __ne__(self, other):
23414 
    return not (self == other)
23415 
 
23416 
class getSettlementsByDate_result:
23417 
  """
23418 
  Attributes:
23419 
   - success
23420 
   - ex
23421 
  """
23422 
 
23423 
  thrift_spec = (
23424 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23426 
  )
23427 
 
23428 
  def __init__(self, success=None, ex=None,):
23429 
    self.success = success
23430 
    self.ex = ex
23431 
 
23432 
  def read(self, iprot):
23433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23435 
      return
23436 
    iprot.readStructBegin()
23437 
    while True:
23438 
      (fname, ftype, fid) = iprot.readFieldBegin()
23439 
      if ftype == TType.STOP:
23440 
        break
23441 
      if fid == 0:
23442 
        if ftype == TType.LIST:
23443 
          self.success = []
6031 rajveer 23444 
          (_etype523, _size520) = iprot.readListBegin()
23445 
          for _i524 in xrange(_size520):
23446 
            _elem525 = PaymentSettlement()
23447 
            _elem525.read(iprot)
23448 
            self.success.append(_elem525)
4715 varun.gupt 23449 
          iprot.readListEnd()
23450 
        else:
23451 
          iprot.skip(ftype)
23452 
      elif fid == 1:
23453 
        if ftype == TType.STRUCT:
23454 
          self.ex = TransactionServiceException()
23455 
          self.ex.read(iprot)
23456 
        else:
23457 
          iprot.skip(ftype)
23458 
      else:
23459 
        iprot.skip(ftype)
23460 
      iprot.readFieldEnd()
23461 
    iprot.readStructEnd()
23462 
 
23463 
  def write(self, oprot):
23464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23466 
      return
23467 
    oprot.writeStructBegin('getSettlementsByDate_result')
23468 
    if self.success is not None:
23469 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23470 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23471 
      for iter526 in self.success:
23472 
        iter526.write(oprot)
4715 varun.gupt 23473 
      oprot.writeListEnd()
23474 
      oprot.writeFieldEnd()
23475 
    if self.ex is not None:
23476 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23477 
      self.ex.write(oprot)
23478 
      oprot.writeFieldEnd()
23479 
    oprot.writeFieldStop()
23480 
    oprot.writeStructEnd()
23481 
 
23482 
  def validate(self):
23483 
    return
23484 
 
23485 
 
23486 
  def __repr__(self):
23487 
    L = ['%s=%r' % (key, value)
23488 
      for key, value in self.__dict__.iteritems()]
23489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23490 
 
23491 
  def __eq__(self, other):
23492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23493 
 
23494 
  def __ne__(self, other):
23495 
    return not (self == other)
23496 
 
23497 
class getReshippedOrderIds_args:
23498 
  """
23499 
  Attributes:
23500 
   - orderIds
23501 
  """
23502 
 
23503 
  thrift_spec = (
23504 
    None, # 0
23505 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23506 
  )
23507 
 
23508 
  def __init__(self, orderIds=None,):
23509 
    self.orderIds = orderIds
23510 
 
23511 
  def read(self, iprot):
23512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23514 
      return
23515 
    iprot.readStructBegin()
23516 
    while True:
23517 
      (fname, ftype, fid) = iprot.readFieldBegin()
23518 
      if ftype == TType.STOP:
23519 
        break
23520 
      if fid == 1:
23521 
        if ftype == TType.LIST:
23522 
          self.orderIds = []
6031 rajveer 23523 
          (_etype530, _size527) = iprot.readListBegin()
23524 
          for _i531 in xrange(_size527):
23525 
            _elem532 = iprot.readI64();
23526 
            self.orderIds.append(_elem532)
4715 varun.gupt 23527 
          iprot.readListEnd()
23528 
        else:
23529 
          iprot.skip(ftype)
23530 
      else:
23531 
        iprot.skip(ftype)
23532 
      iprot.readFieldEnd()
23533 
    iprot.readStructEnd()
23534 
 
23535 
  def write(self, oprot):
23536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23538 
      return
23539 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23540 
    if self.orderIds is not None:
23541 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23542 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23543 
      for iter533 in self.orderIds:
23544 
        oprot.writeI64(iter533)
4715 varun.gupt 23545 
      oprot.writeListEnd()
23546 
      oprot.writeFieldEnd()
23547 
    oprot.writeFieldStop()
23548 
    oprot.writeStructEnd()
23549 
 
23550 
  def validate(self):
23551 
    return
23552 
 
23553 
 
23554 
  def __repr__(self):
23555 
    L = ['%s=%r' % (key, value)
23556 
      for key, value in self.__dict__.iteritems()]
23557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23558 
 
23559 
  def __eq__(self, other):
23560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23561 
 
23562 
  def __ne__(self, other):
23563 
    return not (self == other)
23564 
 
23565 
class getReshippedOrderIds_result:
23566 
  """
23567 
  Attributes:
23568 
   - success
23569 
   - ex
23570 
  """
23571 
 
23572 
  thrift_spec = (
23573 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23575 
  )
23576 
 
23577 
  def __init__(self, success=None, ex=None,):
23578 
    self.success = success
23579 
    self.ex = ex
23580 
 
23581 
  def read(self, iprot):
23582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23584 
      return
23585 
    iprot.readStructBegin()
23586 
    while True:
23587 
      (fname, ftype, fid) = iprot.readFieldBegin()
23588 
      if ftype == TType.STOP:
23589 
        break
23590 
      if fid == 0:
23591 
        if ftype == TType.LIST:
23592 
          self.success = []
6031 rajveer 23593 
          (_etype537, _size534) = iprot.readListBegin()
23594 
          for _i538 in xrange(_size534):
23595 
            _elem539 = iprot.readI64();
23596 
            self.success.append(_elem539)
4715 varun.gupt 23597 
          iprot.readListEnd()
23598 
        else:
23599 
          iprot.skip(ftype)
23600 
      elif fid == 1:
23601 
        if ftype == TType.STRUCT:
23602 
          self.ex = TransactionServiceException()
23603 
          self.ex.read(iprot)
23604 
        else:
23605 
          iprot.skip(ftype)
23606 
      else:
23607 
        iprot.skip(ftype)
23608 
      iprot.readFieldEnd()
23609 
    iprot.readStructEnd()
23610 
 
23611 
  def write(self, oprot):
23612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23614 
      return
23615 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23616 
    if self.success is not None:
23617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23618 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23619 
      for iter540 in self.success:
23620 
        oprot.writeI64(iter540)
4715 varun.gupt 23621 
      oprot.writeListEnd()
23622 
      oprot.writeFieldEnd()
23623 
    if self.ex is not None:
23624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23625 
      self.ex.write(oprot)
23626 
      oprot.writeFieldEnd()
23627 
    oprot.writeFieldStop()
23628 
    oprot.writeStructEnd()
23629 
 
23630 
  def validate(self):
23631 
    return
23632 
 
23633 
 
23634 
  def __repr__(self):
23635 
    L = ['%s=%r' % (key, value)
23636 
      for key, value in self.__dict__.iteritems()]
23637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23638 
 
23639 
  def __eq__(self, other):
23640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23641 
 
23642 
  def __ne__(self, other):
23643 
    return not (self == other)
4757 mandeep.dh 23644 
 
5481 phani.kuma 23645 
class getBilledOrders_args:
4875 varun.gupt 23646 
  """
23647 
  Attributes:
23648 
   - vendorId
5481 phani.kuma 23649 
   - onlyVendorNotPaid
23650 
   - billingDateFrom
23651 
   - billingDateTo
4875 varun.gupt 23652 
  """
23653 
 
23654 
  thrift_spec = (
23655 
    None, # 0
23656 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23657 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23658 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23659 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23660 
  )
23661 
 
5481 phani.kuma 23662 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23663 
    self.vendorId = vendorId
5481 phani.kuma 23664 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23665 
    self.billingDateFrom = billingDateFrom
23666 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23667 
 
23668 
  def read(self, iprot):
23669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23671 
      return
23672 
    iprot.readStructBegin()
23673 
    while True:
23674 
      (fname, ftype, fid) = iprot.readFieldBegin()
23675 
      if ftype == TType.STOP:
23676 
        break
23677 
      if fid == 1:
23678 
        if ftype == TType.I64:
23679 
          self.vendorId = iprot.readI64();
23680 
        else:
23681 
          iprot.skip(ftype)
5481 phani.kuma 23682 
      elif fid == 2:
23683 
        if ftype == TType.BOOL:
23684 
          self.onlyVendorNotPaid = iprot.readBool();
23685 
        else:
23686 
          iprot.skip(ftype)
23687 
      elif fid == 3:
23688 
        if ftype == TType.I64:
23689 
          self.billingDateFrom = iprot.readI64();
23690 
        else:
23691 
          iprot.skip(ftype)
23692 
      elif fid == 4:
23693 
        if ftype == TType.I64:
23694 
          self.billingDateTo = iprot.readI64();
23695 
        else:
23696 
          iprot.skip(ftype)
4875 varun.gupt 23697 
      else:
23698 
        iprot.skip(ftype)
23699 
      iprot.readFieldEnd()
23700 
    iprot.readStructEnd()
23701 
 
23702 
  def write(self, oprot):
23703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23705 
      return
5481 phani.kuma 23706 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23707 
    if self.vendorId is not None:
23708 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23709 
      oprot.writeI64(self.vendorId)
23710 
      oprot.writeFieldEnd()
5481 phani.kuma 23711 
    if self.onlyVendorNotPaid is not None:
23712 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23713 
      oprot.writeBool(self.onlyVendorNotPaid)
23714 
      oprot.writeFieldEnd()
23715 
    if self.billingDateFrom is not None:
23716 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23717 
      oprot.writeI64(self.billingDateFrom)
23718 
      oprot.writeFieldEnd()
23719 
    if self.billingDateTo is not None:
23720 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23721 
      oprot.writeI64(self.billingDateTo)
23722 
      oprot.writeFieldEnd()
4875 varun.gupt 23723 
    oprot.writeFieldStop()
23724 
    oprot.writeStructEnd()
23725 
 
23726 
  def validate(self):
23727 
    return
23728 
 
23729 
 
23730 
  def __repr__(self):
23731 
    L = ['%s=%r' % (key, value)
23732 
      for key, value in self.__dict__.iteritems()]
23733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23734 
 
23735 
  def __eq__(self, other):
23736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23737 
 
23738 
  def __ne__(self, other):
23739 
    return not (self == other)
23740 
 
5481 phani.kuma 23741 
class getBilledOrders_result:
4875 varun.gupt 23742 
  """
23743 
  Attributes:
23744 
   - success
23745 
   - ex
23746 
  """
23747 
 
23748 
  thrift_spec = (
23749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23751 
  )
23752 
 
23753 
  def __init__(self, success=None, ex=None,):
23754 
    self.success = success
23755 
    self.ex = ex
23756 
 
23757 
  def read(self, iprot):
23758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23760 
      return
23761 
    iprot.readStructBegin()
23762 
    while True:
23763 
      (fname, ftype, fid) = iprot.readFieldBegin()
23764 
      if ftype == TType.STOP:
23765 
        break
23766 
      if fid == 0:
23767 
        if ftype == TType.LIST:
23768 
          self.success = []
6031 rajveer 23769 
          (_etype544, _size541) = iprot.readListBegin()
23770 
          for _i545 in xrange(_size541):
23771 
            _elem546 = Order()
23772 
            _elem546.read(iprot)
23773 
            self.success.append(_elem546)
4875 varun.gupt 23774 
          iprot.readListEnd()
23775 
        else:
23776 
          iprot.skip(ftype)
23777 
      elif fid == 1:
23778 
        if ftype == TType.STRUCT:
23779 
          self.ex = TransactionServiceException()
23780 
          self.ex.read(iprot)
23781 
        else:
23782 
          iprot.skip(ftype)
23783 
      else:
23784 
        iprot.skip(ftype)
23785 
      iprot.readFieldEnd()
23786 
    iprot.readStructEnd()
23787 
 
23788 
  def write(self, oprot):
23789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23791 
      return
5481 phani.kuma 23792 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23793 
    if self.success is not None:
23794 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23795 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23796 
      for iter547 in self.success:
23797 
        iter547.write(oprot)
4875 varun.gupt 23798 
      oprot.writeListEnd()
23799 
      oprot.writeFieldEnd()
23800 
    if self.ex is not None:
23801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23802 
      self.ex.write(oprot)
23803 
      oprot.writeFieldEnd()
23804 
    oprot.writeFieldStop()
23805 
    oprot.writeStructEnd()
23806 
 
23807 
  def validate(self):
23808 
    return
23809 
 
23810 
 
23811 
  def __repr__(self):
23812 
    L = ['%s=%r' % (key, value)
23813 
      for key, value in self.__dict__.iteritems()]
23814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23815 
 
23816 
  def __eq__(self, other):
23817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23818 
 
23819 
  def __ne__(self, other):
23820 
    return not (self == other)
5031 varun.gupt 23821 
 
23822 
class getStatusDistributionOfOrders_args:
23823 
  """
23824 
  Attributes:
23825 
   - startDate
23826 
   - endDate
23827 
  """
23828 
 
23829 
  thrift_spec = (
23830 
    None, # 0
23831 
    (1, TType.I64, 'startDate', None, None, ), # 1
23832 
    (2, TType.I64, 'endDate', None, None, ), # 2
23833 
  )
23834 
 
23835 
  def __init__(self, startDate=None, endDate=None,):
23836 
    self.startDate = startDate
23837 
    self.endDate = endDate
23838 
 
23839 
  def read(self, iprot):
23840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23842 
      return
23843 
    iprot.readStructBegin()
23844 
    while True:
23845 
      (fname, ftype, fid) = iprot.readFieldBegin()
23846 
      if ftype == TType.STOP:
23847 
        break
23848 
      if fid == 1:
23849 
        if ftype == TType.I64:
23850 
          self.startDate = iprot.readI64();
23851 
        else:
23852 
          iprot.skip(ftype)
23853 
      elif fid == 2:
23854 
        if ftype == TType.I64:
23855 
          self.endDate = iprot.readI64();
23856 
        else:
23857 
          iprot.skip(ftype)
23858 
      else:
23859 
        iprot.skip(ftype)
23860 
      iprot.readFieldEnd()
23861 
    iprot.readStructEnd()
23862 
 
23863 
  def write(self, oprot):
23864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23866 
      return
23867 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23868 
    if self.startDate is not None:
23869 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23870 
      oprot.writeI64(self.startDate)
23871 
      oprot.writeFieldEnd()
23872 
    if self.endDate is not None:
23873 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23874 
      oprot.writeI64(self.endDate)
23875 
      oprot.writeFieldEnd()
23876 
    oprot.writeFieldStop()
23877 
    oprot.writeStructEnd()
23878 
 
23879 
  def validate(self):
23880 
    return
23881 
 
23882 
 
23883 
  def __repr__(self):
23884 
    L = ['%s=%r' % (key, value)
23885 
      for key, value in self.__dict__.iteritems()]
23886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23887 
 
23888 
  def __eq__(self, other):
23889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23890 
 
23891 
  def __ne__(self, other):
23892 
    return not (self == other)
23893 
 
23894 
class getStatusDistributionOfOrders_result:
23895 
  """
23896 
  Attributes:
23897 
   - success
23898 
   - ex
23899 
  """
23900 
 
23901 
  thrift_spec = (
23902 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23904 
  )
23905 
 
23906 
  def __init__(self, success=None, ex=None,):
23907 
    self.success = success
23908 
    self.ex = ex
23909 
 
23910 
  def read(self, iprot):
23911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23913 
      return
23914 
    iprot.readStructBegin()
23915 
    while True:
23916 
      (fname, ftype, fid) = iprot.readFieldBegin()
23917 
      if ftype == TType.STOP:
23918 
        break
23919 
      if fid == 0:
23920 
        if ftype == TType.MAP:
23921 
          self.success = {}
6031 rajveer 23922 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23923 
          for _i552 in xrange(_size548):
23924 
            _key553 = iprot.readI64();
23925 
            _val554 = iprot.readI64();
23926 
            self.success[_key553] = _val554
5031 varun.gupt 23927 
          iprot.readMapEnd()
23928 
        else:
23929 
          iprot.skip(ftype)
23930 
      elif fid == 1:
23931 
        if ftype == TType.STRUCT:
23932 
          self.ex = TransactionServiceException()
23933 
          self.ex.read(iprot)
23934 
        else:
23935 
          iprot.skip(ftype)
23936 
      else:
23937 
        iprot.skip(ftype)
23938 
      iprot.readFieldEnd()
23939 
    iprot.readStructEnd()
23940 
 
23941 
  def write(self, oprot):
23942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23944 
      return
23945 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23946 
    if self.success is not None:
23947 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23948 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 23949 
      for kiter555,viter556 in self.success.items():
23950 
        oprot.writeI64(kiter555)
23951 
        oprot.writeI64(viter556)
5031 varun.gupt 23952 
      oprot.writeMapEnd()
23953 
      oprot.writeFieldEnd()
23954 
    if self.ex is not None:
23955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23956 
      self.ex.write(oprot)
23957 
      oprot.writeFieldEnd()
23958 
    oprot.writeFieldStop()
23959 
    oprot.writeStructEnd()
23960 
 
23961 
  def validate(self):
23962 
    return
23963 
 
23964 
 
23965 
  def __repr__(self):
23966 
    L = ['%s=%r' % (key, value)
23967 
      for key, value in self.__dict__.iteritems()]
23968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23969 
 
23970 
  def __eq__(self, other):
23971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23972 
 
23973 
  def __ne__(self, other):
23974 
    return not (self == other)
5067 varun.gupt 23975 
 
23976 
class getOrderIdsForStatus_args:
23977 
  """
23978 
  Attributes:
23979 
   - status
23980 
   - startDatetime
23981 
   - endDatetime
23982 
  """
23983 
 
23984 
  thrift_spec = (
23985 
    None, # 0
23986 
    (1, TType.I64, 'status', None, None, ), # 1
23987 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23988 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23989 
  )
23990 
 
23991 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23992 
    self.status = status
23993 
    self.startDatetime = startDatetime
23994 
    self.endDatetime = endDatetime
23995 
 
23996 
  def read(self, iprot):
23997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23999 
      return
24000 
    iprot.readStructBegin()
24001 
    while True:
24002 
      (fname, ftype, fid) = iprot.readFieldBegin()
24003 
      if ftype == TType.STOP:
24004 
        break
24005 
      if fid == 1:
24006 
        if ftype == TType.I64:
24007 
          self.status = iprot.readI64();
24008 
        else:
24009 
          iprot.skip(ftype)
24010 
      elif fid == 2:
24011 
        if ftype == TType.I64:
24012 
          self.startDatetime = iprot.readI64();
24013 
        else:
24014 
          iprot.skip(ftype)
24015 
      elif fid == 3:
24016 
        if ftype == TType.I64:
24017 
          self.endDatetime = iprot.readI64();
24018 
        else:
24019 
          iprot.skip(ftype)
24020 
      else:
24021 
        iprot.skip(ftype)
24022 
      iprot.readFieldEnd()
24023 
    iprot.readStructEnd()
24024 
 
24025 
  def write(self, oprot):
24026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24028 
      return
24029 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24030 
    if self.status is not None:
24031 
      oprot.writeFieldBegin('status', TType.I64, 1)
24032 
      oprot.writeI64(self.status)
24033 
      oprot.writeFieldEnd()
24034 
    if self.startDatetime is not None:
24035 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24036 
      oprot.writeI64(self.startDatetime)
24037 
      oprot.writeFieldEnd()
24038 
    if self.endDatetime is not None:
24039 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24040 
      oprot.writeI64(self.endDatetime)
24041 
      oprot.writeFieldEnd()
24042 
    oprot.writeFieldStop()
24043 
    oprot.writeStructEnd()
24044 
 
24045 
  def validate(self):
24046 
    return
24047 
 
24048 
 
24049 
  def __repr__(self):
24050 
    L = ['%s=%r' % (key, value)
24051 
      for key, value in self.__dict__.iteritems()]
24052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24053 
 
24054 
  def __eq__(self, other):
24055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24056 
 
24057 
  def __ne__(self, other):
24058 
    return not (self == other)
24059 
 
24060 
class getOrderIdsForStatus_result:
24061 
  """
24062 
  Attributes:
24063 
   - success
24064 
   - ex
24065 
  """
24066 
 
24067 
  thrift_spec = (
24068 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24070 
  )
24071 
 
24072 
  def __init__(self, success=None, ex=None,):
24073 
    self.success = success
24074 
    self.ex = ex
24075 
 
24076 
  def read(self, iprot):
24077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24079 
      return
24080 
    iprot.readStructBegin()
24081 
    while True:
24082 
      (fname, ftype, fid) = iprot.readFieldBegin()
24083 
      if ftype == TType.STOP:
24084 
        break
24085 
      if fid == 0:
24086 
        if ftype == TType.LIST:
24087 
          self.success = []
6031 rajveer 24088 
          (_etype560, _size557) = iprot.readListBegin()
24089 
          for _i561 in xrange(_size557):
24090 
            _elem562 = iprot.readI64();
24091 
            self.success.append(_elem562)
5067 varun.gupt 24092 
          iprot.readListEnd()
24093 
        else:
24094 
          iprot.skip(ftype)
24095 
      elif fid == 1:
24096 
        if ftype == TType.STRUCT:
24097 
          self.ex = TransactionServiceException()
24098 
          self.ex.read(iprot)
24099 
        else:
24100 
          iprot.skip(ftype)
24101 
      else:
24102 
        iprot.skip(ftype)
24103 
      iprot.readFieldEnd()
24104 
    iprot.readStructEnd()
24105 
 
24106 
  def write(self, oprot):
24107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24109 
      return
24110 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24111 
    if self.success is not None:
24112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24113 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24114 
      for iter563 in self.success:
24115 
        oprot.writeI64(iter563)
5067 varun.gupt 24116 
      oprot.writeListEnd()
24117 
      oprot.writeFieldEnd()
24118 
    if self.ex is not None:
24119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24120 
      self.ex.write(oprot)
24121 
      oprot.writeFieldEnd()
24122 
    oprot.writeFieldStop()
24123 
    oprot.writeStructEnd()
24124 
 
24125 
  def validate(self):
24126 
    return
24127 
 
24128 
 
24129 
  def __repr__(self):
24130 
    L = ['%s=%r' % (key, value)
24131 
      for key, value in self.__dict__.iteritems()]
24132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24133 
 
24134 
  def __eq__(self, other):
24135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24136 
 
24137 
  def __ne__(self, other):
24138 
    return not (self == other)
5099 varun.gupt 24139 
 
5348 anupam.sin 24140 
class updateCODAgent_args:
24141 
  """
24142 
  Attributes:
24143 
   - agent
24144 
   - orderId
24145 
  """
24146 
 
24147 
  thrift_spec = (
24148 
    None, # 0
24149 
    (1, TType.STRING, 'agent', None, None, ), # 1
24150 
    (2, TType.I64, 'orderId', None, None, ), # 2
24151 
  )
24152 
 
24153 
  def __init__(self, agent=None, orderId=None,):
24154 
    self.agent = agent
24155 
    self.orderId = orderId
24156 
 
24157 
  def read(self, iprot):
24158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24160 
      return
24161 
    iprot.readStructBegin()
24162 
    while True:
24163 
      (fname, ftype, fid) = iprot.readFieldBegin()
24164 
      if ftype == TType.STOP:
24165 
        break
24166 
      if fid == 1:
24167 
        if ftype == TType.STRING:
24168 
          self.agent = iprot.readString();
24169 
        else:
24170 
          iprot.skip(ftype)
24171 
      elif fid == 2:
24172 
        if ftype == TType.I64:
24173 
          self.orderId = iprot.readI64();
24174 
        else:
24175 
          iprot.skip(ftype)
24176 
      else:
24177 
        iprot.skip(ftype)
24178 
      iprot.readFieldEnd()
24179 
    iprot.readStructEnd()
24180 
 
24181 
  def write(self, oprot):
24182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24184 
      return
24185 
    oprot.writeStructBegin('updateCODAgent_args')
24186 
    if self.agent is not None:
24187 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24188 
      oprot.writeString(self.agent)
24189 
      oprot.writeFieldEnd()
24190 
    if self.orderId is not None:
24191 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24192 
      oprot.writeI64(self.orderId)
24193 
      oprot.writeFieldEnd()
24194 
    oprot.writeFieldStop()
24195 
    oprot.writeStructEnd()
24196 
 
24197 
  def validate(self):
24198 
    return
24199 
 
24200 
 
24201 
  def __repr__(self):
24202 
    L = ['%s=%r' % (key, value)
24203 
      for key, value in self.__dict__.iteritems()]
24204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24205 
 
24206 
  def __eq__(self, other):
24207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24208 
 
24209 
  def __ne__(self, other):
24210 
    return not (self == other)
24211 
 
24212 
class updateCODAgent_result:
24213 
  """
24214 
  Attributes:
24215 
   - ex
24216 
  """
24217 
 
24218 
  thrift_spec = (
24219 
    None, # 0
24220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24221 
  )
24222 
 
24223 
  def __init__(self, ex=None,):
24224 
    self.ex = ex
24225 
 
24226 
  def read(self, iprot):
24227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24229 
      return
24230 
    iprot.readStructBegin()
24231 
    while True:
24232 
      (fname, ftype, fid) = iprot.readFieldBegin()
24233 
      if ftype == TType.STOP:
24234 
        break
24235 
      if fid == 1:
24236 
        if ftype == TType.STRUCT:
24237 
          self.ex = TransactionServiceException()
24238 
          self.ex.read(iprot)
24239 
        else:
24240 
          iprot.skip(ftype)
24241 
      else:
24242 
        iprot.skip(ftype)
24243 
      iprot.readFieldEnd()
24244 
    iprot.readStructEnd()
24245 
 
24246 
  def write(self, oprot):
24247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24249 
      return
24250 
    oprot.writeStructBegin('updateCODAgent_result')
24251 
    if self.ex is not None:
24252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24253 
      self.ex.write(oprot)
24254 
      oprot.writeFieldEnd()
24255 
    oprot.writeFieldStop()
24256 
    oprot.writeStructEnd()
24257 
 
24258 
  def validate(self):
24259 
    return
24260 
 
24261 
 
24262 
  def __repr__(self):
24263 
    L = ['%s=%r' % (key, value)
24264 
      for key, value in self.__dict__.iteritems()]
24265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24266 
 
24267 
  def __eq__(self, other):
24268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24269 
 
24270 
  def __ne__(self, other):
24271 
    return not (self == other)
24272 
 
5099 varun.gupt 24273 
class updateOrderAsPaidToVendor_args:
24274 
  """
24275 
  Attributes:
24276 
   - orderId
24277 
  """
24278 
 
24279 
  thrift_spec = (
24280 
    None, # 0
24281 
    (1, TType.I64, 'orderId', None, None, ), # 1
24282 
  )
24283 
 
24284 
  def __init__(self, orderId=None,):
24285 
    self.orderId = orderId
24286 
 
24287 
  def read(self, iprot):
24288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24290 
      return
24291 
    iprot.readStructBegin()
24292 
    while True:
24293 
      (fname, ftype, fid) = iprot.readFieldBegin()
24294 
      if ftype == TType.STOP:
24295 
        break
24296 
      if fid == 1:
24297 
        if ftype == TType.I64:
24298 
          self.orderId = iprot.readI64();
24299 
        else:
24300 
          iprot.skip(ftype)
24301 
      else:
24302 
        iprot.skip(ftype)
24303 
      iprot.readFieldEnd()
24304 
    iprot.readStructEnd()
24305 
 
24306 
  def write(self, oprot):
24307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24309 
      return
24310 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24311 
    if self.orderId is not None:
24312 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24313 
      oprot.writeI64(self.orderId)
24314 
      oprot.writeFieldEnd()
24315 
    oprot.writeFieldStop()
24316 
    oprot.writeStructEnd()
24317 
 
24318 
  def validate(self):
24319 
    return
24320 
 
24321 
 
24322 
  def __repr__(self):
24323 
    L = ['%s=%r' % (key, value)
24324 
      for key, value in self.__dict__.iteritems()]
24325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24326 
 
24327 
  def __eq__(self, other):
24328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24329 
 
24330 
  def __ne__(self, other):
24331 
    return not (self == other)
24332 
 
24333 
class updateOrderAsPaidToVendor_result:
24334 
  """
24335 
  Attributes:
24336 
   - ex
24337 
  """
24338 
 
24339 
  thrift_spec = (
24340 
    None, # 0
24341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24342 
  )
24343 
 
24344 
  def __init__(self, ex=None,):
24345 
    self.ex = ex
24346 
 
24347 
  def read(self, iprot):
24348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24350 
      return
24351 
    iprot.readStructBegin()
24352 
    while True:
24353 
      (fname, ftype, fid) = iprot.readFieldBegin()
24354 
      if ftype == TType.STOP:
24355 
        break
24356 
      if fid == 1:
24357 
        if ftype == TType.STRUCT:
24358 
          self.ex = TransactionServiceException()
24359 
          self.ex.read(iprot)
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      else:
24363 
        iprot.skip(ftype)
24364 
      iprot.readFieldEnd()
24365 
    iprot.readStructEnd()
24366 
 
24367 
  def write(self, oprot):
24368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24370 
      return
24371 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24372 
    if self.ex is not None:
24373 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24374 
      self.ex.write(oprot)
24375 
      oprot.writeFieldEnd()
24376 
    oprot.writeFieldStop()
24377 
    oprot.writeStructEnd()
24378 
 
24379 
  def validate(self):
24380 
    return
24381 
 
24382 
 
24383 
  def __repr__(self):
24384 
    L = ['%s=%r' % (key, value)
24385 
      for key, value in self.__dict__.iteritems()]
24386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24387 
 
24388 
  def __eq__(self, other):
24389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24390 
 
24391 
  def __ne__(self, other):
24392 
    return not (self == other)
5208 varun.gupt 24393 
 
5386 phani.kuma 24394 
class updateOrderOnlyAsPaidToVendor_args:
24395 
  """
24396 
  Attributes:
24397 
   - orderId
24398 
  """
24399 
 
24400 
  thrift_spec = (
24401 
    None, # 0
24402 
    (1, TType.I64, 'orderId', None, None, ), # 1
24403 
  )
24404 
 
24405 
  def __init__(self, orderId=None,):
24406 
    self.orderId = orderId
24407 
 
24408 
  def read(self, iprot):
24409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24411 
      return
24412 
    iprot.readStructBegin()
24413 
    while True:
24414 
      (fname, ftype, fid) = iprot.readFieldBegin()
24415 
      if ftype == TType.STOP:
24416 
        break
24417 
      if fid == 1:
24418 
        if ftype == TType.I64:
24419 
          self.orderId = iprot.readI64();
24420 
        else:
24421 
          iprot.skip(ftype)
24422 
      else:
24423 
        iprot.skip(ftype)
24424 
      iprot.readFieldEnd()
24425 
    iprot.readStructEnd()
24426 
 
24427 
  def write(self, oprot):
24428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24430 
      return
24431 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24432 
    if self.orderId is not None:
24433 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24434 
      oprot.writeI64(self.orderId)
24435 
      oprot.writeFieldEnd()
24436 
    oprot.writeFieldStop()
24437 
    oprot.writeStructEnd()
24438 
 
24439 
  def validate(self):
24440 
    return
24441 
 
24442 
 
24443 
  def __repr__(self):
24444 
    L = ['%s=%r' % (key, value)
24445 
      for key, value in self.__dict__.iteritems()]
24446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24447 
 
24448 
  def __eq__(self, other):
24449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24450 
 
24451 
  def __ne__(self, other):
24452 
    return not (self == other)
24453 
 
24454 
class updateOrderOnlyAsPaidToVendor_result:
24455 
  """
24456 
  Attributes:
24457 
   - ex
24458 
  """
24459 
 
24460 
  thrift_spec = (
24461 
    None, # 0
24462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24463 
  )
24464 
 
24465 
  def __init__(self, ex=None,):
24466 
    self.ex = ex
24467 
 
24468 
  def read(self, iprot):
24469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24471 
      return
24472 
    iprot.readStructBegin()
24473 
    while True:
24474 
      (fname, ftype, fid) = iprot.readFieldBegin()
24475 
      if ftype == TType.STOP:
24476 
        break
24477 
      if fid == 1:
24478 
        if ftype == TType.STRUCT:
24479 
          self.ex = TransactionServiceException()
24480 
          self.ex.read(iprot)
24481 
        else:
24482 
          iprot.skip(ftype)
24483 
      else:
24484 
        iprot.skip(ftype)
24485 
      iprot.readFieldEnd()
24486 
    iprot.readStructEnd()
24487 
 
24488 
  def write(self, oprot):
24489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24491 
      return
24492 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24493 
    if self.ex is not None:
24494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24495 
      self.ex.write(oprot)
24496 
      oprot.writeFieldEnd()
24497 
    oprot.writeFieldStop()
24498 
    oprot.writeStructEnd()
24499 
 
24500 
  def validate(self):
24501 
    return
24502 
 
24503 
 
24504 
  def __repr__(self):
24505 
    L = ['%s=%r' % (key, value)
24506 
      for key, value in self.__dict__.iteritems()]
24507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24508 
 
24509 
  def __eq__(self, other):
24510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24511 
 
24512 
  def __ne__(self, other):
24513 
    return not (self == other)
24514 
 
5208 varun.gupt 24515 
class getRefundedOrdersMarkedPaid_args:
24516 
 
24517 
  thrift_spec = (
24518 
  )
24519 
 
24520 
  def read(self, iprot):
24521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24523 
      return
24524 
    iprot.readStructBegin()
24525 
    while True:
24526 
      (fname, ftype, fid) = iprot.readFieldBegin()
24527 
      if ftype == TType.STOP:
24528 
        break
24529 
      else:
24530 
        iprot.skip(ftype)
24531 
      iprot.readFieldEnd()
24532 
    iprot.readStructEnd()
24533 
 
24534 
  def write(self, oprot):
24535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24537 
      return
24538 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24539 
    oprot.writeFieldStop()
24540 
    oprot.writeStructEnd()
24541 
 
24542 
  def validate(self):
24543 
    return
24544 
 
24545 
 
24546 
  def __repr__(self):
24547 
    L = ['%s=%r' % (key, value)
24548 
      for key, value in self.__dict__.iteritems()]
24549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24550 
 
24551 
  def __eq__(self, other):
24552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24553 
 
24554 
  def __ne__(self, other):
24555 
    return not (self == other)
24556 
 
24557 
class getRefundedOrdersMarkedPaid_result:
24558 
  """
24559 
  Attributes:
24560 
   - success
24561 
   - ex
24562 
  """
24563 
 
24564 
  thrift_spec = (
24565 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24567 
  )
24568 
 
24569 
  def __init__(self, success=None, ex=None,):
24570 
    self.success = success
24571 
    self.ex = ex
24572 
 
24573 
  def read(self, iprot):
24574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24576 
      return
24577 
    iprot.readStructBegin()
24578 
    while True:
24579 
      (fname, ftype, fid) = iprot.readFieldBegin()
24580 
      if ftype == TType.STOP:
24581 
        break
24582 
      if fid == 0:
24583 
        if ftype == TType.LIST:
24584 
          self.success = []
6031 rajveer 24585 
          (_etype567, _size564) = iprot.readListBegin()
24586 
          for _i568 in xrange(_size564):
24587 
            _elem569 = Order()
24588 
            _elem569.read(iprot)
24589 
            self.success.append(_elem569)
5208 varun.gupt 24590 
          iprot.readListEnd()
24591 
        else:
24592 
          iprot.skip(ftype)
24593 
      elif fid == 1:
24594 
        if ftype == TType.STRUCT:
24595 
          self.ex = TransactionServiceException()
24596 
          self.ex.read(iprot)
24597 
        else:
24598 
          iprot.skip(ftype)
24599 
      else:
24600 
        iprot.skip(ftype)
24601 
      iprot.readFieldEnd()
24602 
    iprot.readStructEnd()
24603 
 
24604 
  def write(self, oprot):
24605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24607 
      return
24608 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24609 
    if self.success is not None:
24610 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24611 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24612 
      for iter570 in self.success:
24613 
        iter570.write(oprot)
5208 varun.gupt 24614 
      oprot.writeListEnd()
24615 
      oprot.writeFieldEnd()
24616 
    if self.ex is not None:
24617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24618 
      self.ex.write(oprot)
24619 
      oprot.writeFieldEnd()
24620 
    oprot.writeFieldStop()
24621 
    oprot.writeStructEnd()
24622 
 
24623 
  def validate(self):
24624 
    return
24625 
 
24626 
 
24627 
  def __repr__(self):
24628 
    L = ['%s=%r' % (key, value)
24629 
      for key, value in self.__dict__.iteritems()]
24630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24631 
 
24632 
  def __eq__(self, other):
24633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24634 
 
24635 
  def __ne__(self, other):
24636 
    return not (self == other)
5447 anupam.sin 24637 
 
24638 
class getAllVerificationAgents_args:
24639 
  """
24640 
  Attributes:
24641 
   - minOrderId
24642 
   - maxOrderId
24643 
  """
24644 
 
24645 
  thrift_spec = (
24646 
    None, # 0
24647 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24648 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24649 
  )
24650 
 
24651 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24652 
    self.minOrderId = minOrderId
24653 
    self.maxOrderId = maxOrderId
24654 
 
24655 
  def read(self, iprot):
24656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24658 
      return
24659 
    iprot.readStructBegin()
24660 
    while True:
24661 
      (fname, ftype, fid) = iprot.readFieldBegin()
24662 
      if ftype == TType.STOP:
24663 
        break
24664 
      if fid == 1:
24665 
        if ftype == TType.I64:
24666 
          self.minOrderId = iprot.readI64();
24667 
        else:
24668 
          iprot.skip(ftype)
24669 
      elif fid == 2:
24670 
        if ftype == TType.I64:
24671 
          self.maxOrderId = iprot.readI64();
24672 
        else:
24673 
          iprot.skip(ftype)
24674 
      else:
24675 
        iprot.skip(ftype)
24676 
      iprot.readFieldEnd()
24677 
    iprot.readStructEnd()
24678 
 
24679 
  def write(self, oprot):
24680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24682 
      return
24683 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24684 
    if self.minOrderId is not None:
24685 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24686 
      oprot.writeI64(self.minOrderId)
24687 
      oprot.writeFieldEnd()
24688 
    if self.maxOrderId is not None:
24689 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24690 
      oprot.writeI64(self.maxOrderId)
24691 
      oprot.writeFieldEnd()
24692 
    oprot.writeFieldStop()
24693 
    oprot.writeStructEnd()
24694 
 
24695 
  def validate(self):
24696 
    return
24697 
 
24698 
 
24699 
  def __repr__(self):
24700 
    L = ['%s=%r' % (key, value)
24701 
      for key, value in self.__dict__.iteritems()]
24702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24703 
 
24704 
  def __eq__(self, other):
24705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24706 
 
24707 
  def __ne__(self, other):
24708 
    return not (self == other)
24709 
 
24710 
class getAllVerificationAgents_result:
24711 
  """
24712 
  Attributes:
24713 
   - success
24714 
  """
24715 
 
24716 
  thrift_spec = (
24717 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24718 
  )
24719 
 
24720 
  def __init__(self, success=None,):
24721 
    self.success = success
24722 
 
24723 
  def read(self, iprot):
24724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24726 
      return
24727 
    iprot.readStructBegin()
24728 
    while True:
24729 
      (fname, ftype, fid) = iprot.readFieldBegin()
24730 
      if ftype == TType.STOP:
24731 
        break
24732 
      if fid == 0:
24733 
        if ftype == TType.LIST:
24734 
          self.success = []
6031 rajveer 24735 
          (_etype574, _size571) = iprot.readListBegin()
24736 
          for _i575 in xrange(_size571):
24737 
            _elem576 = CODVerificationAgent()
24738 
            _elem576.read(iprot)
24739 
            self.success.append(_elem576)
5447 anupam.sin 24740 
          iprot.readListEnd()
24741 
        else:
24742 
          iprot.skip(ftype)
24743 
      else:
24744 
        iprot.skip(ftype)
24745 
      iprot.readFieldEnd()
24746 
    iprot.readStructEnd()
24747 
 
24748 
  def write(self, oprot):
24749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24751 
      return
24752 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24753 
    if self.success is not None:
24754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24755 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24756 
      for iter577 in self.success:
24757 
        iter577.write(oprot)
5447 anupam.sin 24758 
      oprot.writeListEnd()
24759 
      oprot.writeFieldEnd()
24760 
    oprot.writeFieldStop()
24761 
    oprot.writeStructEnd()
24762 
 
24763 
  def validate(self):
24764 
    return
24765 
 
24766 
 
24767 
  def __repr__(self):
24768 
    L = ['%s=%r' % (key, value)
24769 
      for key, value in self.__dict__.iteritems()]
24770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24771 
 
24772 
  def __eq__(self, other):
24773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24774 
 
24775 
  def __ne__(self, other):
24776 
    return not (self == other)
5527 anupam.sin 24777 
 
24778 
class getAllAttributesForOrderId_args:
24779 
  """
24780 
  Attributes:
24781 
   - orderId
24782 
  """
24783 
 
24784 
  thrift_spec = (
24785 
    None, # 0
24786 
    (1, TType.I64, 'orderId', None, None, ), # 1
24787 
  )
24788 
 
24789 
  def __init__(self, orderId=None,):
24790 
    self.orderId = orderId
24791 
 
24792 
  def read(self, iprot):
24793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24795 
      return
24796 
    iprot.readStructBegin()
24797 
    while True:
24798 
      (fname, ftype, fid) = iprot.readFieldBegin()
24799 
      if ftype == TType.STOP:
24800 
        break
24801 
      if fid == 1:
24802 
        if ftype == TType.I64:
24803 
          self.orderId = iprot.readI64();
24804 
        else:
24805 
          iprot.skip(ftype)
24806 
      else:
24807 
        iprot.skip(ftype)
24808 
      iprot.readFieldEnd()
24809 
    iprot.readStructEnd()
24810 
 
24811 
  def write(self, oprot):
24812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24814 
      return
24815 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24816 
    if self.orderId is not None:
24817 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24818 
      oprot.writeI64(self.orderId)
24819 
      oprot.writeFieldEnd()
24820 
    oprot.writeFieldStop()
24821 
    oprot.writeStructEnd()
24822 
 
24823 
  def validate(self):
24824 
    return
24825 
 
24826 
 
24827 
  def __repr__(self):
24828 
    L = ['%s=%r' % (key, value)
24829 
      for key, value in self.__dict__.iteritems()]
24830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24831 
 
24832 
  def __eq__(self, other):
24833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24834 
 
24835 
  def __ne__(self, other):
24836 
    return not (self == other)
24837 
 
24838 
class getAllAttributesForOrderId_result:
24839 
  """
24840 
  Attributes:
24841 
   - success
24842 
  """
24843 
 
24844 
  thrift_spec = (
24845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24846 
  )
24847 
 
24848 
  def __init__(self, success=None,):
24849 
    self.success = success
24850 
 
24851 
  def read(self, iprot):
24852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24854 
      return
24855 
    iprot.readStructBegin()
24856 
    while True:
24857 
      (fname, ftype, fid) = iprot.readFieldBegin()
24858 
      if ftype == TType.STOP:
24859 
        break
24860 
      if fid == 0:
24861 
        if ftype == TType.LIST:
24862 
          self.success = []
6031 rajveer 24863 
          (_etype581, _size578) = iprot.readListBegin()
24864 
          for _i582 in xrange(_size578):
24865 
            _elem583 = Attribute()
24866 
            _elem583.read(iprot)
24867 
            self.success.append(_elem583)
5527 anupam.sin 24868 
          iprot.readListEnd()
24869 
        else:
24870 
          iprot.skip(ftype)
24871 
      else:
24872 
        iprot.skip(ftype)
24873 
      iprot.readFieldEnd()
24874 
    iprot.readStructEnd()
24875 
 
24876 
  def write(self, oprot):
24877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24879 
      return
24880 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24881 
    if self.success is not None:
24882 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24883 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24884 
      for iter584 in self.success:
24885 
        iter584.write(oprot)
5527 anupam.sin 24886 
      oprot.writeListEnd()
24887 
      oprot.writeFieldEnd()
24888 
    oprot.writeFieldStop()
24889 
    oprot.writeStructEnd()
24890 
 
24891 
  def validate(self):
24892 
    return
24893 
 
24894 
 
24895 
  def __repr__(self):
24896 
    L = ['%s=%r' % (key, value)
24897 
      for key, value in self.__dict__.iteritems()]
24898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24899 
 
24900 
  def __eq__(self, other):
24901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24902 
 
24903 
  def __ne__(self, other):
24904 
    return not (self == other)
24905 
 
5676 rajveer 24906 
class setOrderAttributes_args:
24907 
  """
24908 
  Attributes:
24909 
   - orderId
24910 
   - attributes
24911 
  """
24912 
 
24913 
  thrift_spec = None
24914 
  def __init__(self, orderId=None, attributes=None,):
24915 
    self.orderId = orderId
24916 
    self.attributes = attributes
24917 
 
24918 
  def read(self, iprot):
24919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24921 
      return
24922 
    iprot.readStructBegin()
24923 
    while True:
24924 
      (fname, ftype, fid) = iprot.readFieldBegin()
24925 
      if ftype == TType.STOP:
24926 
        break
24927 
      if fid == 1:
24928 
        if ftype == TType.I64:
24929 
          self.orderId = iprot.readI64();
24930 
        else:
24931 
          iprot.skip(ftype)
24932 
      elif fid == -1:
24933 
        if ftype == TType.LIST:
24934 
          self.attributes = []
6031 rajveer 24935 
          (_etype588, _size585) = iprot.readListBegin()
24936 
          for _i589 in xrange(_size585):
24937 
            _elem590 = Attribute()
24938 
            _elem590.read(iprot)
24939 
            self.attributes.append(_elem590)
5676 rajveer 24940 
          iprot.readListEnd()
24941 
        else:
24942 
          iprot.skip(ftype)
24943 
      else:
24944 
        iprot.skip(ftype)
24945 
      iprot.readFieldEnd()
24946 
    iprot.readStructEnd()
24947 
 
24948 
  def write(self, oprot):
24949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24951 
      return
24952 
    oprot.writeStructBegin('setOrderAttributes_args')
24953 
    if self.attributes is not None:
24954 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24955 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 24956 
      for iter591 in self.attributes:
24957 
        iter591.write(oprot)
5676 rajveer 24958 
      oprot.writeListEnd()
24959 
      oprot.writeFieldEnd()
24960 
    if self.orderId is not None:
24961 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24962 
      oprot.writeI64(self.orderId)
24963 
      oprot.writeFieldEnd()
24964 
    oprot.writeFieldStop()
24965 
    oprot.writeStructEnd()
24966 
 
24967 
  def validate(self):
24968 
    return
24969 
 
24970 
 
24971 
  def __repr__(self):
24972 
    L = ['%s=%r' % (key, value)
24973 
      for key, value in self.__dict__.iteritems()]
24974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24975 
 
24976 
  def __eq__(self, other):
24977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24978 
 
24979 
  def __ne__(self, other):
24980 
    return not (self == other)
24981 
 
24982 
class setOrderAttributes_result:
24983 
 
24984 
  thrift_spec = (
24985 
  )
24986 
 
24987 
  def read(self, iprot):
24988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24990 
      return
24991 
    iprot.readStructBegin()
24992 
    while True:
24993 
      (fname, ftype, fid) = iprot.readFieldBegin()
24994 
      if ftype == TType.STOP:
24995 
        break
24996 
      else:
24997 
        iprot.skip(ftype)
24998 
      iprot.readFieldEnd()
24999 
    iprot.readStructEnd()
25000 
 
25001 
  def write(self, oprot):
25002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25004 
      return
25005 
    oprot.writeStructBegin('setOrderAttributes_result')
25006 
    oprot.writeFieldStop()
25007 
    oprot.writeStructEnd()
25008 
 
25009 
  def validate(self):
25010 
    return
25011 
 
25012 
 
25013 
  def __repr__(self):
25014 
    L = ['%s=%r' % (key, value)
25015 
      for key, value in self.__dict__.iteritems()]
25016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25017 
 
25018 
  def __eq__(self, other):
25019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25020 
 
25021 
  def __ne__(self, other):
25022 
    return not (self == other)
25023 
 
5527 anupam.sin 25024 
class setOrderAttributeForTransaction_args:
25025 
  """
25026 
  Attributes:
25027 
   - transactionId
25028 
   - attribute
25029 
  """
25030 
 
25031 
  thrift_spec = None
25032 
  def __init__(self, transactionId=None, attribute=None,):
25033 
    self.transactionId = transactionId
25034 
    self.attribute = attribute
25035 
 
25036 
  def read(self, iprot):
25037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25039 
      return
25040 
    iprot.readStructBegin()
25041 
    while True:
25042 
      (fname, ftype, fid) = iprot.readFieldBegin()
25043 
      if ftype == TType.STOP:
25044 
        break
25045 
      if fid == 1:
25046 
        if ftype == TType.I64:
25047 
          self.transactionId = iprot.readI64();
25048 
        else:
25049 
          iprot.skip(ftype)
25050 
      elif fid == -1:
25051 
        if ftype == TType.STRUCT:
25052 
          self.attribute = Attribute()
25053 
          self.attribute.read(iprot)
25054 
        else:
25055 
          iprot.skip(ftype)
25056 
      else:
25057 
        iprot.skip(ftype)
25058 
      iprot.readFieldEnd()
25059 
    iprot.readStructEnd()
25060 
 
25061 
  def write(self, oprot):
25062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25064 
      return
25065 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25066 
    if self.attribute is not None:
25067 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25068 
      self.attribute.write(oprot)
25069 
      oprot.writeFieldEnd()
25070 
    if self.transactionId is not None:
25071 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25072 
      oprot.writeI64(self.transactionId)
25073 
      oprot.writeFieldEnd()
25074 
    oprot.writeFieldStop()
25075 
    oprot.writeStructEnd()
25076 
 
25077 
  def validate(self):
25078 
    return
25079 
 
25080 
 
25081 
  def __repr__(self):
25082 
    L = ['%s=%r' % (key, value)
25083 
      for key, value in self.__dict__.iteritems()]
25084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25085 
 
25086 
  def __eq__(self, other):
25087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25088 
 
25089 
  def __ne__(self, other):
25090 
    return not (self == other)
25091 
 
25092 
class setOrderAttributeForTransaction_result:
25093 
 
25094 
  thrift_spec = (
25095 
  )
25096 
 
25097 
  def read(self, iprot):
25098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25100 
      return
25101 
    iprot.readStructBegin()
25102 
    while True:
25103 
      (fname, ftype, fid) = iprot.readFieldBegin()
25104 
      if ftype == TType.STOP:
25105 
        break
25106 
      else:
25107 
        iprot.skip(ftype)
25108 
      iprot.readFieldEnd()
25109 
    iprot.readStructEnd()
25110 
 
25111 
  def write(self, oprot):
25112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25114 
      return
25115 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25116 
    oprot.writeFieldStop()
25117 
    oprot.writeStructEnd()
25118 
 
25119 
  def validate(self):
25120 
    return
25121 
 
25122 
 
25123 
  def __repr__(self):
25124 
    L = ['%s=%r' % (key, value)
25125 
      for key, value in self.__dict__.iteritems()]
25126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25127 
 
25128 
  def __eq__(self, other):
25129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25130 
 
25131 
  def __ne__(self, other):
25132 
    return not (self == other)
5553 rajveer 25133 
 
25134 
class getReceivePendingOrders_args:
25135 
  """
25136 
  Attributes:
25137 
   - storeId
25138 
  """
25139 
 
25140 
  thrift_spec = (
25141 
    None, # 0
25142 
    (1, TType.I64, 'storeId', None, None, ), # 1
25143 
  )
25144 
 
25145 
  def __init__(self, storeId=None,):
25146 
    self.storeId = storeId
25147 
 
25148 
  def read(self, iprot):
25149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25151 
      return
25152 
    iprot.readStructBegin()
25153 
    while True:
25154 
      (fname, ftype, fid) = iprot.readFieldBegin()
25155 
      if ftype == TType.STOP:
25156 
        break
25157 
      if fid == 1:
25158 
        if ftype == TType.I64:
25159 
          self.storeId = iprot.readI64();
25160 
        else:
25161 
          iprot.skip(ftype)
25162 
      else:
25163 
        iprot.skip(ftype)
25164 
      iprot.readFieldEnd()
25165 
    iprot.readStructEnd()
25166 
 
25167 
  def write(self, oprot):
25168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25170 
      return
25171 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25172 
    if self.storeId is not None:
25173 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25174 
      oprot.writeI64(self.storeId)
25175 
      oprot.writeFieldEnd()
25176 
    oprot.writeFieldStop()
25177 
    oprot.writeStructEnd()
25178 
 
25179 
  def validate(self):
25180 
    return
25181 
 
25182 
 
25183 
  def __repr__(self):
25184 
    L = ['%s=%r' % (key, value)
25185 
      for key, value in self.__dict__.iteritems()]
25186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25187 
 
25188 
  def __eq__(self, other):
25189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25190 
 
25191 
  def __ne__(self, other):
25192 
    return not (self == other)
25193 
 
25194 
class getReceivePendingOrders_result:
25195 
  """
25196 
  Attributes:
25197 
   - success
25198 
  """
25199 
 
25200 
  thrift_spec = (
25201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25202 
  )
25203 
 
25204 
  def __init__(self, success=None,):
25205 
    self.success = success
25206 
 
25207 
  def read(self, iprot):
25208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25210 
      return
25211 
    iprot.readStructBegin()
25212 
    while True:
25213 
      (fname, ftype, fid) = iprot.readFieldBegin()
25214 
      if ftype == TType.STOP:
25215 
        break
25216 
      if fid == 0:
25217 
        if ftype == TType.LIST:
25218 
          self.success = []
6031 rajveer 25219 
          (_etype595, _size592) = iprot.readListBegin()
25220 
          for _i596 in xrange(_size592):
25221 
            _elem597 = Order()
25222 
            _elem597.read(iprot)
25223 
            self.success.append(_elem597)
5553 rajveer 25224 
          iprot.readListEnd()
25225 
        else:
25226 
          iprot.skip(ftype)
25227 
      else:
25228 
        iprot.skip(ftype)
25229 
      iprot.readFieldEnd()
25230 
    iprot.readStructEnd()
25231 
 
25232 
  def write(self, oprot):
25233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25235 
      return
25236 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25237 
    if self.success is not None:
25238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25240 
      for iter598 in self.success:
25241 
        iter598.write(oprot)
5553 rajveer 25242 
      oprot.writeListEnd()
25243 
      oprot.writeFieldEnd()
25244 
    oprot.writeFieldStop()
25245 
    oprot.writeStructEnd()
25246 
 
25247 
  def validate(self):
25248 
    return
25249 
 
25250 
 
25251 
  def __repr__(self):
25252 
    L = ['%s=%r' % (key, value)
25253 
      for key, value in self.__dict__.iteritems()]
25254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25255 
 
25256 
  def __eq__(self, other):
25257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25258 
 
25259 
  def __ne__(self, other):
25260 
    return not (self == other)
25261 
 
25262 
class getReceivedAtStoreOrders_args:
25263 
  """
25264 
  Attributes:
25265 
   - storeId
25266 
  """
25267 
 
25268 
  thrift_spec = (
25269 
    None, # 0
25270 
    (1, TType.I64, 'storeId', None, None, ), # 1
25271 
  )
25272 
 
25273 
  def __init__(self, storeId=None,):
25274 
    self.storeId = storeId
25275 
 
25276 
  def read(self, iprot):
25277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25279 
      return
25280 
    iprot.readStructBegin()
25281 
    while True:
25282 
      (fname, ftype, fid) = iprot.readFieldBegin()
25283 
      if ftype == TType.STOP:
25284 
        break
25285 
      if fid == 1:
25286 
        if ftype == TType.I64:
25287 
          self.storeId = iprot.readI64();
25288 
        else:
25289 
          iprot.skip(ftype)
25290 
      else:
25291 
        iprot.skip(ftype)
25292 
      iprot.readFieldEnd()
25293 
    iprot.readStructEnd()
25294 
 
25295 
  def write(self, oprot):
25296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25298 
      return
25299 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25300 
    if self.storeId is not None:
25301 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25302 
      oprot.writeI64(self.storeId)
25303 
      oprot.writeFieldEnd()
25304 
    oprot.writeFieldStop()
25305 
    oprot.writeStructEnd()
25306 
 
25307 
  def validate(self):
25308 
    return
25309 
 
25310 
 
25311 
  def __repr__(self):
25312 
    L = ['%s=%r' % (key, value)
25313 
      for key, value in self.__dict__.iteritems()]
25314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25315 
 
25316 
  def __eq__(self, other):
25317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25318 
 
25319 
  def __ne__(self, other):
25320 
    return not (self == other)
25321 
 
25322 
class getReceivedAtStoreOrders_result:
25323 
  """
25324 
  Attributes:
25325 
   - success
25326 
  """
25327 
 
25328 
  thrift_spec = (
25329 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25330 
  )
25331 
 
25332 
  def __init__(self, success=None,):
25333 
    self.success = success
25334 
 
25335 
  def read(self, iprot):
25336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25338 
      return
25339 
    iprot.readStructBegin()
25340 
    while True:
25341 
      (fname, ftype, fid) = iprot.readFieldBegin()
25342 
      if ftype == TType.STOP:
25343 
        break
25344 
      if fid == 0:
25345 
        if ftype == TType.LIST:
25346 
          self.success = []
6031 rajveer 25347 
          (_etype602, _size599) = iprot.readListBegin()
25348 
          for _i603 in xrange(_size599):
25349 
            _elem604 = Order()
25350 
            _elem604.read(iprot)
25351 
            self.success.append(_elem604)
5553 rajveer 25352 
          iprot.readListEnd()
25353 
        else:
25354 
          iprot.skip(ftype)
25355 
      else:
25356 
        iprot.skip(ftype)
25357 
      iprot.readFieldEnd()
25358 
    iprot.readStructEnd()
25359 
 
25360 
  def write(self, oprot):
25361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25363 
      return
25364 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25365 
    if self.success is not None:
25366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25368 
      for iter605 in self.success:
25369 
        iter605.write(oprot)
5553 rajveer 25370 
      oprot.writeListEnd()
25371 
      oprot.writeFieldEnd()
25372 
    oprot.writeFieldStop()
25373 
    oprot.writeStructEnd()
25374 
 
25375 
  def validate(self):
25376 
    return
25377 
 
25378 
 
25379 
  def __repr__(self):
25380 
    L = ['%s=%r' % (key, value)
25381 
      for key, value in self.__dict__.iteritems()]
25382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25383 
 
25384 
  def __eq__(self, other):
25385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25386 
 
25387 
  def __ne__(self, other):
25388 
    return not (self == other)
5593 mandeep.dh 25389 
 
5713 rajveer 25390 
class getOrdersCollectionAtStore_args:
25391 
  """
25392 
  Attributes:
25393 
   - storeId
25394 
   - fromDate
25395 
   - toDate
25396 
   - onlyCod
25397 
  """
25398 
 
25399 
  thrift_spec = (
25400 
    None, # 0
25401 
    (1, TType.I64, 'storeId', None, None, ), # 1
25402 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25403 
    (3, TType.I64, 'toDate', None, None, ), # 3
25404 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25405 
  )
25406 
 
25407 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25408 
    self.storeId = storeId
25409 
    self.fromDate = fromDate
25410 
    self.toDate = toDate
25411 
    self.onlyCod = onlyCod
25412 
 
25413 
  def read(self, iprot):
25414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25416 
      return
25417 
    iprot.readStructBegin()
25418 
    while True:
25419 
      (fname, ftype, fid) = iprot.readFieldBegin()
25420 
      if ftype == TType.STOP:
25421 
        break
25422 
      if fid == 1:
25423 
        if ftype == TType.I64:
25424 
          self.storeId = iprot.readI64();
25425 
        else:
25426 
          iprot.skip(ftype)
25427 
      elif fid == 2:
25428 
        if ftype == TType.I64:
25429 
          self.fromDate = iprot.readI64();
25430 
        else:
25431 
          iprot.skip(ftype)
25432 
      elif fid == 3:
25433 
        if ftype == TType.I64:
25434 
          self.toDate = iprot.readI64();
25435 
        else:
25436 
          iprot.skip(ftype)
25437 
      elif fid == 4:
25438 
        if ftype == TType.BOOL:
25439 
          self.onlyCod = iprot.readBool();
25440 
        else:
25441 
          iprot.skip(ftype)
25442 
      else:
25443 
        iprot.skip(ftype)
25444 
      iprot.readFieldEnd()
25445 
    iprot.readStructEnd()
25446 
 
25447 
  def write(self, oprot):
25448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25450 
      return
25451 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25452 
    if self.storeId is not None:
25453 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25454 
      oprot.writeI64(self.storeId)
25455 
      oprot.writeFieldEnd()
25456 
    if self.fromDate is not None:
25457 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25458 
      oprot.writeI64(self.fromDate)
25459 
      oprot.writeFieldEnd()
25460 
    if self.toDate is not None:
25461 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25462 
      oprot.writeI64(self.toDate)
25463 
      oprot.writeFieldEnd()
25464 
    if self.onlyCod is not None:
25465 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25466 
      oprot.writeBool(self.onlyCod)
25467 
      oprot.writeFieldEnd()
25468 
    oprot.writeFieldStop()
25469 
    oprot.writeStructEnd()
25470 
 
25471 
  def validate(self):
25472 
    return
25473 
 
25474 
 
25475 
  def __repr__(self):
25476 
    L = ['%s=%r' % (key, value)
25477 
      for key, value in self.__dict__.iteritems()]
25478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25479 
 
25480 
  def __eq__(self, other):
25481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25482 
 
25483 
  def __ne__(self, other):
25484 
    return not (self == other)
25485 
 
25486 
class getOrdersCollectionAtStore_result:
25487 
  """
25488 
  Attributes:
25489 
   - success
25490 
  """
25491 
 
25492 
  thrift_spec = (
25493 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25494 
  )
25495 
 
25496 
  def __init__(self, success=None,):
25497 
    self.success = success
25498 
 
25499 
  def read(self, iprot):
25500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25502 
      return
25503 
    iprot.readStructBegin()
25504 
    while True:
25505 
      (fname, ftype, fid) = iprot.readFieldBegin()
25506 
      if ftype == TType.STOP:
25507 
        break
25508 
      if fid == 0:
25509 
        if ftype == TType.LIST:
25510 
          self.success = []
6031 rajveer 25511 
          (_etype609, _size606) = iprot.readListBegin()
25512 
          for _i610 in xrange(_size606):
25513 
            _elem611 = Order()
25514 
            _elem611.read(iprot)
25515 
            self.success.append(_elem611)
5713 rajveer 25516 
          iprot.readListEnd()
25517 
        else:
25518 
          iprot.skip(ftype)
25519 
      else:
25520 
        iprot.skip(ftype)
25521 
      iprot.readFieldEnd()
25522 
    iprot.readStructEnd()
25523 
 
25524 
  def write(self, oprot):
25525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25527 
      return
25528 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25529 
    if self.success is not None:
25530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25532 
      for iter612 in self.success:
25533 
        iter612.write(oprot)
5713 rajveer 25534 
      oprot.writeListEnd()
25535 
      oprot.writeFieldEnd()
25536 
    oprot.writeFieldStop()
25537 
    oprot.writeStructEnd()
25538 
 
25539 
  def validate(self):
25540 
    return
25541 
 
25542 
 
25543 
  def __repr__(self):
25544 
    L = ['%s=%r' % (key, value)
25545 
      for key, value in self.__dict__.iteritems()]
25546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25547 
 
25548 
  def __eq__(self, other):
25549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25550 
 
25551 
  def __ne__(self, other):
25552 
    return not (self == other)
25553 
 
5833 rajveer 25554 
class getOrderAttributeValue_args:
25555 
  """
25556 
  Attributes:
25557 
   - orderId
25558 
   - attributeName
25559 
  """
25560 
 
25561 
  thrift_spec = None
25562 
  def __init__(self, orderId=None, attributeName=None,):
25563 
    self.orderId = orderId
25564 
    self.attributeName = attributeName
25565 
 
25566 
  def read(self, iprot):
25567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25569 
      return
25570 
    iprot.readStructBegin()
25571 
    while True:
25572 
      (fname, ftype, fid) = iprot.readFieldBegin()
25573 
      if ftype == TType.STOP:
25574 
        break
25575 
      if fid == 1:
25576 
        if ftype == TType.I64:
25577 
          self.orderId = iprot.readI64();
25578 
        else:
25579 
          iprot.skip(ftype)
25580 
      elif fid == -1:
25581 
        if ftype == TType.STRING:
25582 
          self.attributeName = iprot.readString();
25583 
        else:
25584 
          iprot.skip(ftype)
25585 
      else:
25586 
        iprot.skip(ftype)
25587 
      iprot.readFieldEnd()
25588 
    iprot.readStructEnd()
25589 
 
25590 
  def write(self, oprot):
25591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25593 
      return
25594 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25595 
    if self.attributeName is not None:
25596 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25597 
      oprot.writeString(self.attributeName)
25598 
      oprot.writeFieldEnd()
25599 
    if self.orderId is not None:
25600 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25601 
      oprot.writeI64(self.orderId)
25602 
      oprot.writeFieldEnd()
25603 
    oprot.writeFieldStop()
25604 
    oprot.writeStructEnd()
25605 
 
25606 
  def validate(self):
25607 
    return
25608 
 
25609 
 
25610 
  def __repr__(self):
25611 
    L = ['%s=%r' % (key, value)
25612 
      for key, value in self.__dict__.iteritems()]
25613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25614 
 
25615 
  def __eq__(self, other):
25616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25617 
 
25618 
  def __ne__(self, other):
25619 
    return not (self == other)
25620 
 
25621 
class getOrderAttributeValue_result:
25622 
  """
25623 
  Attributes:
25624 
   - success
25625 
  """
25626 
 
25627 
  thrift_spec = (
25628 
    (0, TType.STRING, 'success', None, None, ), # 0
25629 
  )
25630 
 
25631 
  def __init__(self, success=None,):
25632 
    self.success = success
25633 
 
25634 
  def read(self, iprot):
25635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25637 
      return
25638 
    iprot.readStructBegin()
25639 
    while True:
25640 
      (fname, ftype, fid) = iprot.readFieldBegin()
25641 
      if ftype == TType.STOP:
25642 
        break
25643 
      if fid == 0:
25644 
        if ftype == TType.STRING:
25645 
          self.success = iprot.readString();
25646 
        else:
25647 
          iprot.skip(ftype)
25648 
      else:
25649 
        iprot.skip(ftype)
25650 
      iprot.readFieldEnd()
25651 
    iprot.readStructEnd()
25652 
 
25653 
  def write(self, oprot):
25654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25656 
      return
25657 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25658 
    if self.success is not None:
25659 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25660 
      oprot.writeString(self.success)
25661 
      oprot.writeFieldEnd()
25662 
    oprot.writeFieldStop()
25663 
    oprot.writeStructEnd()
25664 
 
25665 
  def validate(self):
25666 
    return
25667 
 
25668 
 
25669 
  def __repr__(self):
25670 
    L = ['%s=%r' % (key, value)
25671 
      for key, value in self.__dict__.iteritems()]
25672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25673 
 
25674 
  def __eq__(self, other):
25675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25676 
 
25677 
  def __ne__(self, other):
25678 
    return not (self == other)
25679 
 
6019 rajveer 25680 
class changeJacketNumber_args:
25681 
  """
25682 
  Attributes:
25683 
   - orderId
25684 
   - jacketNumber
25685 
  """
25686 
 
25687 
  thrift_spec = (
25688 
    None, # 0
25689 
    (1, TType.I64, 'orderId', None, None, ), # 1
25690 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25691 
  )
25692 
 
25693 
  def __init__(self, orderId=None, jacketNumber=None,):
25694 
    self.orderId = orderId
25695 
    self.jacketNumber = jacketNumber
25696 
 
25697 
  def read(self, iprot):
25698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25700 
      return
25701 
    iprot.readStructBegin()
25702 
    while True:
25703 
      (fname, ftype, fid) = iprot.readFieldBegin()
25704 
      if ftype == TType.STOP:
25705 
        break
25706 
      if fid == 1:
25707 
        if ftype == TType.I64:
25708 
          self.orderId = iprot.readI64();
25709 
        else:
25710 
          iprot.skip(ftype)
25711 
      elif fid == 2:
25712 
        if ftype == TType.I64:
25713 
          self.jacketNumber = iprot.readI64();
25714 
        else:
25715 
          iprot.skip(ftype)
25716 
      else:
25717 
        iprot.skip(ftype)
25718 
      iprot.readFieldEnd()
25719 
    iprot.readStructEnd()
25720 
 
25721 
  def write(self, oprot):
25722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25724 
      return
25725 
    oprot.writeStructBegin('changeJacketNumber_args')
25726 
    if self.orderId is not None:
25727 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25728 
      oprot.writeI64(self.orderId)
25729 
      oprot.writeFieldEnd()
25730 
    if self.jacketNumber is not None:
25731 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25732 
      oprot.writeI64(self.jacketNumber)
25733 
      oprot.writeFieldEnd()
25734 
    oprot.writeFieldStop()
25735 
    oprot.writeStructEnd()
25736 
 
25737 
  def validate(self):
25738 
    return
25739 
 
25740 
 
25741 
  def __repr__(self):
25742 
    L = ['%s=%r' % (key, value)
25743 
      for key, value in self.__dict__.iteritems()]
25744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25745 
 
25746 
  def __eq__(self, other):
25747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25748 
 
25749 
  def __ne__(self, other):
25750 
    return not (self == other)
25751 
 
25752 
class changeJacketNumber_result:
25753 
  """
25754 
  Attributes:
25755 
   - success
25756 
  """
25757 
 
25758 
  thrift_spec = (
25759 
    (0, TType.BOOL, 'success', None, None, ), # 0
25760 
  )
25761 
 
25762 
  def __init__(self, success=None,):
25763 
    self.success = success
25764 
 
25765 
  def read(self, iprot):
25766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25768 
      return
25769 
    iprot.readStructBegin()
25770 
    while True:
25771 
      (fname, ftype, fid) = iprot.readFieldBegin()
25772 
      if ftype == TType.STOP:
25773 
        break
25774 
      if fid == 0:
25775 
        if ftype == TType.BOOL:
25776 
          self.success = iprot.readBool();
25777 
        else:
25778 
          iprot.skip(ftype)
25779 
      else:
25780 
        iprot.skip(ftype)
25781 
      iprot.readFieldEnd()
25782 
    iprot.readStructEnd()
25783 
 
25784 
  def write(self, oprot):
25785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25787 
      return
25788 
    oprot.writeStructBegin('changeJacketNumber_result')
25789 
    if self.success is not None:
25790 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25791 
      oprot.writeBool(self.success)
25792 
      oprot.writeFieldEnd()
25793 
    oprot.writeFieldStop()
25794 
    oprot.writeStructEnd()
25795 
 
25796 
  def validate(self):
25797 
    return
25798 
 
25799 
 
25800 
  def __repr__(self):
25801 
    L = ['%s=%r' % (key, value)
25802 
      for key, value in self.__dict__.iteritems()]
25803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25804 
 
25805 
  def __eq__(self, other):
25806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25807 
 
25808 
  def __ne__(self, other):
25809 
    return not (self == other)
25810 
 
25811 
class markOrderAsRtoInTransit_args:
25812 
  """
25813 
  Attributes:
25814 
   - orderId
25815 
  """
25816 
 
25817 
  thrift_spec = (
25818 
    None, # 0
25819 
    (1, TType.I64, 'orderId', None, None, ), # 1
25820 
  )
25821 
 
25822 
  def __init__(self, orderId=None,):
25823 
    self.orderId = orderId
25824 
 
25825 
  def read(self, iprot):
25826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25828 
      return
25829 
    iprot.readStructBegin()
25830 
    while True:
25831 
      (fname, ftype, fid) = iprot.readFieldBegin()
25832 
      if ftype == TType.STOP:
25833 
        break
25834 
      if fid == 1:
25835 
        if ftype == TType.I64:
25836 
          self.orderId = iprot.readI64();
25837 
        else:
25838 
          iprot.skip(ftype)
25839 
      else:
25840 
        iprot.skip(ftype)
25841 
      iprot.readFieldEnd()
25842 
    iprot.readStructEnd()
25843 
 
25844 
  def write(self, oprot):
25845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25847 
      return
25848 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
25849 
    if self.orderId is not None:
25850 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25851 
      oprot.writeI64(self.orderId)
25852 
      oprot.writeFieldEnd()
25853 
    oprot.writeFieldStop()
25854 
    oprot.writeStructEnd()
25855 
 
25856 
  def validate(self):
25857 
    return
25858 
 
25859 
 
25860 
  def __repr__(self):
25861 
    L = ['%s=%r' % (key, value)
25862 
      for key, value in self.__dict__.iteritems()]
25863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25864 
 
25865 
  def __eq__(self, other):
25866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25867 
 
25868 
  def __ne__(self, other):
25869 
    return not (self == other)
25870 
 
25871 
class markOrderAsRtoInTransit_result:
25872 
  """
25873 
  Attributes:
25874 
   - success
25875 
  """
25876 
 
25877 
  thrift_spec = (
25878 
    (0, TType.BOOL, 'success', None, None, ), # 0
25879 
  )
25880 
 
25881 
  def __init__(self, success=None,):
25882 
    self.success = success
25883 
 
25884 
  def read(self, iprot):
25885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25887 
      return
25888 
    iprot.readStructBegin()
25889 
    while True:
25890 
      (fname, ftype, fid) = iprot.readFieldBegin()
25891 
      if ftype == TType.STOP:
25892 
        break
25893 
      if fid == 0:
25894 
        if ftype == TType.BOOL:
25895 
          self.success = iprot.readBool();
25896 
        else:
25897 
          iprot.skip(ftype)
25898 
      else:
25899 
        iprot.skip(ftype)
25900 
      iprot.readFieldEnd()
25901 
    iprot.readStructEnd()
25902 
 
25903 
  def write(self, oprot):
25904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25906 
      return
25907 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
25908 
    if self.success is not None:
25909 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25910 
      oprot.writeBool(self.success)
25911 
      oprot.writeFieldEnd()
25912 
    oprot.writeFieldStop()
25913 
    oprot.writeStructEnd()
25914 
 
25915 
  def validate(self):
25916 
    return
25917 
 
25918 
 
25919 
  def __repr__(self):
25920 
    L = ['%s=%r' % (key, value)
25921 
      for key, value in self.__dict__.iteritems()]
25922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25923 
 
25924 
  def __eq__(self, other):
25925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25926 
 
25927 
  def __ne__(self, other):
25928 
    return not (self == other)
25929 
 
5593 mandeep.dh 25930 
class acceptOrderForItem_args:
25931 
  """
25932 
  Attributes:
25933 
   - itemId
25934 
   - quantity
25935 
   - fulfilmentWarehouseId
25936 
   - billingWarehouseId
25937 
  """
25938 
 
25939 
  thrift_spec = (
25940 
    None, # 0
25941 
    (1, TType.I64, 'itemId', None, None, ), # 1
25942 
    (2, TType.I64, 'quantity', None, None, ), # 2
25943 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25944 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25945 
  )
25946 
 
25947 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25948 
    self.itemId = itemId
25949 
    self.quantity = quantity
25950 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25951 
    self.billingWarehouseId = billingWarehouseId
25952 
 
25953 
  def read(self, iprot):
25954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25956 
      return
25957 
    iprot.readStructBegin()
25958 
    while True:
25959 
      (fname, ftype, fid) = iprot.readFieldBegin()
25960 
      if ftype == TType.STOP:
25961 
        break
25962 
      if fid == 1:
25963 
        if ftype == TType.I64:
25964 
          self.itemId = iprot.readI64();
25965 
        else:
25966 
          iprot.skip(ftype)
25967 
      elif fid == 2:
25968 
        if ftype == TType.I64:
25969 
          self.quantity = iprot.readI64();
25970 
        else:
25971 
          iprot.skip(ftype)
25972 
      elif fid == 3:
25973 
        if ftype == TType.I64:
25974 
          self.fulfilmentWarehouseId = iprot.readI64();
25975 
        else:
25976 
          iprot.skip(ftype)
25977 
      elif fid == 4:
25978 
        if ftype == TType.I64:
25979 
          self.billingWarehouseId = iprot.readI64();
25980 
        else:
25981 
          iprot.skip(ftype)
25982 
      else:
25983 
        iprot.skip(ftype)
25984 
      iprot.readFieldEnd()
25985 
    iprot.readStructEnd()
25986 
 
25987 
  def write(self, oprot):
25988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25990 
      return
25991 
    oprot.writeStructBegin('acceptOrderForItem_args')
25992 
    if self.itemId is not None:
25993 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25994 
      oprot.writeI64(self.itemId)
25995 
      oprot.writeFieldEnd()
25996 
    if self.quantity is not None:
25997 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25998 
      oprot.writeI64(self.quantity)
25999 
      oprot.writeFieldEnd()
26000 
    if self.fulfilmentWarehouseId is not None:
26001 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26002 
      oprot.writeI64(self.fulfilmentWarehouseId)
26003 
      oprot.writeFieldEnd()
26004 
    if self.billingWarehouseId is not None:
26005 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26006 
      oprot.writeI64(self.billingWarehouseId)
26007 
      oprot.writeFieldEnd()
26008 
    oprot.writeFieldStop()
26009 
    oprot.writeStructEnd()
26010 
 
26011 
  def validate(self):
26012 
    return
26013 
 
26014 
 
26015 
  def __repr__(self):
26016 
    L = ['%s=%r' % (key, value)
26017 
      for key, value in self.__dict__.iteritems()]
26018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26019 
 
26020 
  def __eq__(self, other):
26021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26022 
 
26023 
  def __ne__(self, other):
26024 
    return not (self == other)
26025 
 
26026 
class acceptOrderForItem_result:
26027 
 
26028 
  thrift_spec = (
26029 
  )
26030 
 
26031 
  def read(self, iprot):
26032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26034 
      return
26035 
    iprot.readStructBegin()
26036 
    while True:
26037 
      (fname, ftype, fid) = iprot.readFieldBegin()
26038 
      if ftype == TType.STOP:
26039 
        break
26040 
      else:
26041 
        iprot.skip(ftype)
26042 
      iprot.readFieldEnd()
26043 
    iprot.readStructEnd()
26044 
 
26045 
  def write(self, oprot):
26046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26048 
      return
26049 
    oprot.writeStructBegin('acceptOrderForItem_result')
26050 
    oprot.writeFieldStop()
26051 
    oprot.writeStructEnd()
26052 
 
26053 
  def validate(self):
26054 
    return
26055 
 
26056 
 
26057 
  def __repr__(self):
26058 
    L = ['%s=%r' % (key, value)
26059 
      for key, value in self.__dict__.iteritems()]
26060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26061 
 
26062 
  def __eq__(self, other):
26063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26064 
 
26065 
  def __ne__(self, other):
26066 
    return not (self == other)
6000 mandeep.dh 26067 
 
26068 
class createRechargeOrder_args:
26069 
  """
26070 
  Attributes:
26071 
   - rechargeOrder
26072 
  """
26073 
 
26074 
  thrift_spec = (
26075 
    None, # 0
26076 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26077 
  )
26078 
 
26079 
  def __init__(self, rechargeOrder=None,):
26080 
    self.rechargeOrder = rechargeOrder
26081 
 
26082 
  def read(self, iprot):
26083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26085 
      return
26086 
    iprot.readStructBegin()
26087 
    while True:
26088 
      (fname, ftype, fid) = iprot.readFieldBegin()
26089 
      if ftype == TType.STOP:
26090 
        break
26091 
      if fid == 1:
26092 
        if ftype == TType.STRUCT:
26093 
          self.rechargeOrder = RechargeOrder()
26094 
          self.rechargeOrder.read(iprot)
26095 
        else:
26096 
          iprot.skip(ftype)
26097 
      else:
26098 
        iprot.skip(ftype)
26099 
      iprot.readFieldEnd()
26100 
    iprot.readStructEnd()
26101 
 
26102 
  def write(self, oprot):
26103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26105 
      return
26106 
    oprot.writeStructBegin('createRechargeOrder_args')
26107 
    if self.rechargeOrder is not None:
26108 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26109 
      self.rechargeOrder.write(oprot)
26110 
      oprot.writeFieldEnd()
26111 
    oprot.writeFieldStop()
26112 
    oprot.writeStructEnd()
26113 
 
26114 
  def validate(self):
26115 
    return
26116 
 
26117 
 
26118 
  def __repr__(self):
26119 
    L = ['%s=%r' % (key, value)
26120 
      for key, value in self.__dict__.iteritems()]
26121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26122 
 
26123 
  def __eq__(self, other):
26124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26125 
 
26126 
  def __ne__(self, other):
26127 
    return not (self == other)
26128 
 
26129 
class createRechargeOrder_result:
26130 
  """
26131 
  Attributes:
26132 
   - success
26133 
   - ex
26134 
  """
26135 
 
26136 
  thrift_spec = (
26137 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26139 
  )
26140 
 
26141 
  def __init__(self, success=None, ex=None,):
26142 
    self.success = success
26143 
    self.ex = ex
26144 
 
26145 
  def read(self, iprot):
26146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26148 
      return
26149 
    iprot.readStructBegin()
26150 
    while True:
26151 
      (fname, ftype, fid) = iprot.readFieldBegin()
26152 
      if ftype == TType.STOP:
26153 
        break
26154 
      if fid == 0:
26155 
        if ftype == TType.STRUCT:
26156 
          self.success = RechargeOrder()
26157 
          self.success.read(iprot)
26158 
        else:
26159 
          iprot.skip(ftype)
26160 
      elif fid == 1:
26161 
        if ftype == TType.STRUCT:
26162 
          self.ex = TransactionServiceException()
26163 
          self.ex.read(iprot)
26164 
        else:
26165 
          iprot.skip(ftype)
26166 
      else:
26167 
        iprot.skip(ftype)
26168 
      iprot.readFieldEnd()
26169 
    iprot.readStructEnd()
26170 
 
26171 
  def write(self, oprot):
26172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26174 
      return
26175 
    oprot.writeStructBegin('createRechargeOrder_result')
26176 
    if self.success is not None:
26177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26178 
      self.success.write(oprot)
26179 
      oprot.writeFieldEnd()
26180 
    if self.ex is not None:
26181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26182 
      self.ex.write(oprot)
26183 
      oprot.writeFieldEnd()
26184 
    oprot.writeFieldStop()
26185 
    oprot.writeStructEnd()
26186 
 
26187 
  def validate(self):
26188 
    return
26189 
 
26190 
 
26191 
  def __repr__(self):
26192 
    L = ['%s=%r' % (key, value)
26193 
      for key, value in self.__dict__.iteritems()]
26194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26195 
 
26196 
  def __eq__(self, other):
26197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26198 
 
26199 
  def __ne__(self, other):
26200 
    return not (self == other)
26201 
 
6031 rajveer 26202 
class getRechargeOrder_args:
26203 
  """
26204 
  Attributes:
26205 
   - rechargeRrderId
26206 
  """
26207 
 
26208 
  thrift_spec = (
26209 
    None, # 0
26210 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26211 
  )
26212 
 
26213 
  def __init__(self, rechargeRrderId=None,):
26214 
    self.rechargeRrderId = rechargeRrderId
26215 
 
26216 
  def read(self, iprot):
26217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26219 
      return
26220 
    iprot.readStructBegin()
26221 
    while True:
26222 
      (fname, ftype, fid) = iprot.readFieldBegin()
26223 
      if ftype == TType.STOP:
26224 
        break
26225 
      if fid == 1:
26226 
        if ftype == TType.I64:
26227 
          self.rechargeRrderId = iprot.readI64();
26228 
        else:
26229 
          iprot.skip(ftype)
26230 
      else:
26231 
        iprot.skip(ftype)
26232 
      iprot.readFieldEnd()
26233 
    iprot.readStructEnd()
26234 
 
26235 
  def write(self, oprot):
26236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26238 
      return
26239 
    oprot.writeStructBegin('getRechargeOrder_args')
26240 
    if self.rechargeRrderId is not None:
26241 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26242 
      oprot.writeI64(self.rechargeRrderId)
26243 
      oprot.writeFieldEnd()
26244 
    oprot.writeFieldStop()
26245 
    oprot.writeStructEnd()
26246 
 
26247 
  def validate(self):
26248 
    return
26249 
 
26250 
 
26251 
  def __repr__(self):
26252 
    L = ['%s=%r' % (key, value)
26253 
      for key, value in self.__dict__.iteritems()]
26254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26255 
 
26256 
  def __eq__(self, other):
26257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26258 
 
26259 
  def __ne__(self, other):
26260 
    return not (self == other)
26261 
 
26262 
class getRechargeOrder_result:
26263 
  """
26264 
  Attributes:
26265 
   - success
26266 
   - ex
26267 
  """
26268 
 
26269 
  thrift_spec = (
26270 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26272 
  )
26273 
 
26274 
  def __init__(self, success=None, ex=None,):
26275 
    self.success = success
26276 
    self.ex = ex
26277 
 
26278 
  def read(self, iprot):
26279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26281 
      return
26282 
    iprot.readStructBegin()
26283 
    while True:
26284 
      (fname, ftype, fid) = iprot.readFieldBegin()
26285 
      if ftype == TType.STOP:
26286 
        break
26287 
      if fid == 0:
26288 
        if ftype == TType.STRUCT:
26289 
          self.success = RechargeOrder()
26290 
          self.success.read(iprot)
26291 
        else:
26292 
          iprot.skip(ftype)
26293 
      elif fid == 1:
26294 
        if ftype == TType.STRUCT:
26295 
          self.ex = TransactionServiceException()
26296 
          self.ex.read(iprot)
26297 
        else:
26298 
          iprot.skip(ftype)
26299 
      else:
26300 
        iprot.skip(ftype)
26301 
      iprot.readFieldEnd()
26302 
    iprot.readStructEnd()
26303 
 
26304 
  def write(self, oprot):
26305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26307 
      return
26308 
    oprot.writeStructBegin('getRechargeOrder_result')
26309 
    if self.success is not None:
26310 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26311 
      self.success.write(oprot)
26312 
      oprot.writeFieldEnd()
26313 
    if self.ex is not None:
26314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26315 
      self.ex.write(oprot)
26316 
      oprot.writeFieldEnd()
26317 
    oprot.writeFieldStop()
26318 
    oprot.writeStructEnd()
26319 
 
26320 
  def validate(self):
26321 
    return
26322 
 
26323 
 
26324 
  def __repr__(self):
26325 
    L = ['%s=%r' % (key, value)
26326 
      for key, value in self.__dict__.iteritems()]
26327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26328 
 
26329 
  def __eq__(self, other):
26330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26331 
 
26332 
  def __ne__(self, other):
26333 
    return not (self == other)
26334 
 
26335 
class getRechargeOrders_args:
26336 
  """
26337 
  Attributes:
26338 
   - userId
26339 
  """
26340 
 
26341 
  thrift_spec = (
26342 
    None, # 0
26343 
    (1, TType.I64, 'userId', None, None, ), # 1
26344 
  )
26345 
 
26346 
  def __init__(self, userId=None,):
26347 
    self.userId = userId
26348 
 
26349 
  def read(self, iprot):
26350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26352 
      return
26353 
    iprot.readStructBegin()
26354 
    while True:
26355 
      (fname, ftype, fid) = iprot.readFieldBegin()
26356 
      if ftype == TType.STOP:
26357 
        break
26358 
      if fid == 1:
26359 
        if ftype == TType.I64:
26360 
          self.userId = iprot.readI64();
26361 
        else:
26362 
          iprot.skip(ftype)
26363 
      else:
26364 
        iprot.skip(ftype)
26365 
      iprot.readFieldEnd()
26366 
    iprot.readStructEnd()
26367 
 
26368 
  def write(self, oprot):
26369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26371 
      return
26372 
    oprot.writeStructBegin('getRechargeOrders_args')
26373 
    if self.userId is not None:
26374 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26375 
      oprot.writeI64(self.userId)
26376 
      oprot.writeFieldEnd()
26377 
    oprot.writeFieldStop()
26378 
    oprot.writeStructEnd()
26379 
 
26380 
  def validate(self):
26381 
    return
26382 
 
26383 
 
26384 
  def __repr__(self):
26385 
    L = ['%s=%r' % (key, value)
26386 
      for key, value in self.__dict__.iteritems()]
26387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26388 
 
26389 
  def __eq__(self, other):
26390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26391 
 
26392 
  def __ne__(self, other):
26393 
    return not (self == other)
26394 
 
26395 
class getRechargeOrders_result:
26396 
  """
26397 
  Attributes:
26398 
   - success
26399 
  """
26400 
 
26401 
  thrift_spec = (
26402 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26403 
  )
26404 
 
26405 
  def __init__(self, success=None,):
26406 
    self.success = success
26407 
 
26408 
  def read(self, iprot):
26409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26411 
      return
26412 
    iprot.readStructBegin()
26413 
    while True:
26414 
      (fname, ftype, fid) = iprot.readFieldBegin()
26415 
      if ftype == TType.STOP:
26416 
        break
26417 
      if fid == 0:
26418 
        if ftype == TType.LIST:
26419 
          self.success = []
26420 
          (_etype616, _size613) = iprot.readListBegin()
26421 
          for _i617 in xrange(_size613):
26422 
            _elem618 = RechargeOrder()
26423 
            _elem618.read(iprot)
26424 
            self.success.append(_elem618)
26425 
          iprot.readListEnd()
26426 
        else:
26427 
          iprot.skip(ftype)
26428 
      else:
26429 
        iprot.skip(ftype)
26430 
      iprot.readFieldEnd()
26431 
    iprot.readStructEnd()
26432 
 
26433 
  def write(self, oprot):
26434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26436 
      return
26437 
    oprot.writeStructBegin('getRechargeOrders_result')
26438 
    if self.success is not None:
26439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26441 
      for iter619 in self.success:
26442 
        iter619.write(oprot)
26443 
      oprot.writeListEnd()
26444 
      oprot.writeFieldEnd()
26445 
    oprot.writeFieldStop()
26446 
    oprot.writeStructEnd()
26447 
 
26448 
  def validate(self):
26449 
    return
26450 
 
26451 
 
26452 
  def __repr__(self):
26453 
    L = ['%s=%r' % (key, value)
26454 
      for key, value in self.__dict__.iteritems()]
26455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26456 
 
26457 
  def __eq__(self, other):
26458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26459 
 
26460 
  def __ne__(self, other):
26461 
    return not (self == other)
26462 
 
6000 mandeep.dh 26463 
class updateRechargeOrderStatus_args:
26464 
  """
26465 
  Attributes:
26466 
   - rechargeOrderId
26467 
   - rechargeOrderStatus
26468 
  """
26469 
 
26470 
  thrift_spec = (
26471 
    None, # 0
26472 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26473 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26474 
  )
26475 
 
26476 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26477 
    self.rechargeOrderId = rechargeOrderId
26478 
    self.rechargeOrderStatus = rechargeOrderStatus
26479 
 
26480 
  def read(self, iprot):
26481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26483 
      return
26484 
    iprot.readStructBegin()
26485 
    while True:
26486 
      (fname, ftype, fid) = iprot.readFieldBegin()
26487 
      if ftype == TType.STOP:
26488 
        break
26489 
      if fid == 1:
26490 
        if ftype == TType.I64:
26491 
          self.rechargeOrderId = iprot.readI64();
26492 
        else:
26493 
          iprot.skip(ftype)
26494 
      elif fid == 2:
26495 
        if ftype == TType.I32:
26496 
          self.rechargeOrderStatus = iprot.readI32();
26497 
        else:
26498 
          iprot.skip(ftype)
26499 
      else:
26500 
        iprot.skip(ftype)
26501 
      iprot.readFieldEnd()
26502 
    iprot.readStructEnd()
26503 
 
26504 
  def write(self, oprot):
26505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26507 
      return
26508 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26509 
    if self.rechargeOrderId is not None:
26510 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26511 
      oprot.writeI64(self.rechargeOrderId)
26512 
      oprot.writeFieldEnd()
26513 
    if self.rechargeOrderStatus is not None:
26514 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26515 
      oprot.writeI32(self.rechargeOrderStatus)
26516 
      oprot.writeFieldEnd()
26517 
    oprot.writeFieldStop()
26518 
    oprot.writeStructEnd()
26519 
 
26520 
  def validate(self):
26521 
    return
26522 
 
26523 
 
26524 
  def __repr__(self):
26525 
    L = ['%s=%r' % (key, value)
26526 
      for key, value in self.__dict__.iteritems()]
26527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26528 
 
26529 
  def __eq__(self, other):
26530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26531 
 
26532 
  def __ne__(self, other):
26533 
    return not (self == other)
26534 
 
26535 
class updateRechargeOrderStatus_result:
26536 
  """
26537 
  Attributes:
6031 rajveer 26538 
   - success
6000 mandeep.dh 26539 
   - ex
26540 
  """
26541 
 
26542 
  thrift_spec = (
6031 rajveer 26543 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26545 
  )
26546 
 
6031 rajveer 26547 
  def __init__(self, success=None, ex=None,):
26548 
    self.success = success
6000 mandeep.dh 26549 
    self.ex = ex
26550 
 
26551 
  def read(self, iprot):
26552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26554 
      return
26555 
    iprot.readStructBegin()
26556 
    while True:
26557 
      (fname, ftype, fid) = iprot.readFieldBegin()
26558 
      if ftype == TType.STOP:
26559 
        break
6031 rajveer 26560 
      if fid == 0:
26561 
        if ftype == TType.BOOL:
26562 
          self.success = iprot.readBool();
26563 
        else:
26564 
          iprot.skip(ftype)
26565 
      elif fid == 1:
6000 mandeep.dh 26566 
        if ftype == TType.STRUCT:
26567 
          self.ex = TransactionServiceException()
26568 
          self.ex.read(iprot)
26569 
        else:
26570 
          iprot.skip(ftype)
26571 
      else:
26572 
        iprot.skip(ftype)
26573 
      iprot.readFieldEnd()
26574 
    iprot.readStructEnd()
26575 
 
26576 
  def write(self, oprot):
26577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26579 
      return
26580 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26581 
    if self.success is not None:
26582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26583 
      oprot.writeBool(self.success)
26584 
      oprot.writeFieldEnd()
6000 mandeep.dh 26585 
    if self.ex is not None:
26586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26587 
      self.ex.write(oprot)
26588 
      oprot.writeFieldEnd()
26589 
    oprot.writeFieldStop()
26590 
    oprot.writeStructEnd()
26591 
 
26592 
  def validate(self):
26593 
    return
26594 
 
26595 
 
26596 
  def __repr__(self):
26597 
    L = ['%s=%r' % (key, value)
26598 
      for key, value in self.__dict__.iteritems()]
26599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26600 
 
26601 
  def __eq__(self, other):
26602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26603 
 
26604 
  def __ne__(self, other):
26605 
    return not (self == other)
26606 
 
26607 
class activateRechargeTxn_args:
26608 
  """
26609 
  Attributes:
6031 rajveer 26610 
   - rechargeOrderId
6000 mandeep.dh 26611 
  """
26612 
 
26613 
  thrift_spec = (
26614 
    None, # 0
6031 rajveer 26615 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26616 
  )
26617 
 
6031 rajveer 26618 
  def __init__(self, rechargeOrderId=None,):
26619 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26620 
 
26621 
  def read(self, iprot):
26622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26624 
      return
26625 
    iprot.readStructBegin()
26626 
    while True:
26627 
      (fname, ftype, fid) = iprot.readFieldBegin()
26628 
      if ftype == TType.STOP:
26629 
        break
26630 
      if fid == 1:
6031 rajveer 26631 
        if ftype == TType.I64:
26632 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26633 
        else:
26634 
          iprot.skip(ftype)
26635 
      else:
26636 
        iprot.skip(ftype)
26637 
      iprot.readFieldEnd()
26638 
    iprot.readStructEnd()
26639 
 
26640 
  def write(self, oprot):
26641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26643 
      return
26644 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26645 
    if self.rechargeOrderId is not None:
26646 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26647 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26648 
      oprot.writeFieldEnd()
26649 
    oprot.writeFieldStop()
26650 
    oprot.writeStructEnd()
26651 
 
26652 
  def validate(self):
26653 
    return
26654 
 
26655 
 
26656 
  def __repr__(self):
26657 
    L = ['%s=%r' % (key, value)
26658 
      for key, value in self.__dict__.iteritems()]
26659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26660 
 
26661 
  def __eq__(self, other):
26662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26663 
 
26664 
  def __ne__(self, other):
26665 
    return not (self == other)
26666 
 
26667 
class activateRechargeTxn_result:
26668 
  """
26669 
  Attributes:
26670 
   - success
26671 
   - ex
26672 
  """
26673 
 
26674 
  thrift_spec = (
6031 rajveer 26675 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26677 
  )
26678 
 
26679 
  def __init__(self, success=None, ex=None,):
26680 
    self.success = success
26681 
    self.ex = ex
26682 
 
26683 
  def read(self, iprot):
26684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26686 
      return
26687 
    iprot.readStructBegin()
26688 
    while True:
26689 
      (fname, ftype, fid) = iprot.readFieldBegin()
26690 
      if ftype == TType.STOP:
26691 
        break
26692 
      if fid == 0:
6031 rajveer 26693 
        if ftype == TType.BOOL:
26694 
          self.success = iprot.readBool();
6000 mandeep.dh 26695 
        else:
26696 
          iprot.skip(ftype)
26697 
      elif fid == 1:
26698 
        if ftype == TType.STRUCT:
26699 
          self.ex = TransactionServiceException()
26700 
          self.ex.read(iprot)
26701 
        else:
26702 
          iprot.skip(ftype)
26703 
      else:
26704 
        iprot.skip(ftype)
26705 
      iprot.readFieldEnd()
26706 
    iprot.readStructEnd()
26707 
 
26708 
  def write(self, oprot):
26709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26711 
      return
26712 
    oprot.writeStructBegin('activateRechargeTxn_result')
26713 
    if self.success is not None:
6031 rajveer 26714 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26715 
      oprot.writeBool(self.success)
6000 mandeep.dh 26716 
      oprot.writeFieldEnd()
26717 
    if self.ex is not None:
26718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26719 
      self.ex.write(oprot)
26720 
      oprot.writeFieldEnd()
26721 
    oprot.writeFieldStop()
26722 
    oprot.writeStructEnd()
26723 
 
26724 
  def validate(self):
26725 
    return
26726 
 
26727 
 
26728 
  def __repr__(self):
26729 
    L = ['%s=%r' % (key, value)
26730 
      for key, value in self.__dict__.iteritems()]
26731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26732 
 
26733 
  def __eq__(self, other):
26734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26735 
 
26736 
  def __ne__(self, other):
26737 
    return not (self == other)
26738 
 
6031 rajveer 26739 
class getUserWallet_args:
6000 mandeep.dh 26740 
  """
26741 
  Attributes:
6031 rajveer 26742 
   - userId
6000 mandeep.dh 26743 
  """
26744 
 
26745 
  thrift_spec = (
26746 
    None, # 0
6031 rajveer 26747 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26748 
  )
26749 
 
6031 rajveer 26750 
  def __init__(self, userId=None,):
26751 
    self.userId = userId
6000 mandeep.dh 26752 
 
26753 
  def read(self, iprot):
26754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26756 
      return
26757 
    iprot.readStructBegin()
26758 
    while True:
26759 
      (fname, ftype, fid) = iprot.readFieldBegin()
26760 
      if ftype == TType.STOP:
26761 
        break
26762 
      if fid == 1:
26763 
        if ftype == TType.I64:
6031 rajveer 26764 
          self.userId = iprot.readI64();
6000 mandeep.dh 26765 
        else:
26766 
          iprot.skip(ftype)
26767 
      else:
26768 
        iprot.skip(ftype)
26769 
      iprot.readFieldEnd()
26770 
    iprot.readStructEnd()
26771 
 
26772 
  def write(self, oprot):
26773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26775 
      return
6031 rajveer 26776 
    oprot.writeStructBegin('getUserWallet_args')
26777 
    if self.userId is not None:
26778 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26779 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26780 
      oprot.writeFieldEnd()
26781 
    oprot.writeFieldStop()
26782 
    oprot.writeStructEnd()
26783 
 
26784 
  def validate(self):
26785 
    return
26786 
 
26787 
 
26788 
  def __repr__(self):
26789 
    L = ['%s=%r' % (key, value)
26790 
      for key, value in self.__dict__.iteritems()]
26791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26792 
 
26793 
  def __eq__(self, other):
26794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26795 
 
26796 
  def __ne__(self, other):
26797 
    return not (self == other)
26798 
 
6031 rajveer 26799 
class getUserWallet_result:
6000 mandeep.dh 26800 
  """
26801 
  Attributes:
26802 
   - success
26803 
  """
26804 
 
26805 
  thrift_spec = (
6031 rajveer 26806 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 26807 
  )
26808 
 
26809 
  def __init__(self, success=None,):
26810 
    self.success = success
26811 
 
26812 
  def read(self, iprot):
26813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26815 
      return
26816 
    iprot.readStructBegin()
26817 
    while True:
26818 
      (fname, ftype, fid) = iprot.readFieldBegin()
26819 
      if ftype == TType.STOP:
26820 
        break
26821 
      if fid == 0:
6031 rajveer 26822 
        if ftype == TType.STRUCT:
26823 
          self.success = UserWallet()
26824 
          self.success.read(iprot)
6000 mandeep.dh 26825 
        else:
26826 
          iprot.skip(ftype)
26827 
      else:
26828 
        iprot.skip(ftype)
26829 
      iprot.readFieldEnd()
26830 
    iprot.readStructEnd()
26831 
 
26832 
  def write(self, oprot):
26833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26835 
      return
6031 rajveer 26836 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 26837 
    if self.success is not None:
6031 rajveer 26838 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26839 
      self.success.write(oprot)
6000 mandeep.dh 26840 
      oprot.writeFieldEnd()
26841 
    oprot.writeFieldStop()
26842 
    oprot.writeStructEnd()
26843 
 
26844 
  def validate(self):
26845 
    return
26846 
 
26847 
 
26848 
  def __repr__(self):
26849 
    L = ['%s=%r' % (key, value)
26850 
      for key, value in self.__dict__.iteritems()]
26851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26852 
 
26853 
  def __eq__(self, other):
26854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26855 
 
26856 
  def __ne__(self, other):
26857 
    return not (self == other)
26858 
 
6031 rajveer 26859 
class getUserWalletHistory_args:
6000 mandeep.dh 26860 
  """
26861 
  Attributes:
6031 rajveer 26862 
   - userId
6000 mandeep.dh 26863 
  """
26864 
 
26865 
  thrift_spec = (
26866 
    None, # 0
6031 rajveer 26867 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26868 
  )
26869 
 
6031 rajveer 26870 
  def __init__(self, userId=None,):
26871 
    self.userId = userId
6000 mandeep.dh 26872 
 
26873 
  def read(self, iprot):
26874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26876 
      return
26877 
    iprot.readStructBegin()
26878 
    while True:
26879 
      (fname, ftype, fid) = iprot.readFieldBegin()
26880 
      if ftype == TType.STOP:
26881 
        break
26882 
      if fid == 1:
26883 
        if ftype == TType.I64:
6031 rajveer 26884 
          self.userId = iprot.readI64();
6000 mandeep.dh 26885 
        else:
26886 
          iprot.skip(ftype)
26887 
      else:
26888 
        iprot.skip(ftype)
26889 
      iprot.readFieldEnd()
26890 
    iprot.readStructEnd()
26891 
 
26892 
  def write(self, oprot):
26893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26895 
      return
6031 rajveer 26896 
    oprot.writeStructBegin('getUserWalletHistory_args')
26897 
    if self.userId is not None:
26898 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26899 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26900 
      oprot.writeFieldEnd()
26901 
    oprot.writeFieldStop()
26902 
    oprot.writeStructEnd()
26903 
 
26904 
  def validate(self):
26905 
    return
26906 
 
26907 
 
26908 
  def __repr__(self):
26909 
    L = ['%s=%r' % (key, value)
26910 
      for key, value in self.__dict__.iteritems()]
26911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26912 
 
26913 
  def __eq__(self, other):
26914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26915 
 
26916 
  def __ne__(self, other):
26917 
    return not (self == other)
26918 
 
6031 rajveer 26919 
class getUserWalletHistory_result:
6000 mandeep.dh 26920 
  """
26921 
  Attributes:
26922 
   - success
26923 
  """
26924 
 
26925 
  thrift_spec = (
6031 rajveer 26926 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 26927 
  )
26928 
 
26929 
  def __init__(self, success=None,):
26930 
    self.success = success
26931 
 
26932 
  def read(self, iprot):
26933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26935 
      return
26936 
    iprot.readStructBegin()
26937 
    while True:
26938 
      (fname, ftype, fid) = iprot.readFieldBegin()
26939 
      if ftype == TType.STOP:
26940 
        break
26941 
      if fid == 0:
26942 
        if ftype == TType.LIST:
26943 
          self.success = []
6031 rajveer 26944 
          (_etype623, _size620) = iprot.readListBegin()
26945 
          for _i624 in xrange(_size620):
26946 
            _elem625 = UserWalletHistory()
26947 
            _elem625.read(iprot)
26948 
            self.success.append(_elem625)
6000 mandeep.dh 26949 
          iprot.readListEnd()
26950 
        else:
26951 
          iprot.skip(ftype)
26952 
      else:
26953 
        iprot.skip(ftype)
26954 
      iprot.readFieldEnd()
26955 
    iprot.readStructEnd()
26956 
 
26957 
  def write(self, oprot):
26958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26960 
      return
6031 rajveer 26961 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 26962 
    if self.success is not None:
26963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 26965 
      for iter626 in self.success:
26966 
        iter626.write(oprot)
6000 mandeep.dh 26967 
      oprot.writeListEnd()
26968 
      oprot.writeFieldEnd()
26969 
    oprot.writeFieldStop()
26970 
    oprot.writeStructEnd()
26971 
 
26972 
  def validate(self):
26973 
    return
26974 
 
26975 
 
26976 
  def __repr__(self):
26977 
    L = ['%s=%r' % (key, value)
26978 
      for key, value in self.__dict__.iteritems()]
26979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26980 
 
26981 
  def __eq__(self, other):
26982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26983 
 
26984 
  def __ne__(self, other):
26985 
    return not (self == other)
6048 rajveer 26986 
 
26987 
class getServiceProviders_args:
26988 
  """
26989 
  Attributes:
26990 
   - rechargeType
26991 
  """
26992 
 
26993 
  thrift_spec = (
26994 
    None, # 0
26995 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
26996 
  )
26997 
 
26998 
  def __init__(self, rechargeType=None,):
26999 
    self.rechargeType = rechargeType
27000 
 
27001 
  def read(self, iprot):
27002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27004 
      return
27005 
    iprot.readStructBegin()
27006 
    while True:
27007 
      (fname, ftype, fid) = iprot.readFieldBegin()
27008 
      if ftype == TType.STOP:
27009 
        break
27010 
      if fid == 1:
27011 
        if ftype == TType.I32:
27012 
          self.rechargeType = iprot.readI32();
27013 
        else:
27014 
          iprot.skip(ftype)
27015 
      else:
27016 
        iprot.skip(ftype)
27017 
      iprot.readFieldEnd()
27018 
    iprot.readStructEnd()
27019 
 
27020 
  def write(self, oprot):
27021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27023 
      return
27024 
    oprot.writeStructBegin('getServiceProviders_args')
27025 
    if self.rechargeType is not None:
27026 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27027 
      oprot.writeI32(self.rechargeType)
27028 
      oprot.writeFieldEnd()
27029 
    oprot.writeFieldStop()
27030 
    oprot.writeStructEnd()
27031 
 
27032 
  def validate(self):
27033 
    return
27034 
 
27035 
 
27036 
  def __repr__(self):
27037 
    L = ['%s=%r' % (key, value)
27038 
      for key, value in self.__dict__.iteritems()]
27039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27040 
 
27041 
  def __eq__(self, other):
27042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27043 
 
27044 
  def __ne__(self, other):
27045 
    return not (self == other)
27046 
 
27047 
class getServiceProviders_result:
27048 
  """
27049 
  Attributes:
27050 
   - success
27051 
  """
27052 
 
27053 
  thrift_spec = (
27054 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27055 
  )
27056 
 
27057 
  def __init__(self, success=None,):
27058 
    self.success = success
27059 
 
27060 
  def read(self, iprot):
27061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27063 
      return
27064 
    iprot.readStructBegin()
27065 
    while True:
27066 
      (fname, ftype, fid) = iprot.readFieldBegin()
27067 
      if ftype == TType.STOP:
27068 
        break
27069 
      if fid == 0:
27070 
        if ftype == TType.MAP:
27071 
          self.success = {}
27072 
          (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin()
27073 
          for _i631 in xrange(_size627):
27074 
            _key632 = iprot.readI64();
27075 
            _val633 = iprot.readString();
27076 
            self.success[_key632] = _val633
27077 
          iprot.readMapEnd()
27078 
        else:
27079 
          iprot.skip(ftype)
27080 
      else:
27081 
        iprot.skip(ftype)
27082 
      iprot.readFieldEnd()
27083 
    iprot.readStructEnd()
27084 
 
27085 
  def write(self, oprot):
27086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27088 
      return
27089 
    oprot.writeStructBegin('getServiceProviders_result')
27090 
    if self.success is not None:
27091 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27092 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
27093 
      for kiter634,viter635 in self.success.items():
27094 
        oprot.writeI64(kiter634)
27095 
        oprot.writeString(viter635)
27096 
      oprot.writeMapEnd()
27097 
      oprot.writeFieldEnd()
27098 
    oprot.writeFieldStop()
27099 
    oprot.writeStructEnd()
27100 
 
27101 
  def validate(self):
27102 
    return
27103 
 
27104 
 
27105 
  def __repr__(self):
27106 
    L = ['%s=%r' % (key, value)
27107 
      for key, value in self.__dict__.iteritems()]
27108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27109 
 
27110 
  def __eq__(self, other):
27111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27112 
 
27113 
  def __ne__(self, other):
27114 
    return not (self == other)
27115 
 
27116 
class getServiceProviderForDevice_args:
27117 
  """
27118 
  Attributes:
27119 
   - deviceNumber
27120 
  """
27121 
 
27122 
  thrift_spec = (
27123 
    None, # 0
27124 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27125 
  )
27126 
 
27127 
  def __init__(self, deviceNumber=None,):
27128 
    self.deviceNumber = deviceNumber
27129 
 
27130 
  def read(self, iprot):
27131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27133 
      return
27134 
    iprot.readStructBegin()
27135 
    while True:
27136 
      (fname, ftype, fid) = iprot.readFieldBegin()
27137 
      if ftype == TType.STOP:
27138 
        break
27139 
      if fid == 1:
27140 
        if ftype == TType.STRING:
27141 
          self.deviceNumber = iprot.readString();
27142 
        else:
27143 
          iprot.skip(ftype)
27144 
      else:
27145 
        iprot.skip(ftype)
27146 
      iprot.readFieldEnd()
27147 
    iprot.readStructEnd()
27148 
 
27149 
  def write(self, oprot):
27150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27152 
      return
27153 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
27154 
    if self.deviceNumber is not None:
27155 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27156 
      oprot.writeString(self.deviceNumber)
27157 
      oprot.writeFieldEnd()
27158 
    oprot.writeFieldStop()
27159 
    oprot.writeStructEnd()
27160 
 
27161 
  def validate(self):
27162 
    return
27163 
 
27164 
 
27165 
  def __repr__(self):
27166 
    L = ['%s=%r' % (key, value)
27167 
      for key, value in self.__dict__.iteritems()]
27168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27169 
 
27170 
  def __eq__(self, other):
27171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27172 
 
27173 
  def __ne__(self, other):
27174 
    return not (self == other)
27175 
 
27176 
class getServiceProviderForDevice_result:
27177 
  """
27178 
  Attributes:
27179 
   - success
27180 
  """
27181 
 
27182 
  thrift_spec = (
27183 
    (0, TType.I64, 'success', None, None, ), # 0
27184 
  )
27185 
 
27186 
  def __init__(self, success=None,):
27187 
    self.success = success
27188 
 
27189 
  def read(self, iprot):
27190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27192 
      return
27193 
    iprot.readStructBegin()
27194 
    while True:
27195 
      (fname, ftype, fid) = iprot.readFieldBegin()
27196 
      if ftype == TType.STOP:
27197 
        break
27198 
      if fid == 0:
27199 
        if ftype == TType.I64:
27200 
          self.success = iprot.readI64();
27201 
        else:
27202 
          iprot.skip(ftype)
27203 
      else:
27204 
        iprot.skip(ftype)
27205 
      iprot.readFieldEnd()
27206 
    iprot.readStructEnd()
27207 
 
27208 
  def write(self, oprot):
27209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27211 
      return
27212 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27213 
    if self.success is not None:
27214 
      oprot.writeFieldBegin('success', TType.I64, 0)
27215 
      oprot.writeI64(self.success)
27216 
      oprot.writeFieldEnd()
27217 
    oprot.writeFieldStop()
27218 
    oprot.writeStructEnd()
27219 
 
27220 
  def validate(self):
27221 
    return
27222 
 
27223 
 
27224 
  def __repr__(self):
27225 
    L = ['%s=%r' % (key, value)
27226 
      for key, value in self.__dict__.iteritems()]
27227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27228 
 
27229 
  def __eq__(self, other):
27230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27231 
 
27232 
  def __ne__(self, other):
27233 
    return not (self == other)